Merge branch 'main' into feat/bonjour

fix: pr review
chore: remove qrcode dependency
2025-12-19 06:30:10 +08:00 · 2025-12-18 12:33:20 +08:00 · 2025-12-18 11:32:13 +08:00 · 2025-12-18 10:48:32 +08:00 · 2025-12-18 10:06:34 +08:00 · 2025-12-18 09:57:23 +08:00
60 changed files with 3694 additions and 1665 deletions
--- a/docs/zh/references/lan-transfer-protocol.md
+++ b/docs/zh/references/lan-transfer-protocol.md
@ -222,52 +222,6 @@ function sendControlMessage(socket: Socket, message: object): void {
 {"type":"message_type",...其他字段...}\n
 ```

-### 4.3 消息发送
-
-```typescript
-function sendMessage(socket: Socket, message: object): void {
-  const payload = JSON.stringify(message);
-  socket.write(`${payload}\n`);
-}
-```
-
-### 4.4 消息接收与解析
-
-```typescript
-let buffer = "";
-
-socket.on("data", (chunk: Buffer) => {
-  buffer += chunk.toString("utf8");
-
-  let newlineIndex = buffer.indexOf("\n");
-  while (newlineIndex !== -1) {
-    const line = buffer.slice(0, newlineIndex).trim();
-    buffer = buffer.slice(newlineIndex + 1);
-
-    if (line.length > 0) {
-      const message = JSON.parse(line);
-      handleMessage(message);
-    }
-
-    newlineIndex = buffer.indexOf("\n");
-  }
-});
-```
-
-### 4.5 消息类型汇总
-
-| 类型             | 方向            | 用途         |
-| ---------------- | --------------- | ------------ |
-| `handshake`      | Client → Server | 握手请求     |
-| `handshake_ack`  | Server → Client | 握手响应     |
-| `ping`           | Client → Server | 心跳请求     |
-| `pong`           | Server → Client | 心跳响应     |
-| `file_start`     | Client → Server | 开始文件传输 |
-| `file_start_ack` | Server → Client | 文件传输确认 |
-| `file_chunk`     | Client → Server | 文件数据块（流式，无 per-chunk ACK） |
-| `file_end`       | Client → Server | 文件传输结束 |
-| `file_complete`  | Server → Client | 传输完成结果 |
-
 ---

 ## 5. 文件传输协议
@ -802,7 +756,7 @@ class FileReceiver {

 ## 附录 A：TypeScript 类型定义

-完整的类型定义位于 `src/types/lanTransfer.ts`：
+完整的类型定义位于 `packages/shared/config/types.ts`：

 ```typescript
 // 握手消息
--- a/electron-builder.yml
+++ b/electron-builder.yml
@ -134,54 +134,38 @@ artifactBuildCompleted: scripts/artifact-build-completed.js
 releaseInfo:
  releaseNotes: |
    <!--LANG:en-->
-    Cherry Studio 1.7.4 - New Browser MCP & Model Updates
+    Cherry Studio 1.7.5 - Filesystem MCP Overhaul & Topic Management

-    This release adds a powerful browser automation MCP server, new web search provider, and model support updates.
+    This release features a completely rewritten filesystem MCP server, new batch topic management, and improved assistant management.

    ✨ New Features
-    - [MCP] Add @cherry/browser CDP MCP server with session management for browser automation
-    - [Web Search] Add ExaMCP free web search provider (no API key required)
-    - [Model] Support GPT 5.2 series models
-    - [Model] Add capabilities support for Doubao Seed Code models (tool calling, reasoning, vision)
-
-    🔧 Improvements
-    - [Translate] Add reasoning effort option to translate service
-    - [i18n] Improve zh-TW Traditional Chinese locale
-    - [Settings] Update MCP Settings layout and styling
+    - [MCP] Rewrite filesystem MCP server with improved tool set (glob, ls, grep, read, write, edit, delete)
+    - [Topics] Add topic manage mode for batch delete and move operations with search functionality
+    - [Assistants] Merge import/subscribe popups and add export to assistant management
+    - [Knowledge] Use prompt injection for forced knowledge base search (faster response times)
+    - [Settings] Add tool use mode setting (prompt/function) to default assistant settings

    🐛 Bug Fixes
-    - [Chat] Fix line numbers being wrongly copied from code blocks
-    - [Translate] Fix default to first supported reasoning effort when translating
-    - [Chat] Fix preserve thinking block in assistant messages
-    - [Web Search] Fix max search result limit
-    - [Embedding] Fix embedding dimensions retrieval for ModernAiProvider
-    - [Chat] Fix token calculation in prompt tool use plugin
-    - [Model] Fix Ollama provider options for Qwen model support
-    - [UI] Fix Chat component marginRight calculation for improved layout
+    - [Model] Correct typo in Gemini 3 Pro Image Preview model name
+    - [Installer] Auto-install VC++ Redistributable without user prompt
+    - [Notes] Fix notes directory validation and default path reset for cross-platform restore
+    - [OAuth] Bind OAuth callback server to localhost (127.0.0.1) for security

    <!--LANG:zh-CN-->
-    Cherry Studio 1.7.4 - 新增浏览器 MCP 与模型更新
+    Cherry Studio 1.7.5 - 文件系统 MCP 重构与话题管理

-    本次更新新增强大的浏览器自动化 MCP 服务器、新的网页搜索提供商以及模型支持更新。
+    本次更新完全重写了文件系统 MCP 服务器，新增批量话题管理功能，并改进了助手管理。

    ✨ 新功能
-    - [MCP] 新增 @cherry/browser CDP MCP 服务器，支持会话管理的浏览器自动化
-    - [网页搜索] 新增 ExaMCP 免费网页搜索提供商（无需 API 密钥）
-    - [模型] 支持 GPT 5.2 系列模型
-    - [模型] 为豆包 Seed Code 模型添加能力支持（工具调用、推理、视觉）
-
-    🔧 功能改进
-    - [翻译] 为翻译服务添加推理强度选项
-    - [国际化] 改进繁体中文（zh-TW）本地化
-    - [设置] 优化 MCP 设置布局和样式
+    - [MCP] 重写文件系统 MCP 服务器，提供改进的工具集（glob、ls、grep、read、write、edit、delete）
+    - [话题] 新增话题管理模式，支持批量删除和移动操作，带搜索功能
+    - [助手] 合并导入/订阅弹窗，并在助手管理中添加导出功能
+    - [知识库] 使用提示词注入进行强制知识库搜索（响应更快）
+    - [设置] 在默认助手设置中添加工具使用模式设置（prompt/function）

    🐛 问题修复
-    - [聊天] 修复代码块中行号被错误复制的问题
-    - [翻译] 修复翻译时默认使用第一个支持的推理强度
-    - [聊天] 修复助手消息中思考块的保留问题
-    - [网页搜索] 修复最大搜索结果数限制
-    - [嵌入] 修复 ModernAiProvider 嵌入维度获取问题
-    - [聊天] 修复提示词工具使用插件的 token 计算问题
-    - [模型] 修复 Ollama 提供商对 Qwen 模型的支持选项
-    - [界面] 修复聊天组件右边距计算以改善布局
+    - [模型] 修正 Gemini 3 Pro Image Preview 模型名称的拼写错误
+    - [安装程序] 自动安装 VC++ 运行库，无需用户确认
+    - [笔记] 修复跨平台恢复场景下的笔记目录验证和默认路径重置逻辑
+    - [OAuth] 将 OAuth 回调服务器绑定到 localhost (127.0.0.1) 以提高安全性
    <!--LANG:END-->
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "CherryStudio",
-  "version": "1.7.4",
+  "version": "1.7.5",
  "private": true,
  "description": "A powerful AI assistant for producer.",
  "main": "./out/main/index.js",
@ -98,10 +98,8 @@
    "node-stream-zip": "^1.15.0",
    "officeparser": "^4.2.0",
    "os-proxy-config": "^1.1.2",
-    "qrcode.react": "^4.2.0",
    "selection-hook": "^1.0.12",
    "sharp": "^0.34.3",
-    "socket.io": "^4.8.1",
    "swagger-jsdoc": "^6.2.8",
    "swagger-ui-express": "^5.0.1",
    "tesseract.js": "patch:tesseract.js@npm%3A6.0.1#~/.yarn/patches/tesseract.js-npm-6.0.1-2562a7e46d.patch",
--- a/packages/shared/IpcChannel.ts
+++ b/packages/shared/IpcChannel.ts
@ -246,6 +246,7 @@ export enum IpcChannel {
  System_GetCpuName = 'system:getCpuName',
  System_CheckGitBash = 'system:checkGitBash',
  System_GetGitBashPath = 'system:getGitBashPath',
+  System_GetGitBashPathInfo = 'system:getGitBashPathInfo',
  System_SetGitBashPath = 'system:setGitBashPath',

  // DevTools
@ -382,13 +383,6 @@ export enum IpcChannel {
  ClaudeCodePlugin_ReadContent = 'claudeCodePlugin:read-content',
  ClaudeCodePlugin_WriteContent = 'claudeCodePlugin:write-content',

-  // WebSocket
-  WebSocket_Start = 'webSocket:start',
-  WebSocket_Stop = 'webSocket:stop',
-  WebSocket_Status = 'webSocket:status',
-  WebSocket_SendFile = 'webSocket:send-file',
-  WebSocket_GetAllCandidates = 'webSocket:get-all-candidates',
-
  // Local Transfer
  LocalTransfer_ListServices = 'local-transfer:list',
  LocalTransfer_StartScan = 'local-transfer:start-scan',
--- a/packages/shared/config/constant.ts
+++ b/packages/shared/config/constant.ts
@ -488,3 +488,11 @@ export const MACOS_TERMINALS_WITH_COMMANDS: TerminalConfigWithCommand[] = [

 // resources/scripts should be maintained manually
 export const HOME_CHERRY_DIR = '.cherrystudio'
+
+// Git Bash path configuration types
+export type GitBashPathSource = 'manual' | 'auto'
+
+export interface GitBashPathInfo {
+  path: string | null
+  source: GitBashPathSource | null
+}
--- a/packages/shared/config/types.ts
+++ b/packages/shared/config/types.ts
@ -161,7 +161,7 @@ export const LAN_TRANSFER_MAX_FILE_SIZE = 500 * 1024 * 1024 // 500MB
 export const LAN_TRANSFER_COMPLETE_TIMEOUT_MS = 60_000 // 60s - wait for file_complete after file_end
 export const LAN_TRANSFER_GLOBAL_TIMEOUT_MS = 10 * 60 * 1000 // 10 minutes - global transfer timeout

-// Binary protocol constants (v3)
+// Binary protocol constants (v1)
 export const LAN_TRANSFER_PROTOCOL_VERSION = '1'
 export const LAN_BINARY_FRAME_MAGIC = 0x4353 // "CS" as uint16
 export const LAN_BINARY_TYPE_FILE_CHUNK = 0x01
@ -182,7 +182,7 @@ export type LanFileStartMessage = {

 /**
 * File chunk data (JSON format)
- * @deprecated Use binary frame format in protocol v2. This type is kept for reference only.
+ * @deprecated Use binary frame format in protocol v1. This type is kept for reference only.
 */
 export type LanFileChunkMessage = {
  type: 'file_chunk'
@ -217,7 +217,7 @@ export type LanFileStartAckMessage = {

 /**
 * Acknowledgment of file chunk received
- * @deprecated Protocol v3 uses streaming mode without per-chunk acknowledgment.
+ * @deprecated Protocol v1 uses streaming mode without per-chunk acknowledgment.
 * This type is kept for backward compatibility reference only.
 */
 export type LanFileChunkAckMessage = {
@ -235,7 +235,7 @@ export type LanFileCompleteMessage = {
  success: boolean
  filePath?: string // Path where file was saved on mobile
  error?: string
-  // v3 enhanced error diagnostics
+  // Enhanced error diagnostics
  errorCode?: 'CHECKSUM_MISMATCH' | 'INCOMPLETE_TRANSFER' | 'DISK_ERROR' | 'CANCELLED'
  receivedChunks?: number
  receivedBytes?: number
--- a/src/main/ipc.ts
+++ b/src/main/ipc.ts
@ -6,7 +6,14 @@ import { loggerService } from '@logger'
 import { isLinux, isMac, isPortable, isWin } from '@main/constant'
 import { generateSignature } from '@main/integration/cherryai'
 import anthropicService from '@main/services/AnthropicService'
-import { findGitBash, getBinaryPath, isBinaryExists, runInstallScript, validateGitBashPath } from '@main/utils/process'
+import {
+  autoDiscoverGitBash,
+  getBinaryPath,
+  getGitBashPathInfo,
+  isBinaryExists,
+  runInstallScript,
+  validateGitBashPath
+} from '@main/utils/process'
 import { handleZoomFactor } from '@main/utils/zoom'
 import type { SpanEntity, TokenUsage } from '@mcp-trace/trace-core'
 import type { UpgradeChannel } from '@shared/config/constant'
@ -76,7 +83,6 @@ import {
 import storeSyncService from './services/StoreSyncService'
 import { themeService } from './services/ThemeService'
 import VertexAIService from './services/VertexAIService'
-import WebSocketService from './services/WebSocketService'
 import { setOpenLinkExternal } from './services/WebviewService'
 import { windowService } from './services/WindowService'
 import { calculateDirectorySize, getResourcePath } from './utils'
@ -502,9 +508,8 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
    }

    try {
-      const customPath = configManager.get(ConfigKeys.GitBashPath) as string | undefined
-      const bashPath = findGitBash(customPath)
-
+      // Use autoDiscoverGitBash to handle auto-discovery and persistence
+      const bashPath = autoDiscoverGitBash()
      if (bashPath) {
        logger.info('Git Bash is available', { path: bashPath })
        return true
@ -527,13 +532,22 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
    return customPath ?? null
  })

+  // Returns { path, source } where source is 'manual' | 'auto' | null
+  ipcMain.handle(IpcChannel.System_GetGitBashPathInfo, () => {
+    return getGitBashPathInfo()
+  })
+
  ipcMain.handle(IpcChannel.System_SetGitBashPath, (_, newPath: string | null) => {
    if (!isWin) {
      return false
    }

    if (!newPath) {
+      // Clear manual setting and re-run auto-discovery
      configManager.set(ConfigKeys.GitBashPath, null)
+      configManager.set(ConfigKeys.GitBashPathSource, null)
+      // Re-run auto-discovery to restore auto-discovered path if available
+      autoDiscoverGitBash()
      return true
    }

@ -542,7 +556,9 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
      return false
    }

+    // Set path with 'manual' source
    configManager.set(ConfigKeys.GitBashPath, validated)
+    configManager.set(ConfigKeys.GitBashPathSource, 'manual')
    return true
  })

@ -1102,13 +1118,6 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
    }
  })

-  // WebSocket
-  ipcMain.handle(IpcChannel.WebSocket_Start, WebSocketService.start)
-  ipcMain.handle(IpcChannel.WebSocket_Stop, WebSocketService.stop)
-  ipcMain.handle(IpcChannel.WebSocket_Status, WebSocketService.getStatus)
-  ipcMain.handle(IpcChannel.WebSocket_SendFile, WebSocketService.sendFile)
-  ipcMain.handle(IpcChannel.WebSocket_GetAllCandidates, WebSocketService.getAllCandidates)
-
  ipcMain.handle(IpcChannel.LocalTransfer_ListServices, () => localTransferService.getState())
  ipcMain.handle(IpcChannel.LocalTransfer_StartScan, () => localTransferService.startDiscovery({ resetList: true }))
  ipcMain.handle(IpcChannel.LocalTransfer_StopScan, () => localTransferService.stopDiscovery())
--- a/src/main/mcpServers/factory.ts
+++ b/src/main/mcpServers/factory.ts
@ -36,7 +36,7 @@ export function createInMemoryMCPServer(
      return new FetchServer().server
    }
    case BuiltinMCPServerNames.filesystem: {
-      return new FileSystemServer(args).server
+      return new FileSystemServer(envs.WORKSPACE_ROOT).server
    }
    case BuiltinMCPServerNames.difyKnowledge: {
      const difyKey = envs.DIFY_KEY
--- a/src/main/mcpServers/filesystem.ts
+++ b/src/main/mcpServers/filesystem.ts
@ -1,652 +0,0 @@
-// port https://github.com/modelcontextprotocol/servers/blob/main/src/filesystem/index.ts
-
-import { loggerService } from '@logger'
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
-import { createTwoFilesPatch } from 'diff'
-import fs from 'fs/promises'
-import { minimatch } from 'minimatch'
-import os from 'os'
-import path from 'path'
-import * as z from 'zod'
-
-const logger = loggerService.withContext('MCP:FileSystemServer')
-
-// Normalize all paths consistently
-function normalizePath(p: string): string {
-  return path.normalize(p)
-}
-
-function expandHome(filepath: string): string {
-  if (filepath.startsWith('~/') || filepath === '~') {
-    return path.join(os.homedir(), filepath.slice(1))
-  }
-  return filepath
-}
-
-// Security utilities
-async function validatePath(allowedDirectories: string[], requestedPath: string): Promise<string> {
-  const expandedPath = expandHome(requestedPath)
-  const absolute = path.isAbsolute(expandedPath)
-    ? path.resolve(expandedPath)
-    : path.resolve(process.cwd(), expandedPath)
-
-  const normalizedRequested = normalizePath(absolute)
-
-  // Check if path is within allowed directories
-  const isAllowed = allowedDirectories.some((dir) => normalizedRequested.startsWith(dir))
-  if (!isAllowed) {
-    throw new Error(
-      `Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectories.join(', ')}`
-    )
-  }
-
-  // Handle symlinks by checking their real path
-  try {
-    const realPath = await fs.realpath(absolute)
-    const normalizedReal = normalizePath(realPath)
-    const isRealPathAllowed = allowedDirectories.some((dir) => normalizedReal.startsWith(dir))
-    if (!isRealPathAllowed) {
-      throw new Error('Access denied - symlink target outside allowed directories')
-    }
-    return realPath
-  } catch (error) {
-    // For new files that don't exist yet, verify parent directory
-    const parentDir = path.dirname(absolute)
-    try {
-      const realParentPath = await fs.realpath(parentDir)
-      const normalizedParent = normalizePath(realParentPath)
-      const isParentAllowed = allowedDirectories.some((dir) => normalizedParent.startsWith(dir))
-      if (!isParentAllowed) {
-        throw new Error('Access denied - parent directory outside allowed directories')
-      }
-      return absolute
-    } catch {
-      throw new Error(`Parent directory does not exist: ${parentDir}`)
-    }
-  }
-}
-
-// Schema definitions
-const ReadFileArgsSchema = z.object({
-  path: z.string()
-})
-
-const ReadMultipleFilesArgsSchema = z.object({
-  paths: z.array(z.string())
-})
-
-const WriteFileArgsSchema = z.object({
-  path: z.string(),
-  content: z.string()
-})
-
-const EditOperation = z.object({
-  oldText: z.string().describe('Text to search for - must match exactly'),
-  newText: z.string().describe('Text to replace with')
-})
-
-const EditFileArgsSchema = z.object({
-  path: z.string(),
-  edits: z.array(EditOperation),
-  dryRun: z.boolean().default(false).describe('Preview changes using git-style diff format')
-})
-
-const CreateDirectoryArgsSchema = z.object({
-  path: z.string()
-})
-
-const ListDirectoryArgsSchema = z.object({
-  path: z.string()
-})
-
-const DirectoryTreeArgsSchema = z.object({
-  path: z.string()
-})
-
-const MoveFileArgsSchema = z.object({
-  source: z.string(),
-  destination: z.string()
-})
-
-const SearchFilesArgsSchema = z.object({
-  path: z.string(),
-  pattern: z.string(),
-  excludePatterns: z.array(z.string()).optional().default([])
-})
-
-const GetFileInfoArgsSchema = z.object({
-  path: z.string()
-})
-
-interface FileInfo {
-  size: number
-  created: Date
-  modified: Date
-  accessed: Date
-  isDirectory: boolean
-  isFile: boolean
-  permissions: string
-}
-
-// Tool implementations
-async function getFileStats(filePath: string): Promise<FileInfo> {
-  const stats = await fs.stat(filePath)
-  return {
-    size: stats.size,
-    created: stats.birthtime,
-    modified: stats.mtime,
-    accessed: stats.atime,
-    isDirectory: stats.isDirectory(),
-    isFile: stats.isFile(),
-    permissions: stats.mode.toString(8).slice(-3)
-  }
-}
-
-async function searchFiles(
-  allowedDirectories: string[],
-  rootPath: string,
-  pattern: string,
-  excludePatterns: string[] = []
-): Promise<string[]> {
-  const results: string[] = []
-
-  async function search(currentPath: string) {
-    const entries = await fs.readdir(currentPath, { withFileTypes: true })
-
-    for (const entry of entries) {
-      const fullPath = path.join(currentPath, entry.name)
-
-      try {
-        // Validate each path before processing
-        await validatePath(allowedDirectories, fullPath)
-
-        // Check if path matches any exclude pattern
-        const relativePath = path.relative(rootPath, fullPath)
-        const shouldExclude = excludePatterns.some((pattern) => {
-          const globPattern = pattern.includes('*') ? pattern : `**/${pattern}/**`
-          return minimatch(relativePath, globPattern, { dot: true })
-        })
-
-        if (shouldExclude) {
-          continue
-        }
-
-        if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
-          results.push(fullPath)
-        }
-
-        if (entry.isDirectory()) {
-          await search(fullPath)
-        }
-      } catch (error) {
-        // Skip invalid paths during search
-      }
-    }
-  }
-
-  await search(rootPath)
-  return results
-}
-
-// file editing and diffing utilities
-function normalizeLineEndings(text: string): string {
-  return text.replace(/\r\n/g, '\n')
-}
-
-function createUnifiedDiff(originalContent: string, newContent: string, filepath: string = 'file'): string {
-  // Ensure consistent line endings for diff
-  const normalizedOriginal = normalizeLineEndings(originalContent)
-  const normalizedNew = normalizeLineEndings(newContent)
-
-  return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, 'original', 'modified')
-}
-
-async function applyFileEdits(
-  filePath: string,
-  edits: Array<{ oldText: string; newText: string }>,
-  dryRun = false
-): Promise<string> {
-  // Read file content and normalize line endings
-  const content = normalizeLineEndings(await fs.readFile(filePath, 'utf-8'))
-
-  // Apply edits sequentially
-  let modifiedContent = content
-  for (const edit of edits) {
-    const normalizedOld = normalizeLineEndings(edit.oldText)
-    const normalizedNew = normalizeLineEndings(edit.newText)
-
-    // If exact match exists, use it
-    if (modifiedContent.includes(normalizedOld)) {
-      modifiedContent = modifiedContent.replace(normalizedOld, normalizedNew)
-      continue
-    }
-
-    // Otherwise, try line-by-line matching with flexibility for whitespace
-    const oldLines = normalizedOld.split('\n')
-    const contentLines = modifiedContent.split('\n')
-    let matchFound = false
-
-    for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
-      const potentialMatch = contentLines.slice(i, i + oldLines.length)
-
-      // Compare lines with normalized whitespace
-      const isMatch = oldLines.every((oldLine, j) => {
-        const contentLine = potentialMatch[j]
-        return oldLine.trim() === contentLine.trim()
-      })
-
-      if (isMatch) {
-        // Preserve original indentation of first line
-        const originalIndent = contentLines[i].match(/^\s*/)?.[0] || ''
-        const newLines = normalizedNew.split('\n').map((line, j) => {
-          if (j === 0) return originalIndent + line.trimStart()
-          // For subsequent lines, try to preserve relative indentation
-          const oldIndent = oldLines[j]?.match(/^\s*/)?.[0] || ''
-          const newIndent = line.match(/^\s*/)?.[0] || ''
-          if (oldIndent && newIndent) {
-            const relativeIndent = newIndent.length - oldIndent.length
-            return originalIndent + ' '.repeat(Math.max(0, relativeIndent)) + line.trimStart()
-          }
-          return line
-        })
-
-        contentLines.splice(i, oldLines.length, ...newLines)
-        modifiedContent = contentLines.join('\n')
-        matchFound = true
-        break
-      }
-    }
-
-    if (!matchFound) {
-      throw new Error(`Could not find exact match for edit:\n${edit.oldText}`)
-    }
-  }
-
-  // Create unified diff
-  const diff = createUnifiedDiff(content, modifiedContent, filePath)
-
-  // Format diff with appropriate number of backticks
-  let numBackticks = 3
-  while (diff.includes('`'.repeat(numBackticks))) {
-    numBackticks++
-  }
-  const formattedDiff = `${'`'.repeat(numBackticks)}diff\n${diff}${'`'.repeat(numBackticks)}\n\n`
-
-  if (!dryRun) {
-    await fs.writeFile(filePath, modifiedContent, 'utf-8')
-  }
-
-  return formattedDiff
-}
-
-class FileSystemServer {
-  public server: Server
-  private allowedDirectories: string[]
-  constructor(allowedDirs: string[]) {
-    if (!Array.isArray(allowedDirs) || allowedDirs.length === 0) {
-      throw new Error('No allowed directories provided, please specify at least one directory in args')
-    }
-
-    this.allowedDirectories = allowedDirs.map((dir) => normalizePath(path.resolve(expandHome(dir))))
-
-    // Validate that all directories exist and are accessible
-    this.validateDirs().catch((error) => {
-      logger.error('Error validating allowed directories:', error)
-      throw new Error(`Error validating allowed directories: ${error}`)
-    })
-
-    this.server = new Server(
-      {
-        name: 'secure-filesystem-server',
-        version: '0.2.0'
-      },
-      {
-        capabilities: {
-          tools: {}
-        }
-      }
-    )
-    this.initialize()
-  }
-
-  async validateDirs() {
-    // Validate that all directories exist and are accessible
-    await Promise.all(
-      this.allowedDirectories.map(async (dir) => {
-        try {
-          const stats = await fs.stat(expandHome(dir))
-          if (!stats.isDirectory()) {
-            logger.error(`Error: ${dir} is not a directory`)
-            throw new Error(`Error: ${dir} is not a directory`)
-          }
-        } catch (error: any) {
-          logger.error(`Error accessing directory ${dir}:`, error)
-          throw new Error(`Error accessing directory ${dir}:`, error)
-        }
-      })
-    )
-  }
-
-  initialize() {
-    // Tool handlers
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: 'read_file',
-            description:
-              'Read the complete contents of a file from the file system. ' +
-              'Handles various text encodings and provides detailed error messages ' +
-              'if the file cannot be read. Use this tool when you need to examine ' +
-              'the contents of a single file. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(ReadFileArgsSchema)
-          },
-          {
-            name: 'read_multiple_files',
-            description:
-              'Read the contents of multiple files simultaneously. This is more ' +
-              'efficient than reading files one by one when you need to analyze ' +
-              "or compare multiple files. Each file's content is returned with its " +
-              "path as a reference. Failed reads for individual files won't stop " +
-              'the entire operation. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(ReadMultipleFilesArgsSchema)
-          },
-          {
-            name: 'write_file',
-            description:
-              'Create a new file or completely overwrite an existing file with new content. ' +
-              'Use with caution as it will overwrite existing files without warning. ' +
-              'Handles text content with proper encoding. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(WriteFileArgsSchema)
-          },
-          {
-            name: 'edit_file',
-            description:
-              'Make line-based edits to a text file. Each edit replaces exact line sequences ' +
-              'with new content. Returns a git-style diff showing the changes made. ' +
-              'Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(EditFileArgsSchema)
-          },
-          {
-            name: 'create_directory',
-            description:
-              'Create a new directory or ensure a directory exists. Can create multiple ' +
-              'nested directories in one operation. If the directory already exists, ' +
-              'this operation will succeed silently. Perfect for setting up directory ' +
-              'structures for projects or ensuring required paths exist. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(CreateDirectoryArgsSchema)
-          },
-          {
-            name: 'list_directory',
-            description:
-              'Get a detailed listing of all files and directories in a specified path. ' +
-              'Results clearly distinguish between files and directories with [FILE] and [DIR] ' +
-              'prefixes. This tool is essential for understanding directory structure and ' +
-              'finding specific files within a directory. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(ListDirectoryArgsSchema)
-          },
-          {
-            name: 'directory_tree',
-            description:
-              'Get a recursive tree view of files and directories as a JSON structure. ' +
-              "Each entry includes 'name', 'type' (file/directory), and 'children' for directories. " +
-              'Files have no children array, while directories always have a children array (which may be empty). ' +
-              'The output is formatted with 2-space indentation for readability. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(DirectoryTreeArgsSchema)
-          },
-          {
-            name: 'move_file',
-            description:
-              'Move or rename files and directories. Can move files between directories ' +
-              'and rename them in a single operation. If the destination exists, the ' +
-              'operation will fail. Works across different directories and can be used ' +
-              'for simple renaming within the same directory. Both source and destination must be within allowed directories.',
-            inputSchema: z.toJSONSchema(MoveFileArgsSchema)
-          },
-          {
-            name: 'search_files',
-            description:
-              'Recursively search for files and directories matching a pattern. ' +
-              'Searches through all subdirectories from the starting path. The search ' +
-              'is case-insensitive and matches partial names. Returns full paths to all ' +
-              "matching items. Great for finding files when you don't know their exact location. " +
-              'Only searches within allowed directories.',
-            inputSchema: z.toJSONSchema(SearchFilesArgsSchema)
-          },
-          {
-            name: 'get_file_info',
-            description:
-              'Retrieve detailed metadata about a file or directory. Returns comprehensive ' +
-              'information including size, creation time, last modified time, permissions, ' +
-              'and type. This tool is perfect for understanding file characteristics ' +
-              'without reading the actual content. Only works within allowed directories.',
-            inputSchema: z.toJSONSchema(GetFileInfoArgsSchema)
-          },
-          {
-            name: 'list_allowed_directories',
-            description:
-              'Returns the list of directories that this server is allowed to access. ' +
-              'Use this to understand which directories are available before trying to access files.',
-            inputSchema: {
-              type: 'object',
-              properties: {},
-              required: []
-            }
-          }
-        ]
-      }
-    })
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params
-
-        switch (name) {
-          case 'read_file': {
-            const parsed = ReadFileArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for read_file: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            const content = await fs.readFile(validPath, 'utf-8')
-            return {
-              content: [{ type: 'text', text: content }]
-            }
-          }
-
-          case 'read_multiple_files': {
-            const parsed = ReadMultipleFilesArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for read_multiple_files: ${parsed.error}`)
-            }
-            const results = await Promise.all(
-              parsed.data.paths.map(async (filePath: string) => {
-                try {
-                  const validPath = await validatePath(this.allowedDirectories, filePath)
-                  const content = await fs.readFile(validPath, 'utf-8')
-                  return `${filePath}:\n${content}\n`
-                } catch (error) {
-                  const errorMessage = error instanceof Error ? error.message : String(error)
-                  return `${filePath}: Error - ${errorMessage}`
-                }
-              })
-            )
-            return {
-              content: [{ type: 'text', text: results.join('\n---\n') }]
-            }
-          }
-
-          case 'write_file': {
-            const parsed = WriteFileArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for write_file: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            await fs.writeFile(validPath, parsed.data.content, 'utf-8')
-            return {
-              content: [{ type: 'text', text: `Successfully wrote to ${parsed.data.path}` }]
-            }
-          }
-
-          case 'edit_file': {
-            const parsed = EditFileArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for edit_file: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            const result = await applyFileEdits(validPath, parsed.data.edits, parsed.data.dryRun)
-            return {
-              content: [{ type: 'text', text: result }]
-            }
-          }
-
-          case 'create_directory': {
-            const parsed = CreateDirectoryArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for create_directory: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            await fs.mkdir(validPath, { recursive: true })
-            return {
-              content: [{ type: 'text', text: `Successfully created directory ${parsed.data.path}` }]
-            }
-          }
-
-          case 'list_directory': {
-            const parsed = ListDirectoryArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for list_directory: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            const entries = await fs.readdir(validPath, { withFileTypes: true })
-            const formatted = entries
-              .map((entry) => `${entry.isDirectory() ? '[DIR]' : '[FILE]'} ${entry.name}`)
-              .join('\n')
-            return {
-              content: [{ type: 'text', text: formatted }]
-            }
-          }
-
-          case 'directory_tree': {
-            const parsed = DirectoryTreeArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for directory_tree: ${parsed.error}`)
-            }
-
-            interface TreeEntry {
-              name: string
-              type: 'file' | 'directory'
-              children?: TreeEntry[]
-            }
-
-            async function buildTree(allowedDirectories: string[], currentPath: string): Promise<TreeEntry[]> {
-              const validPath = await validatePath(allowedDirectories, currentPath)
-              const entries = await fs.readdir(validPath, { withFileTypes: true })
-              const result: TreeEntry[] = []
-
-              for (const entry of entries) {
-                const entryData: TreeEntry = {
-                  name: entry.name,
-                  type: entry.isDirectory() ? 'directory' : 'file'
-                }
-
-                if (entry.isDirectory()) {
-                  const subPath = path.join(currentPath, entry.name)
-                  entryData.children = await buildTree(allowedDirectories, subPath)
-                }
-
-                result.push(entryData)
-              }
-
-              return result
-            }
-
-            const treeData = await buildTree(this.allowedDirectories, parsed.data.path)
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(treeData, null, 2)
-                }
-              ]
-            }
-          }
-
-          case 'move_file': {
-            const parsed = MoveFileArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for move_file: ${parsed.error}`)
-            }
-            const validSourcePath = await validatePath(this.allowedDirectories, parsed.data.source)
-            const validDestPath = await validatePath(this.allowedDirectories, parsed.data.destination)
-            await fs.rename(validSourcePath, validDestPath)
-            return {
-              content: [
-                { type: 'text', text: `Successfully moved ${parsed.data.source} to ${parsed.data.destination}` }
-              ]
-            }
-          }
-
-          case 'search_files': {
-            const parsed = SearchFilesArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for search_files: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            const results = await searchFiles(
-              this.allowedDirectories,
-              validPath,
-              parsed.data.pattern,
-              parsed.data.excludePatterns
-            )
-            return {
-              content: [{ type: 'text', text: results.length > 0 ? results.join('\n') : 'No matches found' }]
-            }
-          }
-
-          case 'get_file_info': {
-            const parsed = GetFileInfoArgsSchema.safeParse(args)
-            if (!parsed.success) {
-              throw new Error(`Invalid arguments for get_file_info: ${parsed.error}`)
-            }
-            const validPath = await validatePath(this.allowedDirectories, parsed.data.path)
-            const info = await getFileStats(validPath)
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: Object.entries(info)
-                    .map(([key, value]) => `${key}: ${value}`)
-                    .join('\n')
-                }
-              ]
-            }
-          }
-
-          case 'list_allowed_directories': {
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: `Allowed directories:\n${this.allowedDirectories.join('\n')}`
-                }
-              ]
-            }
-          }
-
-          default:
-            throw new Error(`Unknown tool: ${name}`)
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error)
-        return {
-          content: [{ type: 'text', text: `Error: ${errorMessage}` }],
-          isError: true
-        }
-      }
-    })
-  }
-}
-
-export default FileSystemServer
--- a/src/main/mcpServers/filesystem/index.ts
+++ b/src/main/mcpServers/filesystem/index.ts
@ -0,0 +1,2 @@
+// Re-export FileSystemServer to maintain existing import pattern
+export { default, FileSystemServer } from './server'
--- a/src/main/mcpServers/filesystem/server.ts
+++ b/src/main/mcpServers/filesystem/server.ts
@ -0,0 +1,118 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+import { app } from 'electron'
+import fs from 'fs/promises'
+import path from 'path'
+
+import {
+  deleteToolDefinition,
+  editToolDefinition,
+  globToolDefinition,
+  grepToolDefinition,
+  handleDeleteTool,
+  handleEditTool,
+  handleGlobTool,
+  handleGrepTool,
+  handleLsTool,
+  handleReadTool,
+  handleWriteTool,
+  lsToolDefinition,
+  readToolDefinition,
+  writeToolDefinition
+} from './tools'
+import { logger } from './types'
+
+export class FileSystemServer {
+  public server: Server
+  private baseDir: string
+
+  constructor(baseDir?: string) {
+    if (baseDir && path.isAbsolute(baseDir)) {
+      this.baseDir = baseDir
+      logger.info(`Using provided baseDir for filesystem MCP: ${baseDir}`)
+    } else {
+      const userData = app.getPath('userData')
+      this.baseDir = path.join(userData, 'Data', 'Workspace')
+      logger.info(`Using default workspace for filesystem MCP baseDir: ${this.baseDir}`)
+    }
+
+    this.server = new Server(
+      {
+        name: 'filesystem-server',
+        version: '2.0.0'
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    )
+
+    this.initialize()
+  }
+
+  async initialize() {
+    try {
+      await fs.mkdir(this.baseDir, { recursive: true })
+    } catch (error) {
+      logger.error('Failed to create filesystem MCP baseDir', { error, baseDir: this.baseDir })
+    }
+
+    // Register tool list handler
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          globToolDefinition,
+          lsToolDefinition,
+          grepToolDefinition,
+          readToolDefinition,
+          editToolDefinition,
+          writeToolDefinition,
+          deleteToolDefinition
+        ]
+      }
+    })
+
+    // Register tool call handler
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        const { name, arguments: args } = request.params
+
+        switch (name) {
+          case 'glob':
+            return await handleGlobTool(args, this.baseDir)
+
+          case 'ls':
+            return await handleLsTool(args, this.baseDir)
+
+          case 'grep':
+            return await handleGrepTool(args, this.baseDir)
+
+          case 'read':
+            return await handleReadTool(args, this.baseDir)
+
+          case 'edit':
+            return await handleEditTool(args, this.baseDir)
+
+          case 'write':
+            return await handleWriteTool(args, this.baseDir)
+
+          case 'delete':
+            return await handleDeleteTool(args, this.baseDir)
+
+          default:
+            throw new Error(`Unknown tool: ${name}`)
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        logger.error(`Tool execution error for ${request.params.name}:`, { error })
+        return {
+          content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+          isError: true
+        }
+      }
+    })
+  }
+}
+
+export default FileSystemServer
--- a/src/main/mcpServers/filesystem/tools/delete.ts
+++ b/src/main/mcpServers/filesystem/tools/delete.ts
@ -0,0 +1,93 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import { logger, validatePath } from '../types'
+
+// Schema definition
+export const DeleteToolSchema = z.object({
+  path: z.string().describe('The path to the file or directory to delete'),
+  recursive: z.boolean().optional().describe('For directories, whether to delete recursively (default: false)')
+})
+
+// Tool definition with detailed description
+export const deleteToolDefinition = {
+  name: 'delete',
+  description: `Deletes a file or directory from the filesystem.
+
+CAUTION: This operation cannot be undone!
+
+- For files: simply provide the path
+- For empty directories: provide the path
+- For non-empty directories: set recursive=true
+- The path must be an absolute path, not a relative path
+- Always verify the path before deleting to avoid data loss`,
+  inputSchema: z.toJSONSchema(DeleteToolSchema)
+}
+
+// Handler implementation
+export async function handleDeleteTool(args: unknown, baseDir: string) {
+  const parsed = DeleteToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for delete: ${parsed.error}`)
+  }
+
+  const targetPath = parsed.data.path
+  const validPath = await validatePath(targetPath, baseDir)
+  const recursive = parsed.data.recursive || false
+
+  // Check if path exists and get stats
+  let stats
+  try {
+    stats = await fs.stat(validPath)
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Path not found: ${targetPath}`)
+    }
+    throw error
+  }
+
+  const isDirectory = stats.isDirectory()
+  const relativePath = path.relative(baseDir, validPath)
+
+  // Perform deletion
+  try {
+    if (isDirectory) {
+      if (recursive) {
+        // Delete directory recursively
+        await fs.rm(validPath, { recursive: true, force: true })
+      } else {
+        // Try to delete empty directory
+        await fs.rmdir(validPath)
+      }
+    } else {
+      // Delete file
+      await fs.unlink(validPath)
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOTEMPTY') {
+      throw new Error(`Directory not empty: ${targetPath}. Use recursive=true to delete non-empty directories.`)
+    }
+    throw new Error(`Failed to delete: ${error.message}`)
+  }
+
+  // Log the operation
+  logger.info('Path deleted', {
+    path: validPath,
+    type: isDirectory ? 'directory' : 'file',
+    recursive: isDirectory ? recursive : undefined
+  })
+
+  // Format output
+  const itemType = isDirectory ? 'Directory' : 'File'
+  const recursiveNote = isDirectory && recursive ? ' (recursive)' : ''
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `${itemType} deleted${recursiveNote}: ${relativePath}`
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/edit.ts
+++ b/src/main/mcpServers/filesystem/tools/edit.ts
@ -0,0 +1,130 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import { logger, replaceWithFuzzyMatch, validatePath } from '../types'
+
+// Schema definition
+export const EditToolSchema = z.object({
+  file_path: z.string().describe('The path to the file to modify'),
+  old_string: z.string().describe('The text to replace'),
+  new_string: z.string().describe('The text to replace it with'),
+  replace_all: z.boolean().optional().default(false).describe('Replace all occurrences of old_string (default false)')
+})
+
+// Tool definition with detailed description
+export const editToolDefinition = {
+  name: 'edit',
+  description: `Performs exact string replacements in files.
+
+- You must use the 'read' tool at least once before editing
+- The file_path must be an absolute path, not a relative path
+- Preserve exact indentation from read output (after the line number prefix)
+- Never include line number prefixes in old_string or new_string
+- ALWAYS prefer editing existing files over creating new ones
+- The edit will FAIL if old_string is not found in the file
+- The edit will FAIL if old_string appears multiple times (provide more context or use replace_all)
+- The edit will FAIL if old_string equals new_string
+- Use replace_all to rename variables or replace all occurrences`,
+  inputSchema: z.toJSONSchema(EditToolSchema)
+}
+
+// Handler implementation
+export async function handleEditTool(args: unknown, baseDir: string) {
+  const parsed = EditToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for edit: ${parsed.error}`)
+  }
+
+  const { file_path: filePath, old_string: oldString, new_string: newString, replace_all: replaceAll } = parsed.data
+
+  // Validate path
+  const validPath = await validatePath(filePath, baseDir)
+
+  // Check if file exists
+  try {
+    const stats = await fs.stat(validPath)
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${filePath}`)
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      // If old_string is empty, this is a create new file operation
+      if (oldString === '') {
+        // Create parent directory if needed
+        const parentDir = path.dirname(validPath)
+        await fs.mkdir(parentDir, { recursive: true })
+
+        // Write the new content
+        await fs.writeFile(validPath, newString, 'utf-8')
+
+        logger.info('File created', { path: validPath })
+
+        const relativePath = path.relative(baseDir, validPath)
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Created new file: ${relativePath}\nLines: ${newString.split('\n').length}`
+            }
+          ]
+        }
+      }
+      throw new Error(`File not found: ${filePath}`)
+    }
+    throw error
+  }
+
+  // Read current content
+  const content = await fs.readFile(validPath, 'utf-8')
+
+  // Handle special case: old_string is empty (create file with content)
+  if (oldString === '') {
+    await fs.writeFile(validPath, newString, 'utf-8')
+
+    logger.info('File overwritten', { path: validPath })
+
+    const relativePath = path.relative(baseDir, validPath)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Overwrote file: ${relativePath}\nLines: ${newString.split('\n').length}`
+        }
+      ]
+    }
+  }
+
+  // Perform the replacement with fuzzy matching
+  const newContent = replaceWithFuzzyMatch(content, oldString, newString, replaceAll)
+
+  // Write the modified content
+  await fs.writeFile(validPath, newContent, 'utf-8')
+
+  logger.info('File edited', {
+    path: validPath,
+    replaceAll
+  })
+
+  // Generate a simple diff summary
+  const oldLines = content.split('\n').length
+  const newLines = newContent.split('\n').length
+  const lineDiff = newLines - oldLines
+
+  const relativePath = path.relative(baseDir, validPath)
+  let diffSummary = `Edited: ${relativePath}`
+  if (lineDiff > 0) {
+    diffSummary += `\n+${lineDiff} lines`
+  } else if (lineDiff < 0) {
+    diffSummary += `\n${lineDiff} lines`
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: diffSummary
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/glob.ts
+++ b/src/main/mcpServers/filesystem/tools/glob.ts
@ -0,0 +1,149 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import type { FileInfo } from '../types'
+import { logger, MAX_FILES_LIMIT, runRipgrep, validatePath } from '../types'
+
+// Schema definition
+export const GlobToolSchema = z.object({
+  pattern: z.string().describe('The glob pattern to match files against'),
+  path: z
+    .string()
+    .optional()
+    .describe('The directory to search in (must be absolute path). Defaults to the base directory')
+})
+
+// Tool definition with detailed description
+export const globToolDefinition = {
+  name: 'glob',
+  description: `Fast file pattern matching tool that works with any codebase size.
+
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching absolute file paths sorted by modification time (newest first)
+- Use this when you need to find files by name patterns
+- Patterns without "/" (e.g., "*.txt") match files at ANY depth in the directory tree
+- Patterns with "/" (e.g., "src/*.ts") match relative to the search path
+- Pattern syntax: * (any chars), ** (any path), {a,b} (alternatives), ? (single char)
+- Results are limited to 100 files
+- The path parameter must be an absolute path if specified
+- If path is not specified, defaults to the base directory
+- IMPORTANT: Omit the path field for the default directory (don't use "undefined" or "null")`,
+  inputSchema: z.toJSONSchema(GlobToolSchema)
+}
+
+// Handler implementation
+export async function handleGlobTool(args: unknown, baseDir: string) {
+  const parsed = GlobToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for glob: ${parsed.error}`)
+  }
+
+  const searchPath = parsed.data.path || baseDir
+  const validPath = await validatePath(searchPath, baseDir)
+
+  // Verify the search directory exists
+  try {
+    const stats = await fs.stat(validPath)
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${validPath}`)
+    }
+  } catch (error: unknown) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      throw new Error(`Directory not found: ${validPath}`)
+    }
+    throw error
+  }
+
+  // Validate pattern
+  const pattern = parsed.data.pattern.trim()
+  if (!pattern) {
+    throw new Error('Pattern cannot be empty')
+  }
+
+  const files: FileInfo[] = []
+  let truncated = false
+
+  // Build ripgrep arguments for file listing using --glob=pattern format
+  const rgArgs: string[] = [
+    '--files',
+    '--follow',
+    '--hidden',
+    `--glob=${pattern}`,
+    '--glob=!.git/*',
+    '--glob=!node_modules/*',
+    '--glob=!dist/*',
+    '--glob=!build/*',
+    '--glob=!__pycache__/*',
+    validPath
+  ]
+
+  // Use ripgrep for file listing
+  logger.debug('Running ripgrep with args', { rgArgs })
+  const rgResult = await runRipgrep(rgArgs)
+  logger.debug('Ripgrep result', {
+    ok: rgResult.ok,
+    exitCode: rgResult.exitCode,
+    stdoutLength: rgResult.stdout.length,
+    stdoutPreview: rgResult.stdout.slice(0, 500)
+  })
+
+  // Process results if we have stdout content
+  // Exit code 2 can indicate partial errors (e.g., permission denied on some dirs) but still have valid results
+  if (rgResult.ok && rgResult.stdout.length > 0) {
+    const lines = rgResult.stdout.split('\n').filter(Boolean)
+    logger.debug('Parsed lines from ripgrep', { lineCount: lines.length, lines })
+
+    for (const line of lines) {
+      if (files.length >= MAX_FILES_LIMIT) {
+        truncated = true
+        break
+      }
+
+      const filePath = line.trim()
+      if (!filePath) continue
+
+      const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(validPath, filePath)
+
+      try {
+        const stats = await fs.stat(absolutePath)
+        files.push({
+          path: absolutePath,
+          type: 'file', // ripgrep --files only returns files
+          size: stats.size,
+          modified: stats.mtime
+        })
+      } catch (error) {
+        logger.debug('Failed to stat file from ripgrep output, skipping', { file: absolutePath, error })
+      }
+    }
+  }
+
+  // Sort by modification time (newest first)
+  files.sort((a, b) => {
+    const aTime = a.modified ? a.modified.getTime() : 0
+    const bTime = b.modified ? b.modified.getTime() : 0
+    return bTime - aTime
+  })
+
+  // Format output - always use absolute paths
+  const output: string[] = []
+  if (files.length === 0) {
+    output.push(`No files found matching pattern "${parsed.data.pattern}" in ${validPath}`)
+  } else {
+    output.push(...files.map((f) => f.path))
+    if (truncated) {
+      output.push('')
+      output.push(`(Results truncated to ${MAX_FILES_LIMIT} files. Consider using a more specific pattern.)`)
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: output.join('\n')
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/grep.ts
+++ b/src/main/mcpServers/filesystem/tools/grep.ts
@ -0,0 +1,266 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import type { GrepMatch } from '../types'
+import { isBinaryFile, MAX_GREP_MATCHES, MAX_LINE_LENGTH, runRipgrep, validatePath } from '../types'
+
+// Schema definition
+export const GrepToolSchema = z.object({
+  pattern: z.string().describe('The regex pattern to search for in file contents'),
+  path: z
+    .string()
+    .optional()
+    .describe('The directory to search in (must be absolute path). Defaults to the base directory'),
+  include: z.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")')
+})
+
+// Tool definition with detailed description
+export const grepToolDefinition = {
+  name: 'grep',
+  description: `Fast content search tool that works with any codebase size.
+
+- Searches file contents using regular expressions
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files by pattern with include (e.g., "*.js", "*.{ts,tsx}")
+- Returns absolute file paths and line numbers with matching content
+- Results are limited to 100 matches
+- Binary files are automatically skipped
+- Common directories (node_modules, .git, dist) are excluded
+- The path parameter must be an absolute path if specified
+- If path is not specified, defaults to the base directory`,
+  inputSchema: z.toJSONSchema(GrepToolSchema)
+}
+
+// Handler implementation
+export async function handleGrepTool(args: unknown, baseDir: string) {
+  const parsed = GrepToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for grep: ${parsed.error}`)
+  }
+
+  const data = parsed.data
+
+  if (!data.pattern) {
+    throw new Error('Pattern is required for grep')
+  }
+
+  const searchPath = data.path || baseDir
+  const validPath = await validatePath(searchPath, baseDir)
+
+  const matches: GrepMatch[] = []
+  let truncated = false
+  let regex: RegExp
+
+  // Build ripgrep arguments
+  const rgArgs: string[] = [
+    '--no-heading',
+    '--line-number',
+    '--color',
+    'never',
+    '--ignore-case',
+    '--glob',
+    '!.git/**',
+    '--glob',
+    '!node_modules/**',
+    '--glob',
+    '!dist/**',
+    '--glob',
+    '!build/**',
+    '--glob',
+    '!__pycache__/**'
+  ]
+
+  if (data.include) {
+    for (const pat of data.include
+      .split(',')
+      .map((p) => p.trim())
+      .filter(Boolean)) {
+      rgArgs.push('--glob', pat)
+    }
+  }
+
+  rgArgs.push(data.pattern)
+  rgArgs.push(validPath)
+
+  try {
+    regex = new RegExp(data.pattern, 'gi')
+  } catch (error) {
+    throw new Error(`Invalid regex pattern: ${data.pattern}`)
+  }
+
+  async function searchFile(filePath: string): Promise<void> {
+    if (matches.length >= MAX_GREP_MATCHES) {
+      truncated = true
+      return
+    }
+
+    try {
+      // Skip binary files
+      if (await isBinaryFile(filePath)) {
+        return
+      }
+
+      const content = await fs.readFile(filePath, 'utf-8')
+      const lines = content.split('\n')
+
+      lines.forEach((line, index) => {
+        if (matches.length >= MAX_GREP_MATCHES) {
+          truncated = true
+          return
+        }
+
+        if (regex.test(line)) {
+          // Truncate long lines
+          const truncatedLine = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + '...' : line
+
+          matches.push({
+            file: filePath,
+            line: index + 1,
+            content: truncatedLine.trim()
+          })
+        }
+      })
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+
+  async function searchDirectory(dir: string): Promise<void> {
+    if (matches.length >= MAX_GREP_MATCHES) {
+      truncated = true
+      return
+    }
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (matches.length >= MAX_GREP_MATCHES) {
+          truncated = true
+          break
+        }
+
+        const fullPath = path.join(dir, entry.name)
+
+        // Skip common ignore patterns
+        if (entry.name.startsWith('.') && entry.name !== '.env.example') {
+          continue
+        }
+        if (['node_modules', 'dist', 'build', '__pycache__', '.git'].includes(entry.name)) {
+          continue
+        }
+
+        if (entry.isFile()) {
+          // Check if file matches include pattern
+          if (data.include) {
+            const includePatterns = data.include.split(',').map((p) => p.trim())
+            const fileName = path.basename(fullPath)
+            const matchesInclude = includePatterns.some((pattern) => {
+              // Simple glob pattern matching
+              const regexPattern = pattern
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.')
+                .replace(/\{([^}]+)\}/g, (_, group) => `(${group.split(',').join('|')})`)
+              return new RegExp(`^${regexPattern}$`).test(fileName)
+            })
+            if (!matchesInclude) {
+              continue
+            }
+          }
+
+          await searchFile(fullPath)
+        } else if (entry.isDirectory()) {
+          await searchDirectory(fullPath)
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+  }
+
+  // Perform the search
+  let usedRipgrep = false
+  try {
+    const rgResult = await runRipgrep(rgArgs)
+    if (rgResult.ok && rgResult.exitCode !== null && rgResult.exitCode !== 2) {
+      usedRipgrep = true
+      const lines = rgResult.stdout.split('\n').filter(Boolean)
+      for (const line of lines) {
+        if (matches.length >= MAX_GREP_MATCHES) {
+          truncated = true
+          break
+        }
+
+        const firstColon = line.indexOf(':')
+        const secondColon = line.indexOf(':', firstColon + 1)
+        if (firstColon === -1 || secondColon === -1) continue
+
+        const filePart = line.slice(0, firstColon)
+        const linePart = line.slice(firstColon + 1, secondColon)
+        const contentPart = line.slice(secondColon + 1)
+        const lineNum = Number.parseInt(linePart, 10)
+        if (!Number.isFinite(lineNum)) continue
+
+        const absoluteFilePath = path.isAbsolute(filePart) ? filePart : path.resolve(baseDir, filePart)
+        const truncatedLine =
+          contentPart.length > MAX_LINE_LENGTH ? contentPart.substring(0, MAX_LINE_LENGTH) + '...' : contentPart
+
+        matches.push({
+          file: absoluteFilePath,
+          line: lineNum,
+          content: truncatedLine.trim()
+        })
+      }
+    }
+  } catch {
+    usedRipgrep = false
+  }
+
+  if (!usedRipgrep) {
+    const stats = await fs.stat(validPath)
+    if (stats.isFile()) {
+      await searchFile(validPath)
+    } else {
+      await searchDirectory(validPath)
+    }
+  }
+
+  // Format output
+  const output: string[] = []
+
+  if (matches.length === 0) {
+    output.push('No matches found')
+  } else {
+    // Group matches by file
+    const fileGroups = new Map<string, GrepMatch[]>()
+    matches.forEach((match) => {
+      if (!fileGroups.has(match.file)) {
+        fileGroups.set(match.file, [])
+      }
+      fileGroups.get(match.file)!.push(match)
+    })
+
+    // Format grouped matches - always use absolute paths
+    fileGroups.forEach((fileMatches, filePath) => {
+      output.push(`\n${filePath}:`)
+      fileMatches.forEach((match) => {
+        output.push(`  ${match.line}: ${match.content}`)
+      })
+    })
+
+    if (truncated) {
+      output.push('')
+      output.push(`(Results truncated to ${MAX_GREP_MATCHES} matches. Consider using a more specific pattern or path.)`)
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: output.join('\n')
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/index.ts
+++ b/src/main/mcpServers/filesystem/tools/index.ts
@ -0,0 +1,8 @@
+// Export all tool definitions and handlers
+export { deleteToolDefinition, handleDeleteTool } from './delete'
+export { editToolDefinition, handleEditTool } from './edit'
+export { globToolDefinition, handleGlobTool } from './glob'
+export { grepToolDefinition, handleGrepTool } from './grep'
+export { handleLsTool, lsToolDefinition } from './ls'
+export { handleReadTool, readToolDefinition } from './read'
+export { handleWriteTool, writeToolDefinition } from './write'
--- a/src/main/mcpServers/filesystem/tools/ls.ts
+++ b/src/main/mcpServers/filesystem/tools/ls.ts
@ -0,0 +1,150 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import { MAX_FILES_LIMIT, validatePath } from '../types'
+
+// Schema definition
+export const LsToolSchema = z.object({
+  path: z.string().optional().describe('The directory to list (must be absolute path). Defaults to the base directory'),
+  recursive: z.boolean().optional().describe('Whether to list directories recursively (default: false)')
+})
+
+// Tool definition with detailed description
+export const lsToolDefinition = {
+  name: 'ls',
+  description: `Lists files and directories in a specified path.
+
+- Returns a tree-like structure with icons (📁 directories, 📄 files)
+- Shows the absolute directory path in the header
+- Entries are sorted alphabetically with directories first
+- Can list recursively with recursive=true (up to 5 levels deep)
+- Common directories (node_modules, dist, .git) are excluded
+- Hidden files (starting with .) are excluded except .env.example
+- Results are limited to 100 entries
+- The path parameter must be an absolute path if specified
+- If path is not specified, defaults to the base directory`,
+  inputSchema: z.toJSONSchema(LsToolSchema)
+}
+
+// Handler implementation
+export async function handleLsTool(args: unknown, baseDir: string) {
+  const parsed = LsToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for ls: ${parsed.error}`)
+  }
+
+  const targetPath = parsed.data.path || baseDir
+  const validPath = await validatePath(targetPath, baseDir)
+  const recursive = parsed.data.recursive || false
+
+  interface TreeNode {
+    name: string
+    type: 'file' | 'directory'
+    children?: TreeNode[]
+  }
+
+  let fileCount = 0
+  let truncated = false
+
+  async function buildTree(dirPath: string, depth: number = 0): Promise<TreeNode[]> {
+    if (fileCount >= MAX_FILES_LIMIT) {
+      truncated = true
+      return []
+    }
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true })
+      const nodes: TreeNode[] = []
+
+      // Sort entries: directories first, then files, alphabetically
+      entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1
+        if (!a.isDirectory() && b.isDirectory()) return 1
+        return a.name.localeCompare(b.name)
+      })
+
+      for (const entry of entries) {
+        if (fileCount >= MAX_FILES_LIMIT) {
+          truncated = true
+          break
+        }
+
+        // Skip hidden files and common ignore patterns
+        if (entry.name.startsWith('.') && entry.name !== '.env.example') {
+          continue
+        }
+        if (['node_modules', 'dist', 'build', '__pycache__'].includes(entry.name)) {
+          continue
+        }
+
+        fileCount++
+        const node: TreeNode = {
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : 'file'
+        }
+
+        if (entry.isDirectory() && recursive && depth < 5) {
+          // Limit depth to prevent infinite recursion
+          const childPath = path.join(dirPath, entry.name)
+          node.children = await buildTree(childPath, depth + 1)
+        }
+
+        nodes.push(node)
+      }
+
+      return nodes
+    } catch (error) {
+      return []
+    }
+  }
+
+  // Build the tree
+  const tree = await buildTree(validPath)
+
+  // Format as text output
+  function formatTree(nodes: TreeNode[], prefix: string = ''): string[] {
+    const lines: string[] = []
+
+    nodes.forEach((node, index) => {
+      const isLastNode = index === nodes.length - 1
+      const connector = isLastNode ? '└── ' : '├── '
+      const icon = node.type === 'directory' ? '📁 ' : '📄 '
+
+      lines.push(prefix + connector + icon + node.name)
+
+      if (node.children && node.children.length > 0) {
+        const childPrefix = prefix + (isLastNode ? '    ' : '│   ')
+        lines.push(...formatTree(node.children, childPrefix))
+      }
+    })
+
+    return lines
+  }
+
+  // Generate output
+  const output: string[] = []
+  output.push(`Directory: ${validPath}`)
+  output.push('')
+
+  if (tree.length === 0) {
+    output.push('(empty directory)')
+  } else {
+    const treeLines = formatTree(tree, '')
+    output.push(...treeLines)
+
+    if (truncated) {
+      output.push('')
+      output.push(`(Results truncated to ${MAX_FILES_LIMIT} files. Consider listing a more specific directory.)`)
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: output.join('\n')
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/read.ts
+++ b/src/main/mcpServers/filesystem/tools/read.ts
@ -0,0 +1,101 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import { DEFAULT_READ_LIMIT, isBinaryFile, MAX_LINE_LENGTH, validatePath } from '../types'
+
+// Schema definition
+export const ReadToolSchema = z.object({
+  file_path: z.string().describe('The path to the file to read'),
+  offset: z.number().optional().describe('The line number to start reading from (1-based)'),
+  limit: z.number().optional().describe('The number of lines to read (defaults to 2000)')
+})
+
+// Tool definition with detailed description
+export const readToolDefinition = {
+  name: 'read',
+  description: `Reads a file from the local filesystem.
+
+- Assumes this tool can read all files on the machine
+- The file_path parameter must be an absolute path, not a relative path
+- By default, reads up to 2000 lines starting from the beginning
+- You can optionally specify a line offset and limit for long files
+- Any lines longer than 2000 characters will be truncated
+- Results are returned with line numbers starting at 1
+- Binary files are detected and rejected with an error
+- Empty files return a warning`,
+  inputSchema: z.toJSONSchema(ReadToolSchema)
+}
+
+// Handler implementation
+export async function handleReadTool(args: unknown, baseDir: string) {
+  const parsed = ReadToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for read: ${parsed.error}`)
+  }
+
+  const filePath = parsed.data.file_path
+  const validPath = await validatePath(filePath, baseDir)
+
+  // Check if file exists
+  try {
+    const stats = await fs.stat(validPath)
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${filePath}`)
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`File not found: ${filePath}`)
+    }
+    throw error
+  }
+
+  // Check if file is binary
+  if (await isBinaryFile(validPath)) {
+    throw new Error(`Cannot read binary file: ${filePath}`)
+  }
+
+  // Read file content
+  const content = await fs.readFile(validPath, 'utf-8')
+  const lines = content.split('\n')
+
+  // Apply offset and limit
+  const offset = (parsed.data.offset || 1) - 1 // Convert to 0-based
+  const limit = parsed.data.limit || DEFAULT_READ_LIMIT
+
+  if (offset < 0 || offset >= lines.length) {
+    throw new Error(`Invalid offset: ${offset + 1}. File has ${lines.length} lines.`)
+  }
+
+  const selectedLines = lines.slice(offset, offset + limit)
+
+  // Format output with line numbers and truncate long lines
+  const output: string[] = []
+  const relativePath = path.relative(baseDir, validPath)
+
+  output.push(`File: ${relativePath}`)
+  if (offset > 0 || limit < lines.length) {
+    output.push(`Lines ${offset + 1} to ${Math.min(offset + limit, lines.length)} of ${lines.length}`)
+  }
+  output.push('')
+
+  selectedLines.forEach((line, index) => {
+    const lineNumber = offset + index + 1
+    const truncatedLine = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + '...' : line
+    output.push(`${lineNumber.toString().padStart(6)}\t${truncatedLine}`)
+  })
+
+  if (offset + limit < lines.length) {
+    output.push('')
+    output.push(`(${lines.length - (offset + limit)} more lines not shown)`)
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: output.join('\n')
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/tools/write.ts
+++ b/src/main/mcpServers/filesystem/tools/write.ts
@ -0,0 +1,83 @@
+import fs from 'fs/promises'
+import path from 'path'
+import * as z from 'zod'
+
+import { logger, validatePath } from '../types'
+
+// Schema definition
+export const WriteToolSchema = z.object({
+  file_path: z.string().describe('The path to the file to write'),
+  content: z.string().describe('The content to write to the file')
+})
+
+// Tool definition with detailed description
+export const writeToolDefinition = {
+  name: 'write',
+  description: `Writes a file to the local filesystem.
+
+- This tool will overwrite the existing file if one exists at the path
+- You MUST use the read tool first to understand what you're overwriting
+- ALWAYS prefer using the 'edit' tool for existing files
+- NEVER proactively create documentation files unless explicitly requested
+- Parent directories will be created automatically if they don't exist
+- The file_path must be an absolute path, not a relative path`,
+  inputSchema: z.toJSONSchema(WriteToolSchema)
+}
+
+// Handler implementation
+export async function handleWriteTool(args: unknown, baseDir: string) {
+  const parsed = WriteToolSchema.safeParse(args)
+  if (!parsed.success) {
+    throw new Error(`Invalid arguments for write: ${parsed.error}`)
+  }
+
+  const filePath = parsed.data.file_path
+  const validPath = await validatePath(filePath, baseDir)
+
+  // Create parent directory if it doesn't exist
+  const parentDir = path.dirname(validPath)
+  try {
+    await fs.mkdir(parentDir, { recursive: true })
+  } catch (error: any) {
+    if (error.code !== 'EEXIST') {
+      throw new Error(`Failed to create parent directory: ${error.message}`)
+    }
+  }
+
+  // Check if file exists (for logging)
+  let isOverwrite = false
+  try {
+    await fs.stat(validPath)
+    isOverwrite = true
+  } catch {
+    // File doesn't exist, that's fine
+  }
+
+  // Write the file
+  try {
+    await fs.writeFile(validPath, parsed.data.content, 'utf-8')
+  } catch (error: any) {
+    throw new Error(`Failed to write file: ${error.message}`)
+  }
+
+  // Log the operation
+  logger.info('File written', {
+    path: validPath,
+    overwrite: isOverwrite,
+    size: parsed.data.content.length
+  })
+
+  // Format output
+  const relativePath = path.relative(baseDir, validPath)
+  const action = isOverwrite ? 'Updated' : 'Created'
+  const lines = parsed.data.content.split('\n').length
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `${action} file: ${relativePath}\n` + `Size: ${parsed.data.content.length} bytes\n` + `Lines: ${lines}`
+      }
+    ]
+  }
+}
--- a/src/main/mcpServers/filesystem/types.ts
+++ b/src/main/mcpServers/filesystem/types.ts
@ -0,0 +1,627 @@
+import { loggerService } from '@logger'
+import { isMac, isWin } from '@main/constant'
+import { spawn } from 'child_process'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+export const logger = loggerService.withContext('MCP:FileSystemServer')
+
+// Constants
+export const MAX_LINE_LENGTH = 2000
+export const DEFAULT_READ_LIMIT = 2000
+export const MAX_FILES_LIMIT = 100
+export const MAX_GREP_MATCHES = 100
+
+// Common types
+export interface FileInfo {
+  path: string
+  type: 'file' | 'directory'
+  size?: number
+  modified?: Date
+}
+
+export interface GrepMatch {
+  file: string
+  line: number
+  content: string
+}
+
+// Utility functions for path handling
+export function normalizePath(p: string): string {
+  return path.normalize(p)
+}
+
+export function expandHome(filepath: string): string {
+  if (filepath.startsWith('~/') || filepath === '~') {
+    return path.join(os.homedir(), filepath.slice(1))
+  }
+  return filepath
+}
+
+// Security validation
+export async function validatePath(requestedPath: string, baseDir?: string): Promise<string> {
+  const expandedPath = expandHome(requestedPath)
+  const root = baseDir ?? process.cwd()
+  const absolute = path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(root, expandedPath)
+
+  // Handle symlinks by checking their real path
+  try {
+    const realPath = await fs.realpath(absolute)
+    return normalizePath(realPath)
+  } catch (error) {
+    // For new files that don't exist yet, verify parent directory
+    const parentDir = path.dirname(absolute)
+    try {
+      const realParentPath = await fs.realpath(parentDir)
+      normalizePath(realParentPath)
+      return normalizePath(absolute)
+    } catch {
+      return normalizePath(absolute)
+    }
+  }
+}
+
+// ============================================================================
+// Edit Tool Utilities - Fuzzy matching replacers from opencode
+// ============================================================================
+
+export type Replacer = (content: string, find: string) => Generator<string, void, unknown>
+
+// Similarity thresholds for block anchor fallback matching
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3
+
+/**
+ * Levenshtein distance algorithm implementation
+ */
+function levenshtein(a: string, b: string): number {
+  if (a === '' || b === '') {
+    return Math.max(a.length, b.length)
+  }
+  const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+    Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0))
+  )
+
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+    }
+  }
+  return matrix[a.length][b.length]
+}
+
+export const SimpleReplacer: Replacer = function* (_content, find) {
+  yield find
+}
+
+export const LineTrimmedReplacer: Replacer = function* (content, find) {
+  const originalLines = content.split('\n')
+  const searchLines = find.split('\n')
+
+  if (searchLines[searchLines.length - 1] === '') {
+    searchLines.pop()
+  }
+
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true
+
+    for (let j = 0; j < searchLines.length; j++) {
+      const originalTrimmed = originalLines[i + j].trim()
+      const searchTrimmed = searchLines[j].trim()
+
+      if (originalTrimmed !== searchTrimmed) {
+        matches = false
+        break
+      }
+    }
+
+    if (matches) {
+      let matchStartIndex = 0
+      for (let k = 0; k < i; k++) {
+        matchStartIndex += originalLines[k].length + 1
+      }
+
+      let matchEndIndex = matchStartIndex
+      for (let k = 0; k < searchLines.length; k++) {
+        matchEndIndex += originalLines[i + k].length
+        if (k < searchLines.length - 1) {
+          matchEndIndex += 1
+        }
+      }
+
+      yield content.substring(matchStartIndex, matchEndIndex)
+    }
+  }
+}
+
+export const BlockAnchorReplacer: Replacer = function* (content, find) {
+  const originalLines = content.split('\n')
+  const searchLines = find.split('\n')
+
+  if (searchLines.length < 3) {
+    return
+  }
+
+  if (searchLines[searchLines.length - 1] === '') {
+    searchLines.pop()
+  }
+
+  const firstLineSearch = searchLines[0].trim()
+  const lastLineSearch = searchLines[searchLines.length - 1].trim()
+  const searchBlockSize = searchLines.length
+
+  const candidates: Array<{ startLine: number; endLine: number }> = []
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstLineSearch) {
+      continue
+    }
+
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastLineSearch) {
+        candidates.push({ startLine: i, endLine: j })
+        break
+      }
+    }
+  }
+
+  if (candidates.length === 0) {
+    return
+  }
+
+  if (candidates.length === 1) {
+    const { startLine, endLine } = candidates[0]
+    const actualBlockSize = endLine - startLine + 1
+
+    let similarity = 0
+    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2)
+
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim()
+        const searchLine = searchLines[j].trim()
+        const maxLen = Math.max(originalLine.length, searchLine.length)
+        if (maxLen === 0) {
+          continue
+        }
+        const distance = levenshtein(originalLine, searchLine)
+        similarity += (1 - distance / maxLen) / linesToCheck
+
+        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+          break
+        }
+      }
+    } else {
+      similarity = 1.0
+    }
+
+    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+      let matchStartIndex = 0
+      for (let k = 0; k < startLine; k++) {
+        matchStartIndex += originalLines[k].length + 1
+      }
+      let matchEndIndex = matchStartIndex
+      for (let k = startLine; k <= endLine; k++) {
+        matchEndIndex += originalLines[k].length
+        if (k < endLine) {
+          matchEndIndex += 1
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex)
+    }
+    return
+  }
+
+  let bestMatch: { startLine: number; endLine: number } | null = null
+  let maxSimilarity = -1
+
+  for (const candidate of candidates) {
+    const { startLine, endLine } = candidate
+    const actualBlockSize = endLine - startLine + 1
+
+    let similarity = 0
+    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2)
+
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim()
+        const searchLine = searchLines[j].trim()
+        const maxLen = Math.max(originalLine.length, searchLine.length)
+        if (maxLen === 0) {
+          continue
+        }
+        const distance = levenshtein(originalLine, searchLine)
+        similarity += 1 - distance / maxLen
+      }
+      similarity /= linesToCheck
+    } else {
+      similarity = 1.0
+    }
+
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity
+      bestMatch = candidate
+    }
+  }
+
+  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+    const { startLine, endLine } = bestMatch
+    let matchStartIndex = 0
+    for (let k = 0; k < startLine; k++) {
+      matchStartIndex += originalLines[k].length + 1
+    }
+    let matchEndIndex = matchStartIndex
+    for (let k = startLine; k <= endLine; k++) {
+      matchEndIndex += originalLines[k].length
+      if (k < endLine) {
+        matchEndIndex += 1
+      }
+    }
+    yield content.substring(matchStartIndex, matchEndIndex)
+  }
+}
+
+export const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
+  const normalizeWhitespace = (text: string) => text.replace(/\s+/g, ' ').trim()
+  const normalizedFind = normalizeWhitespace(find)
+
+  const lines = content.split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (normalizeWhitespace(line) === normalizedFind) {
+      yield line
+    } else {
+      const normalizedLine = normalizeWhitespace(line)
+      if (normalizedLine.includes(normalizedFind)) {
+        const words = find.trim().split(/\s+/)
+        if (words.length > 0) {
+          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('\\s+')
+          try {
+            const regex = new RegExp(pattern)
+            const match = line.match(regex)
+            if (match) {
+              yield match[0]
+            }
+          } catch {
+            // Invalid regex pattern, skip
+          }
+        }
+      }
+    }
+  }
+
+  const findLines = find.split('\n')
+  if (findLines.length > 1) {
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+      const block = lines.slice(i, i + findLines.length)
+      if (normalizeWhitespace(block.join('\n')) === normalizedFind) {
+        yield block.join('\n')
+      }
+    }
+  }
+}
+
+export const IndentationFlexibleReplacer: Replacer = function* (content, find) {
+  const removeIndentation = (text: string) => {
+    const lines = text.split('\n')
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0)
+    if (nonEmptyLines.length === 0) return text
+
+    const minIndent = Math.min(
+      ...nonEmptyLines.map((line) => {
+        const match = line.match(/^(\s*)/)
+        return match ? match[1].length : 0
+      })
+    )
+
+    return lines.map((line) => (line.trim().length === 0 ? line : line.slice(minIndent))).join('\n')
+  }
+
+  const normalizedFind = removeIndentation(find)
+  const contentLines = content.split('\n')
+  const findLines = find.split('\n')
+
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join('\n')
+    if (removeIndentation(block) === normalizedFind) {
+      yield block
+    }
+  }
+}
+
+export const EscapeNormalizedReplacer: Replacer = function* (content, find) {
+  const unescapeString = (str: string): string => {
+    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+      switch (capturedChar) {
+        case 'n':
+          return '\n'
+        case 't':
+          return '\t'
+        case 'r':
+          return '\r'
+        case "'":
+          return "'"
+        case '"':
+          return '"'
+        case '`':
+          return '`'
+        case '\\':
+          return '\\'
+        case '\n':
+          return '\n'
+        case '$':
+          return '$'
+        default:
+          return match
+      }
+    })
+  }
+
+  const unescapedFind = unescapeString(find)
+
+  if (content.includes(unescapedFind)) {
+    yield unescapedFind
+  }
+
+  const lines = content.split('\n')
+  const findLines = unescapedFind.split('\n')
+
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join('\n')
+    const unescapedBlock = unescapeString(block)
+
+    if (unescapedBlock === unescapedFind) {
+      yield block
+    }
+  }
+}
+
+export const TrimmedBoundaryReplacer: Replacer = function* (content, find) {
+  const trimmedFind = find.trim()
+
+  if (trimmedFind === find) {
+    return
+  }
+
+  if (content.includes(trimmedFind)) {
+    yield trimmedFind
+  }
+
+  const lines = content.split('\n')
+  const findLines = find.split('\n')
+
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join('\n')
+
+    if (block.trim() === trimmedFind) {
+      yield block
+    }
+  }
+}
+
+export const ContextAwareReplacer: Replacer = function* (content, find) {
+  const findLines = find.split('\n')
+  if (findLines.length < 3) {
+    return
+  }
+
+  if (findLines[findLines.length - 1] === '') {
+    findLines.pop()
+  }
+
+  const contentLines = content.split('\n')
+
+  const firstLine = findLines[0].trim()
+  const lastLine = findLines[findLines.length - 1].trim()
+
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine) continue
+
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const blockLines = contentLines.slice(i, j + 1)
+        const block = blockLines.join('\n')
+
+        if (blockLines.length === findLines.length) {
+          let matchingLines = 0
+          let totalNonEmptyLines = 0
+
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const blockLine = blockLines[k].trim()
+            const findLine = findLines[k].trim()
+
+            if (blockLine.length > 0 || findLine.length > 0) {
+              totalNonEmptyLines++
+              if (blockLine === findLine) {
+                matchingLines++
+              }
+            }
+          }
+
+          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
+            yield block
+            break
+          }
+        }
+        break
+      }
+    }
+  }
+}
+
+export const MultiOccurrenceReplacer: Replacer = function* (content, find) {
+  let startIndex = 0
+
+  while (true) {
+    const index = content.indexOf(find, startIndex)
+    if (index === -1) break
+
+    yield find
+    startIndex = index + find.length
+  }
+}
+
+/**
+ * All replacers in order of specificity
+ */
+export const ALL_REPLACERS: Replacer[] = [
+  SimpleReplacer,
+  LineTrimmedReplacer,
+  BlockAnchorReplacer,
+  WhitespaceNormalizedReplacer,
+  IndentationFlexibleReplacer,
+  EscapeNormalizedReplacer,
+  TrimmedBoundaryReplacer,
+  ContextAwareReplacer,
+  MultiOccurrenceReplacer
+]
+
+/**
+ * Replace oldString with newString in content using fuzzy matching
+ */
+export function replaceWithFuzzyMatch(
+  content: string,
+  oldString: string,
+  newString: string,
+  replaceAll = false
+): string {
+  if (oldString === newString) {
+    throw new Error('old_string and new_string must be different')
+  }
+
+  let notFound = true
+
+  for (const replacer of ALL_REPLACERS) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search)
+      if (index === -1) continue
+      notFound = false
+      if (replaceAll) {
+        return content.replaceAll(search, newString)
+      }
+      const lastIndex = content.lastIndexOf(search)
+      if (index !== lastIndex) continue
+      return content.substring(0, index) + newString + content.substring(index + search.length)
+    }
+  }
+
+  if (notFound) {
+    throw new Error('old_string not found in content')
+  }
+  throw new Error(
+    'Found multiple matches for old_string. Provide more surrounding lines in old_string to identify the correct match.'
+  )
+}
+
+// ============================================================================
+// Binary File Detection
+// ============================================================================
+
+// Check if a file is likely binary
+export async function isBinaryFile(filePath: string): Promise<boolean> {
+  try {
+    const buffer = Buffer.alloc(4096)
+    const fd = await fs.open(filePath, 'r')
+    const { bytesRead } = await fd.read(buffer, 0, buffer.length, 0)
+    await fd.close()
+
+    if (bytesRead === 0) return false
+
+    const view = buffer.subarray(0, bytesRead)
+
+    let zeroBytes = 0
+    let evenZeros = 0
+    let oddZeros = 0
+    let nonPrintable = 0
+
+    for (let i = 0; i < view.length; i++) {
+      const b = view[i]
+
+      if (b === 0) {
+        zeroBytes++
+        if (i % 2 === 0) evenZeros++
+        else oddZeros++
+        continue
+      }
+
+      // treat common whitespace as printable
+      if (b === 9 || b === 10 || b === 13) continue
+
+      // basic ASCII printable range
+      if (b >= 32 && b <= 126) continue
+
+      // bytes >= 128 are likely part of UTF-8 sequences; count as printable
+      if (b >= 128) continue
+
+      nonPrintable++
+    }
+
+    // If there are lots of null bytes, it's probably binary unless it looks like UTF-16 text.
+    if (zeroBytes > 0) {
+      const evenSlots = Math.ceil(view.length / 2)
+      const oddSlots = Math.floor(view.length / 2)
+      const evenZeroRatio = evenSlots > 0 ? evenZeros / evenSlots : 0
+      const oddZeroRatio = oddSlots > 0 ? oddZeros / oddSlots : 0
+
+      // UTF-16LE/BE tends to have zeros on every other byte.
+      if (evenZeroRatio > 0.7 || oddZeroRatio > 0.7) return false
+
+      if (zeroBytes / view.length > 0.05) return true
+    }
+
+    // Heuristic: too many non-printable bytes => binary.
+    return nonPrintable / view.length > 0.3
+  } catch {
+    return false
+  }
+}
+
+// ============================================================================
+// Ripgrep Utilities
+// ============================================================================
+
+export interface RipgrepResult {
+  ok: boolean
+  stdout: string
+  exitCode: number | null
+}
+
+export function getRipgrepAddonPath(): string {
+  const pkgJsonPath = require.resolve('@anthropic-ai/claude-agent-sdk/package.json')
+  const pkgRoot = path.dirname(pkgJsonPath)
+  const platform = isMac ? 'darwin' : isWin ? 'win32' : 'linux'
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64'
+  return path.join(pkgRoot, 'vendor', 'ripgrep', `${arch}-${platform}`, 'ripgrep.node')
+}
+
+export async function runRipgrep(args: string[]): Promise<RipgrepResult> {
+  const addonPath = getRipgrepAddonPath()
+  const childScript = `const { ripgrepMain } = require(process.env.RIPGREP_ADDON_PATH); process.exit(ripgrepMain(process.argv.slice(1)));`
+
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, ['--eval', childScript, 'rg', ...args], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        ELECTRON_RUN_AS_NODE: '1',
+        RIPGREP_ADDON_PATH: addonPath
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    let stdout = ''
+
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk.toString('utf-8')
+    })
+
+    child.on('error', () => {
+      resolve({ ok: false, stdout: '', exitCode: null })
+    })
+
+    child.on('close', (code) => {
+      resolve({ ok: true, stdout, exitCode: code })
+    })
+  })
+}
--- a/src/main/services/BackupManager.ts
+++ b/src/main/services/BackupManager.ts
@ -797,10 +797,11 @@ class BackupManager {
  async deleteTempBackup(_: Electron.IpcMainInvokeEvent, filePath: string): Promise<boolean> {
    try {
      // Security check: only allow deletion within temp directory
-      const tempBase = path.join(app.getPath('temp'), 'cherry-studio', 'lan-transfer')
-      const resolvedPath = path.resolve(filePath)
+      const tempBase = path.normalize(path.join(app.getPath('temp'), 'cherry-studio', 'lan-transfer'))
+      const resolvedPath = path.normalize(path.resolve(filePath))

-      if (!resolvedPath.startsWith(tempBase)) {
+      // Use normalized paths with trailing separator to prevent prefix attacks (e.g., /temp-evil)
+      if (!resolvedPath.startsWith(tempBase + path.sep) && resolvedPath !== tempBase) {
        logger.warn(`[BackupManager] Attempted to delete file outside temp directory: ${filePath}`)
        return false
      }
--- a/src/main/services/ConfigManager.ts
+++ b/src/main/services/ConfigManager.ts
@ -32,7 +32,8 @@ export enum ConfigKeys {
  Proxy = 'proxy',
  EnableDeveloperMode = 'enableDeveloperMode',
  ClientId = 'clientId',
-  GitBashPath = 'gitBashPath'
+  GitBashPath = 'gitBashPath',
+  GitBashPathSource = 'gitBashPathSource' // 'manual' | 'auto' | null
 }

 export class ConfigManager {
--- a/src/main/services/WebSocketService.ts
+++ b/src/main/services/WebSocketService.ts
@ -1,359 +0,0 @@
-import { loggerService } from '@logger'
-import type { WebSocketCandidatesResponse, WebSocketStatusResponse } from '@shared/config/types'
-import * as fs from 'fs'
-import { networkInterfaces } from 'os'
-import * as path from 'path'
-import type { Socket } from 'socket.io'
-import { Server } from 'socket.io'
-
-import { windowService } from './WindowService'
-
-const logger = loggerService.withContext('WebSocketService')
-
-class WebSocketService {
-  private io: Server | null = null
-  private isStarted = false
-  private port = 7017
-  private connectedClients = new Set<string>()
-
-  private getLocalIpAddress(): string | undefined {
-    const interfaces = networkInterfaces()
-
-    // 按优先级排序的网络接口名称模式
-    const interfacePriority = [
-      // macOS: 以太网/Wi-Fi 优先
-      /^en[0-9]+$/, // en0, en1 (以太网/Wi-Fi)
-      /^(en|eth)[0-9]+$/, // 以太网接口
-      /^wlan[0-9]+$/, // 无线接口
-      // Windows: 以太网/Wi-Fi 优先
-      /^(Ethernet|Wi-Fi|Local Area Connection)/,
-      /^(Wi-Fi|无线网络连接)/,
-      // Linux: 以太网/Wi-Fi 优先
-      /^(eth|enp|wlp|wlan)[0-9]+/,
-      // 虚拟化接口（低优先级）
-      /^bridge[0-9]+$/, // Docker bridge
-      /^veth[0-9]+$/, // Docker veth
-      /^docker[0-9]+/, // Docker interfaces
-      /^br-[0-9a-f]+/, // Docker bridge
-      /^vmnet[0-9]+$/, // VMware
-      /^vboxnet[0-9]+$/, // VirtualBox
-      // VPN 隧道接口（低优先级）
-      /^utun[0-9]+$/, // macOS VPN
-      /^tun[0-9]+$/, // Linux/Unix VPN
-      /^tap[0-9]+$/, // TAP interfaces
-      /^tailscale[0-9]*$/, // Tailscale VPN
-      /^wg[0-9]+$/ // WireGuard VPN
-    ]
-
-    const candidates: Array<{ interface: string; address: string; priority: number }> = []
-
-    for (const [name, ifaces] of Object.entries(interfaces)) {
-      for (const iface of ifaces || []) {
-        if (iface.family === 'IPv4' && !iface.internal) {
-          // 计算接口优先级
-          let priority = 999 // 默认最低优先级
-          for (let i = 0; i < interfacePriority.length; i++) {
-            if (interfacePriority[i].test(name)) {
-              priority = i
-              break
-            }
-          }
-
-          candidates.push({
-            interface: name,
-            address: iface.address,
-            priority
-          })
-        }
-      }
-    }
-
-    if (candidates.length === 0) {
-      logger.warn('无法获取局域网 IP，使用默认 IP: 127.0.0.1')
-      return '127.0.0.1'
-    }
-
-    // 按优先级排序，选择优先级最高的
-    candidates.sort((a, b) => a.priority - b.priority)
-    const best = candidates[0]
-
-    logger.info(`获取局域网 IP: ${best.address} (interface: ${best.interface})`)
-    return best.address
-  }
-
-  public start = async (): Promise<{ success: boolean; port?: number; error?: string }> => {
-    if (this.isStarted && this.io) {
-      return { success: true, port: this.port }
-    }
-
-    try {
-      this.io = new Server(this.port, {
-        cors: {
-          origin: '*',
-          methods: ['GET', 'POST']
-        },
-        transports: ['websocket', 'polling'],
-        allowEIO3: true,
-        pingTimeout: 60000,
-        pingInterval: 25000
-      })
-
-      this.io.on('connection', (socket: Socket) => {
-        this.connectedClients.add(socket.id)
-
-        const mainWindow = windowService.getMainWindow()
-        if (!mainWindow) {
-          logger.error('Main window is null, cannot send connection event')
-        } else {
-          mainWindow.webContents.send('websocket-client-connected', {
-            connected: true,
-            clientId: socket.id
-          })
-          logger.info(`Connection event sent to renderer, total clients: ${this.connectedClients.size}`)
-        }
-
-        socket.on('message', (data) => {
-          logger.info('Received message from mobile:', data)
-          mainWindow?.webContents.send('websocket-message-received', data)
-          socket.emit('message_received', { success: true })
-        })
-
-        socket.on('disconnect', () => {
-          logger.info(`Client disconnected: ${socket.id}`)
-          this.connectedClients.delete(socket.id)
-
-          if (this.connectedClients.size === 0) {
-            mainWindow?.webContents.send('websocket-client-connected', {
-              connected: false,
-              clientId: socket.id
-            })
-          }
-        })
-      })
-
-      // Engine 层面的事件监听
-      this.io.engine.on('connection_error', (err) => {
-        logger.error('Engine connection error:', err)
-      })
-
-      this.io.engine.on('connection', (rawSocket) => {
-        const remoteAddr = rawSocket.request.connection.remoteAddress
-        logger.info(`[Engine] Raw connection from: ${remoteAddr}`)
-        logger.info(`[Engine] Transport: ${rawSocket.transport.name}`)
-
-        rawSocket.on('packet', (packet: { type: string; data?: any }) => {
-          logger.info(
-            `[Engine] ← Packet from ${remoteAddr}: type="${packet.type}"`,
-            packet.data ? { data: packet.data } : {}
-          )
-        })
-
-        rawSocket.on('packetCreate', (packet: { type: string; data?: any }) => {
-          logger.info(`[Engine] → Packet to ${remoteAddr}: type="${packet.type}"`)
-        })
-
-        rawSocket.on('close', (reason: string) => {
-          logger.warn(`[Engine] Connection closed from ${remoteAddr}, reason: ${reason}`)
-        })
-
-        rawSocket.on('error', (error: Error) => {
-          logger.error(`[Engine] Connection error from ${remoteAddr}:`, error)
-        })
-      })
-
-      // Socket.IO 握手失败监听
-      this.io.on('connection_error', (err) => {
-        logger.error('[Socket.IO] Connection error during handshake:', err)
-      })
-
-      this.isStarted = true
-      logger.info(`WebSocket server started on port ${this.port}`)
-
-      return { success: true, port: this.port }
-    } catch (error) {
-      logger.error('Failed to start WebSocket server:', error as Error)
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error'
-      }
-    }
-  }
-
-  public stop = async (): Promise<{ success: boolean }> => {
-    if (!this.isStarted || !this.io) {
-      return { success: true }
-    }
-
-    try {
-      await new Promise<void>((resolve) => {
-        this.io!.close(() => {
-          resolve()
-        })
-      })
-
-      this.io = null
-      this.isStarted = false
-      this.connectedClients.clear()
-      logger.info('WebSocket server stopped')
-
-      return { success: true }
-    } catch (error) {
-      logger.error('Failed to stop WebSocket server:', error as Error)
-      return { success: false }
-    }
-  }
-
-  public getStatus = async (): Promise<WebSocketStatusResponse> => {
-    return {
-      isRunning: this.isStarted,
-      port: this.isStarted ? this.port : undefined,
-      ip: this.isStarted ? this.getLocalIpAddress() : undefined,
-      clientConnected: this.connectedClients.size > 0
-    }
-  }
-
-  public getAllCandidates = async (): Promise<WebSocketCandidatesResponse[]> => {
-    const interfaces = networkInterfaces()
-
-    // 按优先级排序的网络接口名称模式
-    const interfacePriority = [
-      // macOS: 以太网/Wi-Fi 优先
-      /^en[0-9]+$/, // en0, en1 (以太网/Wi-Fi)
-      /^(en|eth)[0-9]+$/, // 以太网接口
-      /^wlan[0-9]+$/, // 无线接口
-      // Windows: 以太网/Wi-Fi 优先
-      /^(Ethernet|Wi-Fi|Local Area Connection)/,
-      /^(Wi-Fi|无线网络连接)/,
-      // Linux: 以太网/Wi-Fi 优先
-      /^(eth|enp|wlp|wlan)[0-9]+/,
-      // 虚拟化接口（低优先级）
-      /^bridge[0-9]+$/, // Docker bridge
-      /^veth[0-9]+$/, // Docker veth
-      /^docker[0-9]+/, // Docker interfaces
-      /^br-[0-9a-f]+/, // Docker bridge
-      /^vmnet[0-9]+$/, // VMware
-      /^vboxnet[0-9]+$/, // VirtualBox
-      // VPN 隧道接口（低优先级）
-      /^utun[0-9]+$/, // macOS VPN
-      /^tun[0-9]+$/, // Linux/Unix VPN
-      /^tap[0-9]+$/, // TAP interfaces
-      /^tailscale[0-9]*$/, // Tailscale VPN
-      /^wg[0-9]+$/ // WireGuard VPN
-    ]
-
-    const candidates: Array<{ host: string; interface: string; priority: number }> = []
-
-    for (const [name, ifaces] of Object.entries(interfaces)) {
-      for (const iface of ifaces || []) {
-        if (iface.family === 'IPv4' && !iface.internal) {
-          // 计算接口优先级
-          let priority = 999 // 默认最低优先级
-          for (let i = 0; i < interfacePriority.length; i++) {
-            if (interfacePriority[i].test(name)) {
-              priority = i
-              break
-            }
-          }
-
-          candidates.push({
-            host: iface.address,
-            interface: name,
-            priority
-          })
-
-          logger.debug(`Found interface: ${name} -> ${iface.address} (priority: ${priority})`)
-        }
-      }
-    }
-
-    // 按优先级排序返回
-    candidates.sort((a, b) => a.priority - b.priority)
-    logger.info(
-      `Found ${candidates.length} IP candidates: ${candidates.map((c) => `${c.host}(${c.interface})`).join(', ')}`
-    )
-    return candidates
-  }
-
-  public sendFile = async (
-    _: Electron.IpcMainInvokeEvent,
-    filePath: string
-  ): Promise<{ success: boolean; error?: string }> => {
-    if (!this.isStarted || !this.io) {
-      const errorMsg = 'WebSocket server is not running.'
-      logger.error(errorMsg)
-      return { success: false, error: errorMsg }
-    }
-
-    if (this.connectedClients.size === 0) {
-      const errorMsg = 'No client connected.'
-      logger.error(errorMsg)
-      return { success: false, error: errorMsg }
-    }
-
-    const mainWindow = windowService.getMainWindow()
-
-    return new Promise((resolve, reject) => {
-      const stats = fs.statSync(filePath)
-      const totalSize = stats.size
-      const filename = path.basename(filePath)
-      const stream = fs.createReadStream(filePath)
-      let bytesSent = 0
-      const startTime = Date.now()
-
-      logger.info(`Starting file transfer: ${filename} (${this.formatFileSize(totalSize)})`)
-
-      // 向客户端发送文件开始的信号，包含文件名和总大小
-      this.io!.emit('zip-file-start', { filename, totalSize })
-
-      stream.on('data', (chunk) => {
-        bytesSent += chunk.length
-        const progress = (bytesSent / totalSize) * 100
-
-        // 向客户端发送文件块
-        this.io!.emit('zip-file-chunk', chunk)
-
-        // 向渲染进程发送进度更新
-        mainWindow?.webContents.send('file-send-progress', { progress })
-
-        // 每10%记录一次进度
-        if (Math.floor(progress) % 10 === 0) {
-          const elapsed = (Date.now() - startTime) / 1000
-          const speed = elapsed > 0 ? bytesSent / elapsed : 0
-          logger.info(`Transfer progress: ${Math.floor(progress)}% (${this.formatFileSize(speed)}/s)`)
-        }
-      })
-
-      stream.on('end', () => {
-        const totalTime = (Date.now() - startTime) / 1000
-        const avgSpeed = totalTime > 0 ? totalSize / totalTime : 0
-        logger.info(
-          `File transfer completed: ${filename} in ${totalTime.toFixed(1)}s (${this.formatFileSize(avgSpeed)}/s)`
-        )
-
-        // 确保发送100%的进度
-        mainWindow?.webContents.send('file-send-progress', { progress: 100 })
-        // 向客户端发送文件结束的信号
-        this.io!.emit('zip-file-end')
-        resolve({ success: true })
-      })
-
-      stream.on('error', (error) => {
-        logger.error(`File transfer failed: ${filename}`, error)
-        reject({
-          success: false,
-          error: error instanceof Error ? error.message : 'Unknown error'
-        })
-      })
-    })
-  }
-
-  private formatFileSize(bytes: number): string {
-    if (bytes === 0) return '0 B'
-    const k = 1024
-    const sizes = ['B', 'KB', 'MB', 'GB']
-    const i = Math.floor(Math.log(bytes) / Math.log(k))
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
-  }
-}
-
-export default new WebSocketService()
--- a/src/main/services/tests/BackupManager.deleteTempBackup.test.ts
+++ b/src/main/services/tests/BackupManager.deleteTempBackup.test.ts
@ -0,0 +1,277 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Use vi.hoisted to define mocks that are available during hoisting
+const { mockLogger } = vi.hoisted(() => ({
+  mockLogger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  }
+}))
+
+vi.mock('@logger', () => ({
+  loggerService: {
+    withContext: () => mockLogger
+  }
+}))
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: vi.fn((key: string) => {
+      if (key === 'temp') return '/tmp'
+      if (key === 'userData') return '/mock/userData'
+      return '/mock/unknown'
+    })
+  }
+}))
+
+vi.mock('fs-extra', () => ({
+  default: {
+    pathExists: vi.fn(),
+    remove: vi.fn(),
+    ensureDir: vi.fn(),
+    copy: vi.fn(),
+    readdir: vi.fn(),
+    stat: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    createWriteStream: vi.fn(),
+    createReadStream: vi.fn()
+  },
+  pathExists: vi.fn(),
+  remove: vi.fn(),
+  ensureDir: vi.fn(),
+  copy: vi.fn(),
+  readdir: vi.fn(),
+  stat: vi.fn(),
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  createWriteStream: vi.fn(),
+  createReadStream: vi.fn()
+}))
+
+vi.mock('../WindowService', () => ({
+  windowService: {
+    getMainWindow: vi.fn()
+  }
+}))
+
+vi.mock('../WebDav', () => ({
+  default: vi.fn()
+}))
+
+vi.mock('../S3Storage', () => ({
+  default: vi.fn()
+}))
+
+vi.mock('../../utils', () => ({
+  getDataPath: vi.fn(() => '/mock/data')
+}))
+
+vi.mock('archiver', () => ({
+  default: vi.fn()
+}))
+
+vi.mock('node-stream-zip', () => ({
+  default: vi.fn()
+}))
+
+// Import after mocks
+import * as fs from 'fs-extra'
+
+import BackupManager from '../BackupManager'
+
+describe('BackupManager.deleteTempBackup - Security Tests', () => {
+  let backupManager: BackupManager
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    backupManager = new BackupManager()
+  })
+
+  describe('Normal Operations', () => {
+    it('should delete valid file in allowed directory', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const validPath = '/tmp/cherry-studio/lan-transfer/backup.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, validPath)
+
+      expect(result).toBe(true)
+      expect(fs.remove).toHaveBeenCalledWith(validPath)
+      expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Deleted temp backup'))
+    })
+
+    it('should delete file in nested subdirectory', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const nestedPath = '/tmp/cherry-studio/lan-transfer/sub/dir/file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, nestedPath)
+
+      expect(result).toBe(true)
+      expect(fs.remove).toHaveBeenCalledWith(nestedPath)
+    })
+
+    it('should return false when file does not exist', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(false as never)
+
+      const missingPath = '/tmp/cherry-studio/lan-transfer/missing.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, missingPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Path Traversal Attacks', () => {
+    it('should block basic directory traversal attack (../../../../etc/passwd)', async () => {
+      const attackPath = '/tmp/cherry-studio/lan-transfer/../../../../etc/passwd'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.pathExists).not.toHaveBeenCalled()
+      expect(fs.remove).not.toHaveBeenCalled()
+      expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('outside temp directory'))
+    })
+
+    it('should block absolute path escape (/etc/passwd)', async () => {
+      const attackPath = '/etc/passwd'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+      expect(mockLogger.warn).toHaveBeenCalled()
+    })
+
+    it('should block traversal with multiple slashes', async () => {
+      const attackPath = '/tmp/cherry-studio/lan-transfer/../../../etc/passwd'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+
+    it('should block relative path traversal from current directory', async () => {
+      const attackPath = '../../../etc/passwd'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+
+    it('should block traversal to parent directory', async () => {
+      const attackPath = '/tmp/cherry-studio/lan-transfer/../backup/secret.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Prefix Attacks', () => {
+    it('should block similar prefix attack (lan-transfer-evil)', async () => {
+      const attackPath = '/tmp/cherry-studio/lan-transfer-evil/file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+      expect(mockLogger.warn).toHaveBeenCalled()
+    })
+
+    it('should block path without separator (lan-transferx)', async () => {
+      const attackPath = '/tmp/cherry-studio/lan-transferx'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+
+    it('should block different temp directory prefix', async () => {
+      const attackPath = '/tmp-evil/cherry-studio/lan-transfer/file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, attackPath)
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should return false and log error on permission denied', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockRejectedValue(new Error('EACCES: permission denied') as never)
+
+      const validPath = '/tmp/cherry-studio/lan-transfer/file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, validPath)
+
+      expect(result).toBe(false)
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to delete'),
+        expect.any(Error)
+      )
+    })
+
+    it('should return false on fs.pathExists error', async () => {
+      vi.mocked(fs.pathExists).mockRejectedValue(new Error('ENOENT') as never)
+
+      const validPath = '/tmp/cherry-studio/lan-transfer/file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, validPath)
+
+      expect(result).toBe(false)
+      expect(mockLogger.error).toHaveBeenCalled()
+    })
+
+    it('should handle empty path string', async () => {
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, '')
+
+      expect(result).toBe(false)
+      expect(fs.remove).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should allow deletion of the temp directory itself', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const tempDir = '/tmp/cherry-studio/lan-transfer'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, tempDir)
+
+      expect(result).toBe(true)
+      expect(fs.remove).toHaveBeenCalledWith(tempDir)
+    })
+
+    it('should handle path with trailing slash', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const pathWithSlash = '/tmp/cherry-studio/lan-transfer/sub/'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, pathWithSlash)
+
+      // path.normalize removes trailing slash
+      expect(result).toBe(true)
+    })
+
+    it('should handle file with special characters in name', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const specialPath = '/tmp/cherry-studio/lan-transfer/file with spaces & (special).zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, specialPath)
+
+      expect(result).toBe(true)
+      expect(fs.remove).toHaveBeenCalled()
+    })
+
+    it('should handle path with double slashes', async () => {
+      vi.mocked(fs.pathExists).mockResolvedValue(true as never)
+      vi.mocked(fs.remove).mockResolvedValue(undefined as never)
+
+      const doubleSlashPath = '/tmp/cherry-studio//lan-transfer//file.zip'
+      const result = await backupManager.deleteTempBackup({} as Electron.IpcMainInvokeEvent, doubleSlashPath)
+
+      // path.normalize handles double slashes
+      expect(result).toBe(true)
+    })
+  })
+})
--- a/src/main/services/tests/LocalTransferService.test.ts
+++ b/src/main/services/tests/LocalTransferService.test.ts
@ -0,0 +1,481 @@
+import { EventEmitter } from 'events'
+import { afterEach, beforeEach, describe, expect, it, type Mock,vi } from 'vitest'
+
+// Create mock objects before vi.mock calls
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn()
+}
+
+let mockMainWindow: {
+  isDestroyed: Mock
+  webContents: { send: Mock }
+} | null = null
+
+let mockBrowser: EventEmitter & {
+  start: Mock
+  stop: Mock
+  removeAllListeners: Mock
+}
+
+let mockBonjour: {
+  find: Mock
+  destroy: Mock
+}
+
+// Mock dependencies before importing the service
+vi.mock('@logger', () => ({
+  loggerService: {
+    withContext: () => mockLogger
+  }
+}))
+
+vi.mock('../WindowService', () => ({
+  windowService: {
+    getMainWindow: vi.fn(() => mockMainWindow)
+  }
+}))
+
+vi.mock('bonjour-service', () => ({
+  default: vi.fn(() => mockBonjour)
+}))
+
+describe('LocalTransferService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.resetModules()
+
+    // Reset mock objects
+    mockMainWindow = {
+      isDestroyed: vi.fn(() => false),
+      webContents: { send: vi.fn() }
+    }
+
+    mockBrowser = Object.assign(new EventEmitter(), {
+      start: vi.fn(),
+      stop: vi.fn(),
+      removeAllListeners: vi.fn()
+    })
+
+    mockBonjour = {
+      find: vi.fn(() => mockBrowser),
+      destroy: vi.fn()
+    }
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('startDiscovery', () => {
+    it('should set isScanning to true and start browser', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      const state = localTransferService.startDiscovery()
+
+      expect(state.isScanning).toBe(true)
+      expect(state.lastScanStartedAt).toBeDefined()
+      expect(mockBonjour.find).toHaveBeenCalledWith({ type: 'cherrystudio', protocol: 'tcp' })
+      expect(mockBrowser.start).toHaveBeenCalled()
+    })
+
+    it('should clear services when resetList is true', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      // First, start discovery and add a service
+      localTransferService.startDiscovery()
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        fqdn: 'test.local'
+      })
+
+      expect(localTransferService.getState().services).toHaveLength(1)
+
+      // Now restart with resetList
+      const state = localTransferService.startDiscovery({ resetList: true })
+
+      expect(state.services).toHaveLength(0)
+    })
+
+    it('should broadcast state after starting discovery', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      expect(mockMainWindow?.webContents.send).toHaveBeenCalled()
+    })
+
+    it('should handle browser.start() error', async () => {
+      mockBrowser.start.mockImplementation(() => {
+        throw new Error('Failed to start mDNS')
+      })
+
+      const { localTransferService } = await import('../LocalTransferService')
+
+      const state = localTransferService.startDiscovery()
+
+      expect(state.lastError).toBe('Failed to start mDNS')
+      expect(mockLogger.error).toHaveBeenCalled()
+    })
+  })
+
+  describe('stopDiscovery', () => {
+    it('should set isScanning to false and stop browser', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+      const state = localTransferService.stopDiscovery()
+
+      expect(state.isScanning).toBe(false)
+      expect(mockBrowser.stop).toHaveBeenCalled()
+    })
+
+    it('should handle browser.stop() error gracefully', async () => {
+      mockBrowser.stop.mockImplementation(() => {
+        throw new Error('Stop failed')
+      })
+
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      // Should not throw
+      expect(() => localTransferService.stopDiscovery()).not.toThrow()
+      expect(mockLogger.warn).toHaveBeenCalled()
+    })
+
+    it('should broadcast state after stopping', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+      vi.clearAllMocks()
+
+      localTransferService.stopDiscovery()
+
+      expect(mockMainWindow?.webContents.send).toHaveBeenCalled()
+    })
+  })
+
+  describe('browser events', () => {
+    it('should add service on "up" event', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        fqdn: 'test.local',
+        type: 'cherrystudio',
+        protocol: 'tcp'
+      })
+
+      const state = localTransferService.getState()
+      expect(state.services).toHaveLength(1)
+      expect(state.services[0].name).toBe('Test Service')
+      expect(state.services[0].port).toBe(12345)
+      expect(state.services[0].addresses).toContain('192.168.1.100')
+    })
+
+    it('should remove service on "down" event', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      // Add service
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        fqdn: 'test.local'
+      })
+
+      expect(localTransferService.getState().services).toHaveLength(1)
+
+      // Remove service
+      mockBrowser.emit('down', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        fqdn: 'test.local'
+      })
+
+      expect(localTransferService.getState().services).toHaveLength(0)
+      expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('removed'))
+    })
+
+    it('should set lastError on "error" event', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('error', new Error('Discovery failed'))
+
+      const state = localTransferService.getState()
+      expect(state.lastError).toBe('Discovery failed')
+      expect(mockLogger.error).toHaveBeenCalled()
+    })
+
+    it('should handle non-Error objects in error event', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('error', 'String error message')
+
+      const state = localTransferService.getState()
+      expect(state.lastError).toBe('String error message')
+    })
+  })
+
+  describe('getState', () => {
+    it('should return sorted services by name', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Zebra Service',
+        host: 'host1',
+        port: 1001,
+        addresses: ['192.168.1.1']
+      })
+
+      mockBrowser.emit('up', {
+        name: 'Alpha Service',
+        host: 'host2',
+        port: 1002,
+        addresses: ['192.168.1.2']
+      })
+
+      const state = localTransferService.getState()
+      expect(state.services[0].name).toBe('Alpha Service')
+      expect(state.services[1].name).toBe('Zebra Service')
+    })
+
+    it('should include all state properties', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      const state = localTransferService.getState()
+
+      expect(state).toHaveProperty('services')
+      expect(state).toHaveProperty('isScanning')
+      expect(state).toHaveProperty('lastScanStartedAt')
+      expect(state).toHaveProperty('lastUpdatedAt')
+    })
+  })
+
+  describe('getPeerById', () => {
+    it('should return peer when exists', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        fqdn: 'test.local'
+      })
+
+      const services = localTransferService.getState().services
+      const peer = localTransferService.getPeerById(services[0].id)
+
+      expect(peer).toBeDefined()
+      expect(peer?.name).toBe('Test Service')
+    })
+
+    it('should return undefined when peer does not exist', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      const peer = localTransferService.getPeerById('non-existent-id')
+
+      expect(peer).toBeUndefined()
+    })
+  })
+
+  describe('normalizeService', () => {
+    it('should deduplicate addresses', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100', '192.168.1.100', '10.0.0.1'],
+        referer: { address: '192.168.1.100' }
+      })
+
+      const services = localTransferService.getState().services
+      expect(services[0].addresses).toHaveLength(2)
+      expect(services[0].addresses).toContain('192.168.1.100')
+      expect(services[0].addresses).toContain('10.0.0.1')
+    })
+
+    it('should filter empty addresses', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100', '', null as any]
+      })
+
+      const services = localTransferService.getState().services
+      expect(services[0].addresses).toEqual(['192.168.1.100'])
+    })
+
+    it('should convert txt null/undefined values to empty strings', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        txt: {
+          version: '1.0',
+          nullValue: null,
+          undefinedValue: undefined,
+          numberValue: 42
+        }
+      })
+
+      const services = localTransferService.getState().services
+      expect(services[0].txt).toEqual({
+        version: '1.0',
+        nullValue: '',
+        undefinedValue: '',
+        numberValue: '42'
+      })
+    })
+
+    it('should not include txt when empty', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100'],
+        txt: {}
+      })
+
+      const services = localTransferService.getState().services
+      expect(services[0].txt).toBeUndefined()
+    })
+  })
+
+  describe('dispose', () => {
+    it('should clean up all resources', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      mockBrowser.emit('up', {
+        name: 'Test Service',
+        host: 'localhost',
+        port: 12345,
+        addresses: ['192.168.1.100']
+      })
+
+      localTransferService.dispose()
+
+      expect(localTransferService.getState().services).toHaveLength(0)
+      expect(localTransferService.getState().isScanning).toBe(false)
+      expect(mockBrowser.removeAllListeners).toHaveBeenCalled()
+      expect(mockBonjour.destroy).toHaveBeenCalled()
+    })
+
+    it('should handle bonjour.destroy() error gracefully', async () => {
+      mockBonjour.destroy.mockImplementation(() => {
+        throw new Error('Destroy failed')
+      })
+
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      // Should not throw
+      expect(() => localTransferService.dispose()).not.toThrow()
+      expect(mockLogger.warn).toHaveBeenCalled()
+    })
+
+    it('should be safe to call multiple times', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+
+      expect(() => {
+        localTransferService.dispose()
+        localTransferService.dispose()
+      }).not.toThrow()
+    })
+  })
+
+  describe('broadcastState', () => {
+    it('should not throw when main window is null', async () => {
+      mockMainWindow = null
+
+      const { localTransferService } = await import('../LocalTransferService')
+
+      // Should not throw
+      expect(() => localTransferService.startDiscovery()).not.toThrow()
+    })
+
+    it('should not throw when main window is destroyed', async () => {
+      mockMainWindow = {
+        isDestroyed: vi.fn(() => true),
+        webContents: { send: vi.fn() }
+      }
+
+      const { localTransferService } = await import('../LocalTransferService')
+
+      // Should not throw
+      expect(() => localTransferService.startDiscovery()).not.toThrow()
+      expect(mockMainWindow.webContents.send).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('restartBrowser', () => {
+    it('should destroy old bonjour instance to prevent socket leaks', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      // First start
+      localTransferService.startDiscovery()
+      expect(mockBonjour.destroy).not.toHaveBeenCalled()
+
+      // Restart - should destroy old instance
+      localTransferService.startDiscovery()
+      expect(mockBonjour.destroy).toHaveBeenCalled()
+    })
+
+    it('should remove all listeners from old browser', async () => {
+      const { localTransferService } = await import('../LocalTransferService')
+
+      localTransferService.startDiscovery()
+      localTransferService.startDiscovery()
+
+      expect(mockBrowser.removeAllListeners).toHaveBeenCalled()
+    })
+  })
+})
--- a/src/main/services/agents/services/claudecode/index.ts
+++ b/src/main/services/agents/services/claudecode/index.ts
@ -15,8 +15,8 @@ import { query } from '@anthropic-ai/claude-agent-sdk'
 import { loggerService } from '@logger'
 import { config as apiConfigService } from '@main/apiServer/config'
 import { validateModelId } from '@main/apiServer/utils'
-import { ConfigKeys, configManager } from '@main/services/ConfigManager'
-import { validateGitBashPath } from '@main/utils/process'
+import { isWin } from '@main/constant'
+import { autoDiscoverGitBash } from '@main/utils/process'
 import getLoginShellEnvironment from '@main/utils/shell-env'
 import { app } from 'electron'

@ -109,7 +109,8 @@ class ClaudeCodeService implements AgentServiceInterface {
      Object.entries(loginShellEnv).filter(([key]) => !key.toLowerCase().endsWith('_proxy'))
    ) as Record<string, string>

-    const customGitBashPath = validateGitBashPath(configManager.get(ConfigKeys.GitBashPath) as string | undefined)
+    // Auto-discover Git Bash path on Windows (already logs internally)
+    const customGitBashPath = isWin ? autoDiscoverGitBash() : null

    const env = {
      ...loginShellEnvWithoutProxies,
--- a/src/main/services/lanTransfer/LanTransferClientService.ts
+++ b/src/main/services/lanTransfer/LanTransferClientService.ts
@ -43,7 +43,7 @@ const logger = loggerService.withContext('LanTransferClientService')
 * LAN Transfer Client Service
 *
 * Handles outgoing file transfers to LAN peers via TCP.
- * Protocol v3 with streaming mode (no per-chunk acknowledgment).
+ * Protocol v1 with streaming mode (no per-chunk acknowledgment).
 */
 class LanTransferClientService {
  private socket: Socket | null = null
@ -53,6 +53,9 @@ class LanTransferClientService {
  private isConnecting = false
  private activeTransfer?: ActiveFileTransfer
  private lastConnectOptions?: LocalTransferConnectPayload
+  private consecutiveJsonErrors = 0
+  private static readonly MAX_CONSECUTIVE_JSON_ERRORS = 3
+  private reconnectPromise: Promise<void> | null = null

  constructor() {
    this.responseManager.setTimeoutCallback(() => void this.disconnect())
@ -296,8 +299,9 @@ class LanTransferClientService {
        transferId,
        reason: 'Cancelled by user'
      })
-    } catch {
-      // Ignore errors when sending cancel message
+    } catch (error) {
+      // Expected when connection is already broken
+      logger.warn('Failed to send cancel message', error as Error)
    }

    abortTransfer(this.activeTransfer, new Error('Transfer cancelled by user'))
@ -317,8 +321,23 @@ class LanTransferClientService {
      throw new Error('No active connection. Please connect to a peer first.')
    }

+    // Prevent concurrent reconnection attempts
+    if (this.reconnectPromise) {
+      logger.debug('Waiting for existing reconnection attempt...')
+      await this.reconnectPromise
+      return
+    }
+
    logger.info('Connection lost, attempting to reconnect...')
-    await this.connectAndHandshake(this.lastConnectOptions)
+    this.reconnectPromise = this.connectAndHandshake(this.lastConnectOptions)
+      .then(() => {
+        // Handshake succeeded, connection restored
+      })
+      .finally(() => {
+        this.reconnectPromise = null
+      })
+
+    await this.reconnectPromise
  }

  private async performFileTransfer(
@ -386,15 +405,35 @@ class LanTransferClientService {

  private attachSocketListeners(socket: Socket): void {
    this.dataHandler = createDataHandler((line) => this.handleControlLine(line))
-    socket.on('data', (chunk: Buffer) => this.dataHandler?.handleData(chunk))
+    socket.on('data', (chunk: Buffer) => {
+      try {
+        this.dataHandler?.handleData(chunk)
+      } catch (error) {
+        logger.error('Data handler error', error as Error)
+        void this.disconnect()
+      }
+    })
  }

  private handleControlLine(line: string): void {
    let payload: Record<string, unknown>
    try {
      payload = JSON.parse(line)
+      this.consecutiveJsonErrors = 0 // Reset on successful parse
    } catch {
-      logger.warn('Received invalid JSON control message', { line })
+      this.consecutiveJsonErrors++
+      logger.warn('Received invalid JSON control message', { line, consecutiveErrors: this.consecutiveJsonErrors })
+
+      if (this.consecutiveJsonErrors >= LanTransferClientService.MAX_CONSECUTIVE_JSON_ERRORS) {
+        const message = `Protocol error: ${this.consecutiveJsonErrors} consecutive invalid messages, disconnecting`
+        logger.error(message)
+        this.broadcastClientEvent({
+          type: 'error',
+          message,
+          timestamp: Date.now()
+        })
+        void this.disconnect()
+      }
      return
    }

--- a/src/main/services/lanTransfer/tests/LanTransferClientService.test.ts
+++ b/src/main/services/lanTransfer/tests/LanTransferClientService.test.ts
@ -0,0 +1,137 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Mock dependencies before importing the service
+vi.mock('node:net', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return {
+    ...actual,
+    createConnection: vi.fn()
+  }
+})
+
+vi.mock('electron', () => ({
+  app: {
+    getName: vi.fn(() => 'Cherry Studio'),
+    getVersion: vi.fn(() => '1.0.0')
+  }
+}))
+
+vi.mock('../../LocalTransferService', () => ({
+  localTransferService: {
+    getPeerById: vi.fn()
+  }
+}))
+
+vi.mock('../../WindowService', () => ({
+  windowService: {
+    getMainWindow: vi.fn(() => ({
+      isDestroyed: () => false,
+      webContents: {
+        send: vi.fn()
+      }
+    }))
+  }
+}))
+
+// Import after mocks
+import { localTransferService } from '../../LocalTransferService'
+
+describe('LanTransferClientService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.resetModules()
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  describe('connectAndHandshake - validation', () => {
+    it('should throw error when peer is not found', async () => {
+      vi.mocked(localTransferService.getPeerById).mockReturnValue(undefined)
+
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      await expect(
+        lanTransferClientService.connectAndHandshake({
+          peerId: 'non-existent',
+          type: 'connect'
+        })
+      ).rejects.toThrow('Selected LAN peer is no longer available')
+    })
+
+    it('should throw error when peer has no port', async () => {
+      vi.mocked(localTransferService.getPeerById).mockReturnValue({
+        id: 'test-peer',
+        name: 'Test Peer',
+        addresses: ['192.168.1.100'],
+        updatedAt: Date.now()
+      })
+
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      await expect(
+        lanTransferClientService.connectAndHandshake({
+          peerId: 'test-peer',
+          type: 'connect'
+        })
+      ).rejects.toThrow('Selected peer does not expose a TCP port')
+    })
+
+    it('should throw error when no reachable host', async () => {
+      vi.mocked(localTransferService.getPeerById).mockReturnValue({
+        id: 'test-peer',
+        name: 'Test Peer',
+        port: 12345,
+        addresses: [],
+        updatedAt: Date.now()
+      })
+
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      await expect(
+        lanTransferClientService.connectAndHandshake({
+          peerId: 'test-peer',
+          type: 'connect'
+        })
+      ).rejects.toThrow('Unable to resolve a reachable host for the peer')
+    })
+
+  })
+
+  describe('cancelTransfer', () => {
+    it('should not throw when no active transfer', async () => {
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      // Should not throw, just log warning
+      expect(() => lanTransferClientService.cancelTransfer()).not.toThrow()
+    })
+  })
+
+  describe('dispose', () => {
+    it('should clean up resources without throwing', async () => {
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      // Should not throw
+      expect(() => lanTransferClientService.dispose()).not.toThrow()
+    })
+  })
+
+  describe('sendFile', () => {
+    it('should throw error when not connected', async () => {
+      const { lanTransferClientService } = await import('../LanTransferClientService')
+
+      await expect(lanTransferClientService.sendFile('/path/to/file.zip')).rejects.toThrow(
+        'No active connection. Please connect to a peer first.'
+      )
+    })
+  })
+
+  describe('HANDSHAKE_PROTOCOL_VERSION', () => {
+    it('should export protocol version', async () => {
+      const { HANDSHAKE_PROTOCOL_VERSION } = await import('../LanTransferClientService')
+
+      expect(HANDSHAKE_PROTOCOL_VERSION).toBe('1')
+    })
+  })
+})
--- a/src/main/services/lanTransfer/tests/binaryProtocol.test.ts
+++ b/src/main/services/lanTransfer/tests/binaryProtocol.test.ts
@ -13,6 +13,8 @@ describe('binaryProtocol', () => {
    beforeEach(() => {
      writtenBuffers = []
      mockSocket = Object.assign(new EventEmitter(), {
+        destroyed: false,
+        writable: true,
        write: vi.fn((buffer: Buffer) => {
          writtenBuffers.push(Buffer.from(buffer))
          return true
@ -79,6 +81,18 @@ describe('binaryProtocol', () => {
      const expectedTotalLen = 1 + 2 + Buffer.from(transferId).length + 4 + data.length
      expect(totalLen).toBe(expectedTotalLen)
    })
+
+    it('should throw error when socket is not writable', () => {
+      mockSocket.writable = false
+
+      expect(() => sendBinaryChunk(mockSocket, 'test-id', 0, Buffer.from('data'))).toThrow('Socket is not writable')
+    })
+
+    it('should throw error when socket is destroyed', () => {
+      mockSocket.destroyed = true
+
+      expect(() => sendBinaryChunk(mockSocket, 'test-id', 0, Buffer.from('data'))).toThrow('Socket is not writable')
+    })
  })

  describe('BINARY_TYPE_FILE_CHUNK', () => {
--- a/src/main/services/lanTransfer/tests/handlers/connection.test.ts
+++ b/src/main/services/lanTransfer/tests/handlers/connection.test.ts
@ -1,11 +1,15 @@
-import { describe, expect, it, vi } from 'vitest'
+import { EventEmitter } from 'node:events'
+import type { Socket } from 'node:net'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

 import {
  buildHandshakeMessage,
  createDataHandler,
  getAbortError,
  HANDSHAKE_PROTOCOL_VERSION,
-  pickHost
+  pickHost,
+  waitForSocketDrain
 } from '../../handlers/connection'

 // Mock electron app
@ -28,7 +32,7 @@ describe('connection handlers', () => {
      expect(typeof message.platform).toBe('string')
    })

-    it('should use protocol version 3', () => {
+    it('should use protocol version 1', () => {
    expect(HANDSHAKE_PROTOCOL_VERSION).toBe('1')
    })
  })
@ -137,6 +141,105 @@ describe('connection handlers', () => {

      expect(lines).toEqual(['{"type":"test"}'])
    })
+
+    it('should throw error when buffer exceeds MAX_LINE_BUFFER_SIZE', () => {
+      const handler = createDataHandler(vi.fn())
+
+      // Create a buffer larger than 1MB (MAX_LINE_BUFFER_SIZE)
+      const largeData = 'x'.repeat(1024 * 1024 + 1)
+
+      expect(() => handler.handleData(Buffer.from(largeData))).toThrow('Control message too large')
+    })
+
+    it('should reset buffer after exceeding MAX_LINE_BUFFER_SIZE', () => {
+      const lines: string[] = []
+      const handler = createDataHandler((line) => lines.push(line))
+
+      // Create a buffer larger than 1MB
+      const largeData = 'x'.repeat(1024 * 1024 + 1)
+
+      try {
+        handler.handleData(Buffer.from(largeData))
+      } catch {
+        // Expected error
+      }
+
+      // Buffer should be reset, so lineBuffer should be empty
+      expect(handler.lineBuffer).toBe('')
+    })
+  })
+
+  describe('waitForSocketDrain', () => {
+    let mockSocket: Socket & EventEmitter
+
+    beforeEach(() => {
+      mockSocket = Object.assign(new EventEmitter(), {
+        destroyed: false,
+        writable: true,
+        write: vi.fn(),
+        off: vi.fn(),
+        removeAllListeners: vi.fn()
+      }) as unknown as Socket & EventEmitter
+    })
+
+    afterEach(() => {
+      vi.resetAllMocks()
+    })
+
+    it('should throw error when abort signal is already aborted', async () => {
+      const abortController = new AbortController()
+      abortController.abort(new Error('Already aborted'))
+
+      await expect(waitForSocketDrain(mockSocket, abortController.signal)).rejects.toThrow('Already aborted')
+    })
+
+    it('should throw error when socket is destroyed', async () => {
+      mockSocket.destroyed = true
+      const abortController = new AbortController()
+
+      await expect(waitForSocketDrain(mockSocket, abortController.signal)).rejects.toThrow('Socket is closed')
+    })
+
+    it('should resolve when drain event is emitted', async () => {
+      const abortController = new AbortController()
+
+      const drainPromise = waitForSocketDrain(mockSocket, abortController.signal)
+
+      // Emit drain event after a short delay
+      setImmediate(() => mockSocket.emit('drain'))
+
+      await expect(drainPromise).resolves.toBeUndefined()
+    })
+
+    it('should reject when close event is emitted', async () => {
+      const abortController = new AbortController()
+
+      const drainPromise = waitForSocketDrain(mockSocket, abortController.signal)
+
+      setImmediate(() => mockSocket.emit('close'))
+
+      await expect(drainPromise).rejects.toThrow('Socket closed while waiting for drain')
+    })
+
+    it('should reject when error event is emitted', async () => {
+      const abortController = new AbortController()
+
+      const drainPromise = waitForSocketDrain(mockSocket, abortController.signal)
+
+      setImmediate(() => mockSocket.emit('error', new Error('Network error')))
+
+      await expect(drainPromise).rejects.toThrow('Network error')
+    })
+
+    it('should reject when abort signal is triggered', async () => {
+      const abortController = new AbortController()
+
+      const drainPromise = waitForSocketDrain(mockSocket, abortController.signal)
+
+      setImmediate(() => abortController.abort(new Error('User cancelled')))
+
+      await expect(drainPromise).rejects.toThrow('User cancelled')
+    })
  })

  describe('getAbortError', () => {
--- a/src/main/services/lanTransfer/tests/handlers/fileTransfer.test.ts
+++ b/src/main/services/lanTransfer/tests/handlers/fileTransfer.test.ts
@ -1,10 +1,28 @@
+import { EventEmitter } from 'node:events'
 import type * as fs from 'node:fs'
+import type { Socket } from 'node:net'

-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

-import { abortTransfer, cleanupTransfer, createTransferState, formatFileSize } from '../../handlers/fileTransfer'
+import { abortTransfer, cleanupTransfer, createTransferState, formatFileSize, streamFileChunks } from '../../handlers/fileTransfer'
 import type { ActiveFileTransfer } from '../../types'

+// Mock binaryProtocol
+vi.mock('../../binaryProtocol', () => ({
+  sendBinaryChunk: vi.fn().mockReturnValue(true)
+}))
+
+// Mock connection handlers
+vi.mock('./connection', () => ({
+  waitForSocketDrain: vi.fn().mockResolvedValue(undefined),
+  getAbortError: vi.fn((signal, fallback) => {
+    const reason = (signal as AbortSignal & { reason?: unknown }).reason
+    if (reason instanceof Error) return reason
+    if (typeof reason === 'string' && reason.length > 0) return new Error(reason)
+    return new Error(fallback)
+  })
+}))
+
 // Note: validateFile and calculateFileChecksum tests are skipped because
 // the test environment has globally mocked node:fs and node:os modules.
 // These functions are tested through integration tests instead.
@ -149,4 +167,44 @@ describe('fileTransfer handlers', () => {
      expect(formatFileSize(1.5 * 1024 * 1024)).toBe('1.5 MB')
    })
  })
+
+  // Note: streamFileChunks tests require careful mocking of fs.createReadStream
+  // which is globally mocked in the test environment. These tests verify the
+  // streaming logic works correctly with mock streams.
+  describe('streamFileChunks', () => {
+    let mockSocket: Socket & EventEmitter
+    let mockProgress: ReturnType<typeof vi.fn>
+
+    beforeEach(() => {
+      vi.clearAllMocks()
+
+      mockSocket = Object.assign(new EventEmitter(), {
+        destroyed: false,
+        writable: true,
+        write: vi.fn().mockReturnValue(true),
+        cork: vi.fn(),
+        uncork: vi.fn()
+      }) as unknown as Socket & EventEmitter
+
+      mockProgress = vi.fn()
+    })
+
+    afterEach(() => {
+      vi.resetAllMocks()
+    })
+
+    it('should throw when abort signal is already aborted', async () => {
+      const transfer = createTransferState('test-id', 'test.zip', 1024, 'checksum')
+      transfer.abortController.abort(new Error('Already cancelled'))
+
+      await expect(
+        streamFileChunks(mockSocket, '/fake/path.zip', transfer, transfer.abortController.signal, mockProgress)
+      ).rejects.toThrow()
+    })
+
+    // Note: Full integration testing of streamFileChunks with actual file streaming
+    // requires a real file system, which cannot be easily mocked in ESM.
+    // The abort signal test above verifies the early abort path.
+    // Additional streaming tests are covered through integration tests.
+  })
 })
--- a/src/main/services/lanTransfer/binaryProtocol.ts
+++ b/src/main/services/lanTransfer/binaryProtocol.ts
@ -1,12 +1,12 @@
 import type { Socket } from 'node:net'

 /**
- * Binary protocol constants (v3)
+ * Binary protocol constants (v1)
 */
 export const BINARY_TYPE_FILE_CHUNK = 0x01

 /**
- * Send file chunk as binary frame (protocol v3 - streaming mode)
+ * Send file chunk as binary frame (protocol v1 - streaming mode)
 *
 * Frame format:
 * ```
@ -23,6 +23,10 @@ export const BINARY_TYPE_FILE_CHUNK = 0x01
 * @returns true if data was buffered, false if backpressure should be applied
 */
 export function sendBinaryChunk(socket: Socket, transferId: string, chunkIndex: number, data: Buffer): boolean {
+  if (!socket || socket.destroyed || !socket.writable) {
+    throw new Error('Socket is not writable')
+  }
+
  const tidBuffer = Buffer.from(transferId, 'utf8')
  const tidLen = tidBuffer.length

--- a/src/main/services/lanTransfer/handlers/connection.ts
+++ b/src/main/services/lanTransfer/handlers/connection.ts
@ -9,6 +9,9 @@ import type { ConnectionContext } from '../types'

 export const HANDSHAKE_PROTOCOL_VERSION = '1'

+/** Maximum size for line buffer to prevent memory exhaustion from malicious peers */
+const MAX_LINE_BUFFER_SIZE = 1024 * 1024 // 1MB limit for control messages
+
 const logger = loggerService.withContext('LanTransferConnection')

 /**
@ -74,6 +77,14 @@ export function createDataHandler(onControlLine: (line: string) => void): {
    },
    handleData(chunk: Buffer) {
      lineBuffer += chunk.toString('utf8')
+
+      // Prevent memory exhaustion from malicious peers sending data without newlines
+      if (lineBuffer.length > MAX_LINE_BUFFER_SIZE) {
+        logger.error('Line buffer exceeded maximum size, resetting')
+        lineBuffer = ''
+        throw new Error('Control message too large')
+      }
+
      let newlineIndex = lineBuffer.indexOf('\n')
      while (newlineIndex !== -1) {
        const line = lineBuffer.slice(0, newlineIndex).trim()
--- a/src/main/services/lanTransfer/handlers/fileTransfer.ts
+++ b/src/main/services/lanTransfer/handlers/fileTransfer.ts
@ -32,8 +32,17 @@ export async function validateFile(filePath: string): Promise<{ stats: fs.Stats;
  let stats: fs.Stats
  try {
    stats = await fs.promises.stat(filePath)
-  } catch {
-    throw new Error(`File not found: ${filePath}`)
+  } catch (error) {
+    const nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code === 'ENOENT') {
+      throw new Error(`File not found: ${filePath}`)
+    } else if (nodeError.code === 'EACCES') {
+      throw new Error(`Permission denied: ${filePath}`)
+    } else if (nodeError.code === 'ENOTDIR') {
+      throw new Error(`Invalid path: ${filePath}`)
+    } else {
+      throw new Error(`Cannot access file: ${filePath} (${nodeError.code || 'unknown error'})`)
+    }
  }

  if (!stats.isFile()) {
@ -166,7 +175,7 @@ export function sendFileEnd(ctx: FileTransferContext, transferId: string): void
 }

 /**
- * Stream file chunks to the receiver (v3 streaming mode - no per-chunk acknowledgment).
+ * Stream file chunks to the receiver (v1 streaming mode - no per-chunk acknowledgment).
 */
 export async function streamFileChunks(
  socket: Socket,
@ -192,7 +201,7 @@ export async function streamFileChunks(
      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
      bytesSent += buffer.length

-      // Send chunk as binary frame (v3 streaming) with backpressure handling
+      // Send chunk as binary frame (v1 streaming) with backpressure handling
      const canContinue = sendBinaryChunk(socket, transferId, chunkIndex, buffer)
      if (!canContinue) {
        await waitForSocketDrain(socket, abortSignal)
--- a/src/main/services/lanTransfer/index.ts
+++ b/src/main/services/lanTransfer/index.ts
@ -1,7 +1,7 @@
 /**
 * LAN Transfer Client Module
 *
- * Protocol: v3.0 (streaming mode)
+ * Protocol: v1.0 (streaming mode)
 *
 * Features:
 * - Binary frame format for file chunks (no base64 overhead)
--- a/src/main/utils/tests/process.test.ts
+++ b/src/main/utils/tests/process.test.ts
@ -1,9 +1,21 @@
+import { configManager } from '@main/services/ConfigManager'
 import { execFileSync } from 'child_process'
 import fs from 'fs'
 import path from 'path'
 import { beforeEach, describe, expect, it, vi } from 'vitest'

-import { findExecutable, findGitBash, validateGitBashPath } from '../process'
+import { autoDiscoverGitBash, findExecutable, findGitBash, validateGitBashPath } from '../process'
+
+// Mock configManager
+vi.mock('@main/services/ConfigManager', () => ({
+  ConfigKeys: {
+    GitBashPath: 'gitBashPath'
+  },
+  configManager: {
+    get: vi.fn(),
+    set: vi.fn()
+  }
+}))

 // Mock dependencies
 vi.mock('child_process')
@ -695,4 +707,284 @@ describe.skipIf(process.platform !== 'win32')('process utilities', () => {
      })
    })
  })
+
+  describe('autoDiscoverGitBash', () => {
+    const originalEnvVar = process.env.CLAUDE_CODE_GIT_BASH_PATH
+
+    beforeEach(() => {
+      vi.mocked(configManager.get).mockReset()
+      vi.mocked(configManager.set).mockReset()
+      delete process.env.CLAUDE_CODE_GIT_BASH_PATH
+    })
+
+    afterEach(() => {
+      // Restore original environment variable
+      if (originalEnvVar !== undefined) {
+        process.env.CLAUDE_CODE_GIT_BASH_PATH = originalEnvVar
+      } else {
+        delete process.env.CLAUDE_CODE_GIT_BASH_PATH
+      }
+    })
+
+    /**
+     * Helper to mock fs.existsSync with a set of valid paths
+     */
+    const mockExistingPaths = (...validPaths: string[]) => {
+      vi.mocked(fs.existsSync).mockImplementation((p) => validPaths.includes(p as string))
+    }
+
+    describe('with no existing config path', () => {
+      it('should discover and persist Git Bash path when not configured', () => {
+        const bashPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        mockExistingPaths(gitPath, bashPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(bashPath)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', bashPath)
+      })
+
+      it('should return null and not persist when Git Bash is not found', () => {
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+        vi.mocked(fs.existsSync).mockReturnValue(false)
+        vi.mocked(execFileSync).mockImplementation(() => {
+          throw new Error('Not found')
+        })
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBeNull()
+        expect(configManager.set).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('environment variable precedence', () => {
+      it('should use env var over valid config path', () => {
+        const envPath = 'C:\\EnvGit\\bin\\bash.exe'
+        const configPath = 'C:\\ConfigGit\\bin\\bash.exe'
+
+        process.env.CLAUDE_CODE_GIT_BASH_PATH = envPath
+        vi.mocked(configManager.get).mockReturnValue(configPath)
+        mockExistingPaths(envPath, configPath)
+
+        const result = autoDiscoverGitBash()
+
+        // Env var should take precedence
+        expect(result).toBe(envPath)
+        // Should not persist env var path (it's a runtime override)
+        expect(configManager.set).not.toHaveBeenCalled()
+      })
+
+      it('should fall back to config path when env var is invalid', () => {
+        const envPath = 'C:\\Invalid\\bash.exe'
+        const configPath = 'C:\\ConfigGit\\bin\\bash.exe'
+
+        process.env.CLAUDE_CODE_GIT_BASH_PATH = envPath
+        vi.mocked(configManager.get).mockReturnValue(configPath)
+        // Env path is invalid (doesn't exist), only config path exists
+        mockExistingPaths(configPath)
+
+        const result = autoDiscoverGitBash()
+
+        // Should fall back to config path
+        expect(result).toBe(configPath)
+        expect(configManager.set).not.toHaveBeenCalled()
+      })
+
+      it('should fall back to auto-discovery when both env var and config are invalid', () => {
+        const envPath = 'C:\\InvalidEnv\\bash.exe'
+        const configPath = 'C:\\InvalidConfig\\bash.exe'
+        const discoveredPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        process.env.CLAUDE_CODE_GIT_BASH_PATH = envPath
+        process.env.ProgramFiles = 'C:\\Program Files'
+        vi.mocked(configManager.get).mockReturnValue(configPath)
+        // Both env and config paths are invalid, only standard Git exists
+        mockExistingPaths(gitPath, discoveredPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(discoveredPath)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', discoveredPath)
+      })
+    })
+
+    describe('with valid existing config path', () => {
+      it('should validate and return existing path without re-discovering', () => {
+        const existingPath = 'C:\\CustomGit\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(existingPath)
+        mockExistingPaths(existingPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(existingPath)
+        // Should not call findGitBash or persist again
+        expect(configManager.set).not.toHaveBeenCalled()
+        // Should not call execFileSync (which findGitBash would use for discovery)
+        expect(execFileSync).not.toHaveBeenCalled()
+      })
+
+      it('should not override existing valid config with auto-discovery', () => {
+        const existingPath = 'C:\\CustomGit\\bin\\bash.exe'
+        const discoveredPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(existingPath)
+        mockExistingPaths(existingPath, discoveredPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(existingPath)
+        expect(configManager.set).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('with invalid existing config path', () => {
+      it('should attempt auto-discovery when existing path does not exist', () => {
+        const existingPath = 'C:\\NonExistent\\bin\\bash.exe'
+        const discoveredPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(existingPath)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        // Invalid path doesn't exist, but Git is installed at standard location
+        mockExistingPaths(gitPath, discoveredPath)
+
+        const result = autoDiscoverGitBash()
+
+        // Should discover and return the new path
+        expect(result).toBe(discoveredPath)
+        // Should persist the discovered path (overwrites invalid)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', discoveredPath)
+      })
+
+      it('should attempt auto-discovery when existing path is not bash.exe', () => {
+        const existingPath = 'C:\\CustomGit\\bin\\git.exe'
+        const discoveredPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(existingPath)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        // Invalid path exists but is not bash.exe (validation will fail)
+        // Git is installed at standard location
+        mockExistingPaths(existingPath, gitPath, discoveredPath)
+
+        const result = autoDiscoverGitBash()
+
+        // Should discover and return the new path
+        expect(result).toBe(discoveredPath)
+        // Should persist the discovered path (overwrites invalid)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', discoveredPath)
+      })
+
+      it('should return null when existing path is invalid and discovery fails', () => {
+        const existingPath = 'C:\\NonExistent\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(existingPath)
+        vi.mocked(fs.existsSync).mockReturnValue(false)
+        vi.mocked(execFileSync).mockImplementation(() => {
+          throw new Error('Not found')
+        })
+
+        const result = autoDiscoverGitBash()
+
+        // Both validation and discovery failed
+        expect(result).toBeNull()
+        // Should not persist when discovery fails
+        expect(configManager.set).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('config persistence verification', () => {
+      it('should persist discovered path with correct config key', () => {
+        const bashPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        mockExistingPaths(gitPath, bashPath)
+
+        autoDiscoverGitBash()
+
+        // Verify the exact call to configManager.set
+        expect(configManager.set).toHaveBeenCalledTimes(1)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', bashPath)
+      })
+
+      it('should persist on each discovery when config remains undefined', () => {
+        const bashPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        mockExistingPaths(gitPath, bashPath)
+
+        autoDiscoverGitBash()
+        autoDiscoverGitBash()
+
+        // Each call discovers and persists since config remains undefined (mocked)
+        expect(configManager.set).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe('real-world scenarios', () => {
+      it('should discover and persist standard Git for Windows installation', () => {
+        const gitPath = 'C:\\Program Files\\Git\\cmd\\git.exe'
+        const bashPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+        process.env.ProgramFiles = 'C:\\Program Files'
+        mockExistingPaths(gitPath, bashPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(bashPath)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', bashPath)
+      })
+
+      it('should discover portable Git via where.exe and persist', () => {
+        const gitPath = 'D:\\PortableApps\\Git\\bin\\git.exe'
+        const bashPath = 'D:\\PortableApps\\Git\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(undefined)
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+          const pathStr = p?.toString() || ''
+          // Common git paths don't exist
+          if (pathStr.includes('Program Files\\Git\\cmd\\git.exe')) return false
+          if (pathStr.includes('Program Files (x86)\\Git\\cmd\\git.exe')) return false
+          // Portable bash path exists
+          if (pathStr === bashPath) return true
+          return false
+        })
+
+        vi.mocked(execFileSync).mockReturnValue(gitPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(bashPath)
+        expect(configManager.set).toHaveBeenCalledWith('gitBashPath', bashPath)
+      })
+
+      it('should respect user-configured path over auto-discovery', () => {
+        const userConfiguredPath = 'D:\\MyGit\\bin\\bash.exe'
+        const systemPath = 'C:\\Program Files\\Git\\bin\\bash.exe'
+
+        vi.mocked(configManager.get).mockReturnValue(userConfiguredPath)
+        mockExistingPaths(userConfiguredPath, systemPath)
+
+        const result = autoDiscoverGitBash()
+
+        expect(result).toBe(userConfiguredPath)
+        expect(configManager.set).not.toHaveBeenCalled()
+        // Verify findGitBash was not called for discovery
+        expect(execFileSync).not.toHaveBeenCalled()
+      })
+    })
+  })
 })
--- a/src/main/utils/process.ts
+++ b/src/main/utils/process.ts
@ -1,4 +1,5 @@
 import { loggerService } from '@logger'
+import type { GitBashPathInfo, GitBashPathSource } from '@shared/config/constant'
 import { HOME_CHERRY_DIR } from '@shared/config/constant'
 import { execFileSync, spawn } from 'child_process'
 import fs from 'fs'
@ -6,6 +7,7 @@ import os from 'os'
 import path from 'path'

 import { isWin } from '../constant'
+import { ConfigKeys, configManager } from '../services/ConfigManager'
 import { getResourcePath } from '.'

 const logger = loggerService.withContext('Utils:Process')
@ -59,7 +61,7 @@ export async function getBinaryPath(name?: string): Promise<string> {

 export async function isBinaryExists(name: string): Promise<boolean> {
  const cmd = await getBinaryPath(name)
-  return await fs.existsSync(cmd)
+  return fs.existsSync(cmd)
 }

 /**
@ -225,3 +227,77 @@ export function validateGitBashPath(customPath?: string | null): string | null {
  logger.debug('Validated custom Git Bash path', { path: resolved })
  return resolved
 }
+
+/**
+ * Auto-discover and persist Git Bash path if not already configured
+ * Only called when Git Bash is actually needed
+ *
+ * Precedence order:
+ * 1. CLAUDE_CODE_GIT_BASH_PATH environment variable (highest - runtime override)
+ * 2. Configured path from settings (manual or auto)
+ * 3. Auto-discovery via findGitBash (only if no valid config exists)
+ */
+export function autoDiscoverGitBash(): string | null {
+  if (!isWin) {
+    return null
+  }
+
+  // 1. Check environment variable override first (highest priority)
+  const envOverride = process.env.CLAUDE_CODE_GIT_BASH_PATH
+  if (envOverride) {
+    const validated = validateGitBashPath(envOverride)
+    if (validated) {
+      logger.debug('Using CLAUDE_CODE_GIT_BASH_PATH override', { path: validated })
+      return validated
+    }
+    logger.warn('CLAUDE_CODE_GIT_BASH_PATH provided but path is invalid', { path: envOverride })
+  }
+
+  // 2. Check if a path is already configured
+  const existingPath = configManager.get<string | undefined>(ConfigKeys.GitBashPath)
+  const existingSource = configManager.get<GitBashPathSource | undefined>(ConfigKeys.GitBashPathSource)
+
+  if (existingPath) {
+    const validated = validateGitBashPath(existingPath)
+    if (validated) {
+      return validated
+    }
+    // Existing path is invalid, try to auto-discover
+    logger.warn('Existing Git Bash path is invalid, attempting auto-discovery', {
+      path: existingPath,
+      source: existingSource
+    })
+  }
+
+  // 3. Try to find Git Bash via auto-discovery
+  const discoveredPath = findGitBash()
+  if (discoveredPath) {
+    // Persist the discovered path with 'auto' source
+    configManager.set(ConfigKeys.GitBashPath, discoveredPath)
+    configManager.set(ConfigKeys.GitBashPathSource, 'auto')
+    logger.info('Auto-discovered Git Bash path', { path: discoveredPath })
+  }
+
+  return discoveredPath
+}
+
+/**
+ * Get Git Bash path info including source
+ * If no path is configured, triggers auto-discovery first
+ */
+export function getGitBashPathInfo(): GitBashPathInfo {
+  if (!isWin) {
+    return { path: null, source: null }
+  }
+
+  let path = configManager.get<string | null>(ConfigKeys.GitBashPath) ?? null
+  let source = configManager.get<GitBashPathSource | null>(ConfigKeys.GitBashPathSource) ?? null
+
+  // If no path configured, trigger auto-discovery (handles upgrade from old versions)
+  if (!path) {
+    path = autoDiscoverGitBash()
+    source = path ? 'auto' : null
+  }
+
+  return { path, source }
+}
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@ -2,7 +2,7 @@ import type { PermissionUpdate } from '@anthropic-ai/claude-agent-sdk'
 import { electronAPI } from '@electron-toolkit/preload'
 import type { SpanEntity, TokenUsage } from '@mcp-trace/trace-core'
 import type { SpanContext } from '@opentelemetry/api'
-import type { TerminalConfig, UpgradeChannel } from '@shared/config/constant'
+import type { GitBashPathInfo, TerminalConfig, UpgradeChannel } from '@shared/config/constant'
 import type { LogLevel, LogSourceWithContext } from '@shared/config/logger'
 import type {
  FileChangeEvent,
@ -134,6 +134,7 @@ const api = {
    getCpuName: () => ipcRenderer.invoke(IpcChannel.System_GetCpuName),
    checkGitBash: (): Promise<boolean> => ipcRenderer.invoke(IpcChannel.System_CheckGitBash),
    getGitBashPath: (): Promise<string | null> => ipcRenderer.invoke(IpcChannel.System_GetGitBashPath),
+    getGitBashPathInfo: (): Promise<GitBashPathInfo> => ipcRenderer.invoke(IpcChannel.System_GetGitBashPathInfo),
    setGitBashPath: (newPath: string | null): Promise<boolean> =>
      ipcRenderer.invoke(IpcChannel.System_SetGitBashPath, newPath)
  },
@ -626,13 +627,6 @@ const api = {
    sendFile: (filePath: string): Promise<LanFileCompleteMessage> =>
      ipcRenderer.invoke(IpcChannel.LocalTransfer_SendFile, { filePath }),
    cancelTransfer: (): Promise<void> => ipcRenderer.invoke(IpcChannel.LocalTransfer_CancelTransfer)
-  },
-  webSocket: {
-    start: () => ipcRenderer.invoke(IpcChannel.WebSocket_Start),
-    stop: () => ipcRenderer.invoke(IpcChannel.WebSocket_Stop),
-    status: () => ipcRenderer.invoke(IpcChannel.WebSocket_Status),
-    sendFile: (filePath: string) => ipcRenderer.invoke(IpcChannel.WebSocket_SendFile, filePath),
-    getAllCandidates: () => ipcRenderer.invoke(IpcChannel.WebSocket_GetAllCandidates)
  }
 }

--- a/src/renderer/src/aiCore/middleware/AiSdkMiddlewareBuilder.ts
+++ b/src/renderer/src/aiCore/middleware/AiSdkMiddlewareBuilder.ts
@ -7,7 +7,6 @@ import type { Chunk } from '@renderer/types/chunk'
 import { isOllamaProvider, isSupportEnableThinkingProvider } from '@renderer/utils/provider'
 import type { LanguageModelMiddleware } from 'ai'
 import { extractReasoningMiddleware, simulateStreamingMiddleware } from 'ai'
-import { isEmpty } from 'lodash'

 import { getAiSdkProviderId } from '../provider/factory'
 import { isOpenRouterGeminiGenerateImageModel } from '../utils/image'
@ -16,7 +15,6 @@ import { openrouterGenerateImageMiddleware } from './openrouterGenerateImageMidd
 import { openrouterReasoningMiddleware } from './openrouterReasoningMiddleware'
 import { qwenThinkingMiddleware } from './qwenThinkingMiddleware'
 import { skipGeminiThoughtSignatureMiddleware } from './skipGeminiThoughtSignatureMiddleware'
-import { toolChoiceMiddleware } from './toolChoiceMiddleware'

 const logger = loggerService.withContext('AiSdkMiddlewareBuilder')

@ -136,15 +134,6 @@ export class AiSdkMiddlewareBuilder {
 export function buildAiSdkMiddlewares(config: AiSdkMiddlewareConfig): LanguageModelMiddleware[] {
  const builder = new AiSdkMiddlewareBuilder()

-  // 0. 知识库强制调用中间件（必须在最前面，确保第一轮强制调用知识库）
-  if (!isEmpty(config.assistant?.knowledge_bases?.map((base) => base.id)) && config.knowledgeRecognition !== 'on') {
-    builder.add({
-      name: 'force-knowledge-first',
-      middleware: toolChoiceMiddleware('builtin_knowledge_search')
-    })
-    logger.debug('Added toolChoice middleware to force knowledge base search on first round')
-  }
-
  // 1. 根据provider添加特定中间件
  if (config.provider) {
    addProviderSpecificMiddlewares(builder, config)
--- a/src/renderer/src/aiCore/plugins/searchOrchestrationPlugin.ts
+++ b/src/renderer/src/aiCore/plugins/searchOrchestrationPlugin.ts
@ -31,7 +31,7 @@ import { webSearchToolWithPreExtractedKeywords } from '../tools/WebSearchTool'

 const logger = loggerService.withContext('SearchOrchestrationPlugin')

-const getMessageContent = (message: ModelMessage) => {
+export const getMessageContent = (message: ModelMessage) => {
  if (typeof message.content === 'string') return message.content
  return message.content.reduce((acc, part) => {
    if (part.type === 'text') {
@ -266,14 +266,14 @@ export const searchOrchestrationPlugin = (assistant: Assistant, topicId: string)
        // 判断是否需要各种搜索
        const knowledgeBaseIds = assistant.knowledge_bases?.map((base) => base.id)
        const hasKnowledgeBase = !isEmpty(knowledgeBaseIds)
-        const knowledgeRecognition = assistant.knowledgeRecognition || 'on'
+        const knowledgeRecognition = assistant.knowledgeRecognition || 'off'
        const globalMemoryEnabled = selectGlobalMemoryEnabled(store.getState())
        const shouldWebSearch = !!assistant.webSearchProviderId
        const shouldKnowledgeSearch = hasKnowledgeBase && knowledgeRecognition === 'on'
        const shouldMemorySearch = globalMemoryEnabled && assistant.enableMemory

        // 执行意图分析
-        if (shouldWebSearch || hasKnowledgeBase) {
+        if (shouldWebSearch || shouldKnowledgeSearch) {
          const analysisResult = await analyzeSearchIntent(lastUserMessage, assistant, {
            shouldWebSearch,
            shouldKnowledgeSearch,
@ -330,41 +330,25 @@ export const searchOrchestrationPlugin = (assistant: Assistant, topicId: string)
        // 📚 知识库搜索工具配置
        const knowledgeBaseIds = assistant.knowledge_bases?.map((base) => base.id)
        const hasKnowledgeBase = !isEmpty(knowledgeBaseIds)
-        const knowledgeRecognition = assistant.knowledgeRecognition || 'on'
+        const knowledgeRecognition = assistant.knowledgeRecognition || 'off'
+        const shouldKnowledgeSearch = hasKnowledgeBase && knowledgeRecognition === 'on'

-        if (hasKnowledgeBase) {
-          if (knowledgeRecognition === 'off') {
-            // off 模式：直接添加知识库搜索工具，使用用户消息作为搜索关键词
+        if (shouldKnowledgeSearch) {
+          // on 模式：根据意图识别结果决定是否添加工具
+          const needsKnowledgeSearch =
+            analysisResult?.knowledge &&
+            analysisResult.knowledge.question &&
+            analysisResult.knowledge.question[0] !== 'not_needed'
+
+          if (needsKnowledgeSearch && analysisResult.knowledge) {
+            // logger.info('📚 Adding knowledge search tool (intent-based)')
            const userMessage = userMessages[context.requestId]
-            const fallbackKeywords = {
-              question: [getMessageContent(userMessage) || 'search'],
-              rewrite: getMessageContent(userMessage) || 'search'
-            }
-            // logger.info('📚 Adding knowledge search tool (force mode)')
            params.tools['builtin_knowledge_search'] = knowledgeSearchTool(
              assistant,
-              fallbackKeywords,
+              analysisResult.knowledge,
              getMessageContent(userMessage),
              topicId
            )
-            // params.toolChoice = { type: 'tool', toolName: 'builtin_knowledge_search' }
-          } else {
-            // on 模式：根据意图识别结果决定是否添加工具
-            const needsKnowledgeSearch =
-              analysisResult?.knowledge &&
-              analysisResult.knowledge.question &&
-              analysisResult.knowledge.question[0] !== 'not_needed'
-
-            if (needsKnowledgeSearch && analysisResult.knowledge) {
-              // logger.info('📚 Adding knowledge search tool (intent-based)')
-              const userMessage = userMessages[context.requestId]
-              params.tools['builtin_knowledge_search'] = knowledgeSearchTool(
-                assistant,
-                analysisResult.knowledge,
-                getMessageContent(userMessage),
-                topicId
-              )
-            }
          }
        }

--- a/src/renderer/src/components/Popups/agent/AgentModal.tsx
+++ b/src/renderer/src/components/Popups/agent/AgentModal.tsx
@ -3,6 +3,7 @@ import { ErrorBoundary } from '@renderer/components/ErrorBoundary'
 import { HelpTooltip } from '@renderer/components/TooltipIcons'
 import { TopView } from '@renderer/components/TopView'
 import { permissionModeCards } from '@renderer/config/agent'
+import { isWin } from '@renderer/config/constant'
 import { useAgents } from '@renderer/hooks/agents/useAgents'
 import { useUpdateAgent } from '@renderer/hooks/agents/useUpdateAgent'
 import SelectAgentBaseModelButton from '@renderer/pages/home/components/SelectAgentBaseModelButton'
@ -16,7 +17,8 @@ import type {
  UpdateAgentForm
 } from '@renderer/types'
 import { AgentConfigurationSchema, isAgentType } from '@renderer/types'
-import { Alert, Button, Input, Modal, Select } from 'antd'
+import type { GitBashPathInfo } from '@shared/config/constant'
+import { Button, Input, Modal, Select } from 'antd'
 import { AlertTriangleIcon } from 'lucide-react'
 import type { ChangeEvent, FormEvent } from 'react'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
@ -59,8 +61,7 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
  const isEditing = (agent?: AgentWithTools) => agent !== undefined

  const [form, setForm] = useState<BaseAgentForm>(() => buildAgentForm(agent))
-  const [hasGitBash, setHasGitBash] = useState<boolean>(true)
-  const [customGitBashPath, setCustomGitBashPath] = useState<string>('')
+  const [gitBashPathInfo, setGitBashPathInfo] = useState<GitBashPathInfo>({ path: null, source: null })

  useEffect(() => {
    if (open) {
@ -68,29 +69,15 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
    }
  }, [agent, open])

-  const checkGitBash = useCallback(
-    async (showToast = false) => {
-      try {
-        const [gitBashInstalled, savedPath] = await Promise.all([
-          window.api.system.checkGitBash(),
-          window.api.system.getGitBashPath().catch(() => null)
-        ])
-        setCustomGitBashPath(savedPath ?? '')
-        setHasGitBash(gitBashInstalled)
-        if (showToast) {
-          if (gitBashInstalled) {
-            window.toast.success(t('agent.gitBash.success', 'Git Bash detected successfully!'))
-          } else {
-            window.toast.error(t('agent.gitBash.notFound', 'Git Bash not found. Please install it first.'))
-          }
-        }
-      } catch (error) {
-        logger.error('Failed to check Git Bash:', error as Error)
-        setHasGitBash(true) // Default to true on error to avoid false warnings
-      }
-    },
-    [t]
-  )
+  const checkGitBash = useCallback(async () => {
+    if (!isWin) return
+    try {
+      const pathInfo = await window.api.system.getGitBashPathInfo()
+      setGitBashPathInfo(pathInfo)
+    } catch (error) {
+      logger.error('Failed to check Git Bash:', error as Error)
+    }
+  }, [])

  useEffect(() => {
    checkGitBash()
@ -119,24 +106,22 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
        return
      }

-      setCustomGitBashPath(pickedPath)
-      await checkGitBash(true)
+      await checkGitBash()
    } catch (error) {
      logger.error('Failed to pick Git Bash path', error as Error)
      window.toast.error(t('agent.gitBash.pick.failed', 'Failed to set Git Bash path'))
    }
  }, [checkGitBash, t])

-  const handleClearGitBash = useCallback(async () => {
+  const handleResetGitBash = useCallback(async () => {
    try {
+      // Clear manual setting and re-run auto-discovery
      await window.api.system.setGitBashPath(null)
-      setCustomGitBashPath('')
-      await checkGitBash(true)
+      await checkGitBash()
    } catch (error) {
-      logger.error('Failed to clear Git Bash path', error as Error)
-      window.toast.error(t('agent.gitBash.pick.failed', 'Failed to set Git Bash path'))
+      logger.error('Failed to reset Git Bash path', error as Error)
    }
-  }, [checkGitBash, t])
+  }, [checkGitBash])

  const onPermissionModeChange = useCallback((value: PermissionMode) => {
    setForm((prev) => {
@ -268,6 +253,12 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
        return
      }

+      if (isWin && !gitBashPathInfo.path) {
+        window.toast.error(t('agent.gitBash.error.required', 'Git Bash path is required on Windows'))
+        loadingRef.current = false
+        return
+      }
+
      if (isEditing(agent)) {
        if (!agent) {
          loadingRef.current = false
@ -327,7 +318,8 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
      t,
      updateAgent,
      afterSubmit,
-      addAgent
+      addAgent,
+      gitBashPathInfo.path
    ]
  )

@ -346,66 +338,6 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
        footer={null}>
        <StyledForm onSubmit={onSubmit}>
          <FormContent>
-            {!hasGitBash && (
-              <Alert
-                message={t('agent.gitBash.error.title', 'Git Bash Required')}
-                description={
-                  <div>
-                    <div style={{ marginBottom: 8 }}>
-                      {t(
-                        'agent.gitBash.error.description',
-                        'Git Bash is required to run agents on Windows. The agent cannot function without it. Please install Git for Windows from'
-                      )}{' '}
-                      <a
-                        href="https://git-scm.com/download/win"
-                        onClick={(e) => {
-                          e.preventDefault()
-                          window.api.openWebsite('https://git-scm.com/download/win')
-                        }}
-                        style={{ textDecoration: 'underline' }}>
-                        git-scm.com
-                      </a>
-                    </div>
-                    <Button size="small" onClick={() => checkGitBash(true)}>
-                      {t('agent.gitBash.error.recheck', 'Recheck Git Bash Installation')}
-                    </Button>
-                    <Button size="small" style={{ marginLeft: 8 }} onClick={handlePickGitBash}>
-                      {t('agent.gitBash.pick.button', 'Select Git Bash Path')}
-                    </Button>
-                  </div>
-                }
-                type="error"
-                showIcon
-                style={{ marginBottom: 16 }}
-              />
-            )}
-
-            {hasGitBash && customGitBashPath && (
-              <Alert
-                message={t('agent.gitBash.found.title', 'Git Bash configured')}
-                description={
-                  <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
-                    <div>
-                      {t('agent.gitBash.customPath', {
-                        defaultValue: 'Using custom path: {{path}}',
-                        path: customGitBashPath
-                      })}
-                    </div>
-                    <div style={{ display: 'flex', gap: 8 }}>
-                      <Button size="small" onClick={handlePickGitBash}>
-                        {t('agent.gitBash.pick.button', 'Select Git Bash Path')}
-                      </Button>
-                      <Button size="small" onClick={handleClearGitBash}>
-                        {t('agent.gitBash.clear.button', 'Clear custom path')}
-                      </Button>
-                    </div>
-                  </div>
-                }
-                type="success"
-                showIcon
-                style={{ marginBottom: 16 }}
-              />
-            )}
            <FormRow>
              <FormItem style={{ flex: 1 }}>
                <Label>
@ -439,6 +371,40 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {
              />
            </FormItem>

+            {isWin && (
+              <FormItem>
+                <div className="flex items-center gap-2">
+                  <Label>
+                    Git Bash <RequiredMark>*</RequiredMark>
+                  </Label>
+                  <HelpTooltip
+                    title={t(
+                      'agent.gitBash.tooltip',
+                      'Git Bash is required to run agents on Windows. Install from git-scm.com if not available.'
+                    )}
+                  />
+                </div>
+                <GitBashInputWrapper>
+                  <Input
+                    value={gitBashPathInfo.path ?? ''}
+                    readOnly
+                    placeholder={t('agent.gitBash.placeholder', 'Select bash.exe path')}
+                  />
+                  <Button size="small" onClick={handlePickGitBash}>
+                    {t('common.select', 'Select')}
+                  </Button>
+                  {gitBashPathInfo.source === 'manual' && (
+                    <Button size="small" onClick={handleResetGitBash}>
+                      {t('common.reset', 'Reset')}
+                    </Button>
+                  )}
+                </GitBashInputWrapper>
+                {gitBashPathInfo.path && gitBashPathInfo.source === 'auto' && (
+                  <SourceHint>{t('agent.gitBash.autoDiscoveredHint', 'Auto-discovered')}</SourceHint>
+                )}
+              </FormItem>
+            )}
+
            <FormItem>
              <Label>
                {t('agent.settings.tooling.permissionMode.title', 'Permission mode')} <RequiredMark>*</RequiredMark>
@ -511,7 +477,11 @@ const PopupContainer: React.FC<Props> = ({ agent, afterSubmit, resolve }) => {

          <FormFooter>
            <Button onClick={onCancel}>{t('common.close')}</Button>
-            <Button type="primary" htmlType="submit" loading={loadingRef.current} disabled={!hasGitBash}>
+            <Button
+              type="primary"
+              htmlType="submit"
+              loading={loadingRef.current}
+              disabled={isWin && !gitBashPathInfo.path}>
              {isEditing(agent) ? t('common.confirm') : t('common.add')}
            </Button>
          </FormFooter>
@ -582,6 +552,21 @@ const FormItem = styled.div`
  gap: 8px;
 `

+const GitBashInputWrapper = styled.div`
+  display: flex;
+  gap: 8px;
+  align-items: center;
+
+  input {
+    flex: 1;
+  }
+`
+
+const SourceHint = styled.span`
+  font-size: 12px;
+  color: var(--color-text-3);
+`
+
 const Label = styled.label`
  font-size: 14px;
  color: var(--color-text-1);
--- a/src/renderer/src/config/models/default.ts
+++ b/src/renderer/src/config/models/default.ts
@ -362,7 +362,7 @@ export const SYSTEM_MODELS: Record<SystemProviderId | 'defaultModel', Model[]> =
    {
      id: 'gemini-3-pro-image-preview',
      provider: 'gemini',
-      name: 'Gemini 3 Pro Image Privew',
+      name: 'Gemini 3 Pro Image Preview',
      group: 'Gemini 3'
    },
    {
--- a/src/renderer/src/i18n/locales/en-us.json
+++ b/src/renderer/src/i18n/locales/en-us.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Using auto-detected Git Bash",
+      "autoDiscoveredHint": "Auto-discovered",
      "clear": {
        "button": "Clear custom path"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Git Bash is required to run agents on Windows. The agent cannot function without it. Please install Git for Windows from",
        "recheck": "Recheck Git Bash Installation",
+        "required": "Git Bash path is required on Windows",
        "title": "Git Bash Required"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "Selected file is not a valid Git Bash executable (bash.exe).",
        "title": "Select Git Bash executable"
      },
-      "success": "Git Bash detected successfully!"
+      "placeholder": "Select bash.exe path",
+      "success": "Git Bash detected successfully!",
+      "tooltip": "Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Enter your message here, send with {{key}} - @ select path, / select command"
@ -3218,12 +3222,9 @@
        },
        "content": "Export some data, including chat logs and settings. Please note that the backup process may take some time. Thank you for your patience.",
        "lan": {
-          "auto_close_tip": "Auto-closing in {{seconds}} seconds...",
-          "confirm_close_message": "File transfer is in progress. Closing will interrupt the transfer. Are you sure you want to force close?",
-          "confirm_close_title": "Confirm Close",
          "connected": "Connected",
          "connection_failed": "Connection failed",
-          "content": "Please ensure your computer and phone are on the same network for LAN transfer. Open the Cherry Studio App to scan this QR code.",
+          "content": "Please ensure your computer and phone are on the same network for LAN transfer.",
          "device_list_title": "Local network devices",
          "discovered_devices": "Discovered devices",
          "error": {
@ -3241,8 +3242,6 @@
            "progress": "Sending... {{progress}}%",
            "success": "File sent successfully"
          },
-          "force_close": "Force Close",
-          "generating_qr": "Generating QR code...",
          "handshake": {
            "button": "Handshake",
            "failed": "Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "IP addresses",
          "last_seen": "Last seen at {{time}}",
          "metadata": "Metadata",
-          "noZipSelected": "No compressed file selected",
          "no_connection_warning": "Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "No LAN peers found yet",
          "scan_devices": "Scan devices",
-          "scan_qr": "Please scan QR code with your phone",
          "scanning_hint": "Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Select a compressed file",
-          "sendZip": "Begin data recovery",
          "send_file": "Send File",
          "status": {
            "completed": "Transfer completed",
@ -3272,8 +3267,7 @@
            "error": "Connection error",
            "initializing": "Initializing connection...",
            "preparing": "Preparing transfer...",
-            "sending": "Transferring {{progress}}%",
-            "waiting_qr_scan": "Please scan QR code to connect"
+            "sending": "Transferring {{progress}}%"
          },
          "status_badge_idle": "Idle",
          "status_badge_scanning": "Scanning",
--- a/src/renderer/src/i18n/locales/zh-cn.json
+++ b/src/renderer/src/i18n/locales/zh-cn.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "使用自动检测的 Git Bash",
+      "autoDiscoveredHint": "自动发现",
      "clear": {
        "button": "清除自定义路径"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "在 Windows 上运行智能体需要 Git Bash。没有它智能体无法运行。请从以下地址安装 Git for Windows",
        "recheck": "重新检测 Git Bash 安装",
+        "required": "在 Windows 上需要配置 Git Bash 路径",
        "title": "需要 Git Bash"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "选择的文件不是有效的 Git Bash 可执行文件（bash.exe）。",
        "title": "选择 Git Bash 可执行文件"
      },
-      "success": "成功检测到 Git Bash！"
+      "placeholder": "选择 bash.exe 路径",
+      "success": "成功检测到 Git Bash！",
+      "tooltip": "在 Windows 上运行智能体需要 Git Bash。如果未安装，请从 git-scm.com 下载安装。"
    },
    "input": {
      "placeholder": "在这里输入消息，按 {{key}} 发送 - @ 选择路径， / 选择命令"
@ -3218,12 +3222,9 @@
        },
        "content": "导出部分数据，包括聊天记录、设置。请注意，备份过程可能需要一些时间，感谢您的耐心等待。",
        "lan": {
-          "auto_close_tip": "{{seconds}} 秒后自动关闭...",
-          "confirm_close_message": "文件正在传输中，关闭将中断传输。确定要强制关闭吗？",
-          "confirm_close_title": "确认关闭",
          "connected": "连接成功",
          "connection_failed": "连接失败",
-          "content": "请确保电脑和手机处于同一网络以使用局域网传输。请打开 Cherry Studio App 扫描此二维码。",
+          "content": "请确保电脑和手机处于同一网络以使用局域网传输。",
          "device_list_title": "局域网设备列表",
          "discovered_devices": "已发现的设备",
          "error": {
@ -3241,8 +3242,6 @@
            "progress": "发送中... {{progress}}%",
            "success": "文件发送成功"
          },
-          "force_close": "强制关闭",
-          "generating_qr": "正在生成二维码...",
          "handshake": {
            "button": "握手测试",
            "failed": "握手失败：{{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "IP 地址",
          "last_seen": "最后活动：{{time}}",
          "metadata": "元数据",
-          "noZipSelected": "未选择压缩文件",
          "no_connection_warning": "请在 Cherry Studio 移动端打开局域网传输",
          "no_devices": "尚未发现局域网设备",
          "scan_devices": "扫描设备",
-          "scan_qr": "请使用手机扫码连接",
          "scanning_hint": "正在扫描局域网中的 Cherry Studio 设备...",
-          "selectZip": "选择压缩文件",
-          "sendZip": "开始恢复数据",
          "send_file": "发送文件",
          "status": {
            "completed": "传输完成",
@ -3272,8 +3267,7 @@
            "error": "连接出错",
            "initializing": "正在初始化连接...",
            "preparing": "准备传输中...",
-            "sending": "传输中 {{progress}}%",
-            "waiting_qr_scan": "请扫描二维码连接"
+            "sending": "传输中 {{progress}}%"
          },
          "status_badge_idle": "空闲",
          "status_badge_scanning": "扫描中",
--- a/src/renderer/src/i18n/locales/zh-tw.json
+++ b/src/renderer/src/i18n/locales/zh-tw.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "使用自動偵測的 Git Bash",
+      "autoDiscoveredHint": "自動發現",
      "clear": {
        "button": "清除自訂路徑"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "在 Windows 上執行 Agent 需要 Git Bash。沒有它 Agent 無法運作。請從以下網址安裝 Git for Windows",
        "recheck": "重新偵測 Git Bash 安裝",
+        "required": "在 Windows 上需要設定 Git Bash 路徑",
        "title": "需要 Git Bash"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "選擇的檔案不是有效的 Git Bash 可執行檔（bash.exe）。",
        "title": "選擇 Git Bash 可執行檔"
      },
-      "success": "成功偵測到 Git Bash！"
+      "placeholder": "選擇 bash.exe 路徑",
+      "success": "成功偵測到 Git Bash！",
+      "tooltip": "在 Windows 上執行 Agent 需要 Git Bash。如未安裝，請從 git-scm.com 下載安裝。"
    },
    "input": {
      "placeholder": "在這裡輸入您的訊息，使用 {{key}} 傳送 - @ 選擇路徑，/ 選擇命令"
@ -3218,12 +3222,9 @@
        },
        "content": "匯出部分資料，包括聊天記錄與設定。請注意，備份過程可能需要一些時間，感謝耐心等候。",
        "lan": {
-          "auto_close_tip": "將於 {{seconds}} 秒後自動關閉...",
-          "confirm_close_message": "檔案傳輸正在進行中。關閉將會中斷傳輸。您確定要強制關閉嗎？",
-          "confirm_close_title": "確認關閉",
          "connected": "已連線",
          "connection_failed": "連線失敗",
-          "content": "請確保電腦和手機處於同一網路以使用區域網路傳輸。請開啟 Cherry Studio App 掃描此 QR 碼。",
+          "content": "請確保電腦和手機處於同一網路以使用區域網路傳輸。",
          "device_list_title": "區域網路裝置",
          "discovered_devices": "已發現的裝置",
          "error": {
@ -3241,8 +3242,6 @@
            "progress": "傳送中... {{progress}}%",
            "success": "檔案傳送成功"
          },
-          "force_close": "強制關閉",
-          "generating_qr": "正在產生 QR 碼...",
          "handshake": {
            "button": "握手",
            "failed": "握手失敗：{{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "IP 位址",
          "last_seen": "上次看到：{{time}}",
          "metadata": "中繼資料",
-          "noZipSelected": "未選取壓縮檔案",
          "no_connection_warning": "請在 Cherry Studio 行動裝置開啟區域網路傳輸",
          "no_devices": "尚未找到區域網路節點",
          "scan_devices": "掃描裝置",
-          "scan_qr": "請使用手機掃描 QR 碼",
          "scanning_hint": "正在掃描區域網路中的 Cherry Studio 裝置...",
-          "selectZip": "選擇壓縮檔案",
-          "sendZip": "開始還原資料",
          "send_file": "傳送檔案",
          "status": {
            "completed": "傳輸完成",
@ -3272,8 +3267,7 @@
            "error": "連線錯誤",
            "initializing": "正在初始化連線...",
            "preparing": "正在準備傳輸...",
-            "sending": "傳輸中 {{progress}}%",
-            "waiting_qr_scan": "請掃描 QR 碼以連線"
+            "sending": "傳輸中 {{progress}}%"
          },
          "status_badge_idle": "閒置",
          "status_badge_scanning": "掃描中",
--- a/src/renderer/src/i18n/translate/de-de.json
+++ b/src/renderer/src/i18n/translate/de-de.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Automatisch ermitteltes Git Bash wird verwendet",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Benutzerdefinierten Pfad löschen"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Git Bash ist erforderlich, um Agents unter Windows auszuführen. Der Agent kann ohne es nicht funktionieren. Bitte installieren Sie Git für Windows von",
        "recheck": "Überprüfe die Git Bash-Installation erneut",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Git Bash erforderlich"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "Die ausgewählte Datei ist keine gültige Git Bash ausführbare Datei (bash.exe).",
        "title": "Git Bash ausführbare Datei auswählen"
      },
-      "success": "Git Bash erfolgreich erkannt!"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Git Bash erfolgreich erkannt!",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Gib hier deine Nachricht ein, senden mit {{key}} – @ Pfad auswählen, / Befehl auswählen"
@ -3218,9 +3222,6 @@
        },
        "content": "Exportieren Sie einige Daten, einschließlich Chat-Protokollen und Einstellungen. Bitte beachten Sie, dass der Sicherungsvorgang einige Zeit in Anspruch nehmen kann. Vielen Dank für Ihre Geduld.",
        "lan": {
-          "auto_close_tip": "Automatisches Schließen in {{seconds}} Sekunden...",
-          "confirm_close_message": "Dateiübertragung läuft. Beim Schließen wird die Übertragung unterbrochen. Möchten Sie wirklich das Schließen erzwingen?",
-          "confirm_close_title": "Schließen bestätigen",
          "connected": "Verbunden",
          "connection_failed": "Verbindung fehlgeschlagen",
          "content": "Bitte stelle sicher, dass sich dein Computer und dein Telefon im selben Netzwerk befinden, um eine LAN-Übertragung durchzuführen. Öffne die Cherry Studio App, um diesen QR-Code zu scannen.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Erzwungenes Schließen",
-          "generating_qr": "QR-Code wird generiert...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "Keine komprimierte Datei ausgewählt",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Bitte scannen Sie den QR-Code mit Ihrem Telefon.",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Wählen Sie eine komprimierte Datei",
-          "sendZip": "Datenwiederherstellung beginnen",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Übertragung abgeschlossen",
@ -3272,8 +3267,7 @@
            "error": "Verbindungsfehler",
            "initializing": "Verbindung wird initialisiert...",
            "preparing": "Übertragung wird vorbereitet...",
-            "sending": "Übertrage {{progress}}%",
-            "waiting_qr_scan": "Bitte QR-Code scannen, um zu verbinden"
+            "sending": "Übertrage {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/el-gr.json
+++ b/src/renderer/src/i18n/translate/el-gr.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Χρησιμοποιείται αυτόματα εντοπισμένο Git Bash",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Διαγραφή προσαρμοσμένης διαδρομής"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Το Git Bash απαιτείται για την εκτέλεση πρακτόρων στα Windows. Ο πράκτορας δεν μπορεί να λειτουργήσει χωρίς αυτό. Παρακαλούμε εγκαταστήστε το Git για Windows από",
        "recheck": "Επανέλεγχος Εγκατάστασης του Git Bash",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Απαιτείται Git Bash"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "Το επιλεγμένο αρχείο δεν είναι έγκυρο εκτελέσιμο Git Bash (bash.exe).",
        "title": "Επιλογή εκτελέσιμου Git Bash"
      },
-      "success": "Το Git Bash εντοπίστηκε με επιτυχία!"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Το Git Bash εντοπίστηκε με επιτυχία!",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Εισάγετε το μήνυμά σας εδώ, στείλτε με {{key}} - @ επιλέξτε διαδρομή, / επιλέξτε εντολή"
@ -3218,9 +3222,6 @@
        },
        "content": "Εξαγωγή μέρους των δεδομένων, συμπεριλαμβανομένων των ιστορικών συνομιλιών και των ρυθμίσεων. Σημειώστε ότι η διαδικασία δημιουργίας αντιγράφων ασφαλείας ενδέχεται να διαρκέσει κάποιο χρονικό διάστημα, ευχαριστούμε για την υπομονή σας.",
        "lan": {
-          "auto_close_tip": "Αυτόματο κλείσιμο σε {{seconds}} δευτερόλεπτα...",
-          "confirm_close_message": "Η μεταφορά αρχείων είναι σε εξέλιξη. Το κλείσιμο θα διακόψει τη μεταφορά. Είστε σίγουροι ότι θέλετε να κλείσετε βίαια;",
-          "confirm_close_title": "Επιβεβαίωση Κλεισίματος",
          "connected": "Συνδεδεμένος",
          "connection_failed": "Η σύνδεση απέτυχε",
          "content": "Βεβαιωθείτε ότι ο υπολογιστής και το κινητό βρίσκονται στο ίδιο δίκτυο για να χρησιμοποιήσετε τη μεταφορά LAN. Ανοίξτε την εφαρμογή Cherry Studio και σαρώστε αυτόν τον κωδικό QR.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Κλείσιμο με βία",
-          "generating_qr": "Δημιουργία κώδικα QR...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "Δεν επιλέχθηκε συμπιεσμένο αρχείο",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Παρακαλώ σαρώστε τον κωδικό QR με το τηλέφωνό σας",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Επιλέξτε συμπιεσμένο αρχείο",
-          "sendZip": "Έναρξη ανάκτησης δεδομένων",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Η μεταφορά ολοκληρώθηκε",
@ -3272,8 +3267,7 @@
            "error": "Σφάλμα σύνδεσης",
            "initializing": "Αρχικοποίηση σύνδεσης...",
            "preparing": "Προετοιμασία μεταφοράς...",
-            "sending": "Μεταφορά {{progress}}%",
-            "waiting_qr_scan": "Παρακαλώ σαρώστε τον κωδικό QR για σύνδεση"
+            "sending": "Μεταφορά {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/es-es.json
+++ b/src/renderer/src/i18n/translate/es-es.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Usando Git Bash detectado automáticamente",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Borrar ruta personalizada"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Se requiere Git Bash para ejecutar agentes en Windows. El agente no puede funcionar sin él. Instale Git para Windows desde",
        "recheck": "Volver a verificar la instalación de Git Bash",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Git Bash Requerido"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "El archivo seleccionado no es un ejecutable válido de Git Bash (bash.exe).",
        "title": "Seleccionar ejecutable de Git Bash"
      },
-      "success": "¡Git Bash detectado con éxito!"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "¡Git Bash detectado con éxito!",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Introduce tu mensaje aquí, envía con {{key}} - @ seleccionar ruta, / seleccionar comando"
@ -3218,9 +3222,6 @@
        },
        "content": "Exportar parte de los datos, incluidos los registros de chat y la configuración. Tenga en cuenta que el proceso de copia de seguridad puede tardar un tiempo; gracias por su paciencia.",
        "lan": {
-          "auto_close_tip": "Cierre automático en {{seconds}} segundos...",
-          "confirm_close_message": "La transferencia de archivos está en progreso. Cerrar interrumpirá la transferencia. ¿Estás seguro de que quieres forzar el cierre?",
-          "confirm_close_title": "Confirmar Cierre",
          "connected": "Conectado",
          "connection_failed": "Conexión fallida",
          "content": "Asegúrate de que el ordenador y el móvil estén en la misma red para usar la transferencia por LAN. Abre la aplicación Cherry Studio y escanea este código QR.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Cerrar forzosamente",
-          "generating_qr": "Generando código QR...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "No se ha seleccionado ningún archivo comprimido",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Por favor, escanea el código QR con tu teléfono",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Seleccionar archivo comprimido",
-          "sendZip": "Comenzar la recuperación de datos",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Transferencia completada",
@ -3272,8 +3267,7 @@
            "error": "Error de conexión",
            "initializing": "Inicializando conexión...",
            "preparing": "Preparando transferencia...",
-            "sending": "Transfiriendo {{progress}}%",
-            "waiting_qr_scan": "Por favor, escanea el código QR para conectarte"
+            "sending": "Transfiriendo {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/fr-fr.json
+++ b/src/renderer/src/i18n/translate/fr-fr.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Utilisation de Git Bash détecté automatiquement",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Effacer le chemin personnalisé"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Git Bash est requis pour exécuter des agents sur Windows. L'agent ne peut pas fonctionner sans. Veuillez installer Git pour Windows depuis",
        "recheck": "Revérifier l'installation de Git Bash",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Git Bash requis"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "Le fichier sélectionné n'est pas un exécutable Git Bash valide (bash.exe).",
        "title": "Sélectionner l'exécutable Git Bash"
      },
-      "success": "Git Bash détecté avec succès !"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Git Bash détecté avec succès !",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Entrez votre message ici, envoyez avec {{key}} - @ sélectionner le chemin, / sélectionner la commande"
@ -3218,9 +3222,6 @@
        },
        "content": "Exporter une partie des données, incluant les historiques de discussion et les paramètres. Veuillez noter que le processus de sauvegarde peut prendre un certain temps ; merci pour votre patience.",
        "lan": {
-          "auto_close_tip": "Fermeture automatique dans {{seconds}} secondes...",
-          "confirm_close_message": "Le transfert de fichier est en cours. Fermer interrompra le transfert. Êtes-vous sûr de vouloir forcer la fermeture ?",
-          "confirm_close_title": "Confirmer la fermeture",
          "connected": "Connecté",
          "connection_failed": "Échec de la connexion",
          "content": "Assurez-vous que l'ordinateur et le téléphone sont connectés au même réseau pour utiliser le transfert en réseau local. Ouvrez l'application Cherry Studio et scannez ce code QR.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Fermer de force",
-          "generating_qr": "Génération du code QR...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "Aucun fichier compressé sélectionné",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Veuillez scanner le code QR avec votre téléphone",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Sélectionner le fichier compressé",
-          "sendZip": "Commencer la restauration des données",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Transfert terminé",
@ -3272,8 +3267,7 @@
            "error": "Erreur de connexion",
            "initializing": "Initialisation de la connexion...",
            "preparing": "Préparation du transfert...",
-            "sending": "Transfert {{progress}} %",
-            "waiting_qr_scan": "Veuillez scanner le code QR pour vous connecter"
+            "sending": "Transfert {{progress}} %"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/ja-jp.json
+++ b/src/renderer/src/i18n/translate/ja-jp.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "自動検出されたGit Bashを使用中",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "カスタムパスをクリア"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Windowsでエージェントを実行するにはGit Bashが必要です。これがないとエージェントは動作しません。以下からGit for Windowsをインストールしてください。",
        "recheck": "Git Bashのインストールを再確認してください",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Git Bashが必要です"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "選択されたファイルは有効なGit Bash実行ファイル（bash.exe）ではありません。",
        "title": "Git Bash実行ファイルを選択"
      },
-      "success": "Git Bashが正常に検出されました！"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Git Bashが正常に検出されました！",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "メッセージをここに入力し、{{key}}で送信 - @でパスを選択、/でコマンドを選択"
@ -3218,9 +3222,6 @@
        },
        "content": "一部のデータ、チャット履歴や設定をエクスポートします。バックアップには時間がかかる場合がありますので、しばらくお待ちください。",
        "lan": {
-          "auto_close_tip": "{{seconds}}秒後に自動的に閉じます...",
-          "confirm_close_message": "ファイル転送が進行中です。閉じると転送が中断されます。強制終了してもよろしいですか？",
-          "confirm_close_title": "閉じることを確認",
          "connected": "接続済み",
          "connection_failed": "接続に失敗しました",
          "content": "コンピューターとスマートフォンが同じネットワークに接続されていることを確認し、ローカルエリアネットワーク転送を使用してください。Cherry Studioアプリを開き、このQRコードをスキャンしてください。",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "強制終了",
-          "generating_qr": "QRコードを生成中...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "圧縮ファイルが選択されていません",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "携帯電話でQRコードをスキャンしてください",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "圧縮ファイルを選択",
-          "sendZip": "データの復元を開始します",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "転送完了",
@ -3272,8 +3267,7 @@
            "error": "接続エラー",
            "initializing": "接続を初期化中...",
            "preparing": "転送準備中...",
-            "sending": "転送中 {{progress}}%",
-            "waiting_qr_scan": "QRコードをスキャンして接続してください"
+            "sending": "転送中 {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/pt-pt.json
+++ b/src/renderer/src/i18n/translate/pt-pt.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Usando Git Bash detectado automaticamente",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Limpar caminho personalizado"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "O Git Bash é necessário para executar agentes no Windows. O agente não pode funcionar sem ele. Por favor, instale o Git para Windows a partir de",
        "recheck": "Reverificar a Instalação do Git Bash",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Git Bash Necessário"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "O arquivo selecionado não é um executável válido do Git Bash (bash.exe).",
        "title": "Selecionar executável do Git Bash"
      },
-      "success": "Git Bash detectado com sucesso!"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Git Bash detectado com sucesso!",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Digite sua mensagem aqui, envie com {{key}} - @ selecionar caminho, / selecionar comando"
@ -3218,9 +3222,6 @@
        },
        "content": "Exportar parte dos dados, incluindo registros de conversas e configurações. Observe que o processo de backup pode demorar um pouco; agradecemos sua paciência.",
        "lan": {
-          "auto_close_tip": "Fechando automaticamente em {{seconds}} segundos...",
-          "confirm_close_message": "Transferência de arquivo em andamento. Fechar irá interromper a transferência. Tem certeza de que deseja forçar o fechamento?",
-          "confirm_close_title": "Confirmar Fechamento",
          "connected": "Conectado",
          "connection_failed": "Falha na conexão",
          "content": "Certifique-se de que o computador e o telefone estejam na mesma rede para usar a transferência via LAN. Abra o aplicativo Cherry Studio e escaneie este código QR.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Forçar Fechamento",
-          "generating_qr": "Gerando código QR...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "Nenhum arquivo de compressão selecionado",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Por favor, escaneie o código QR com o seu telefone",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Selecionar arquivo compactado",
-          "sendZip": "Iniciar recuperação de dados",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Transferência concluída",
@ -3272,8 +3267,7 @@
            "error": "Erro de conexão",
            "initializing": "Inicializando conexão...",
            "preparing": "Preparando transferência...",
-            "sending": "Transferindo {{progress}}%",
-            "waiting_qr_scan": "Por favor, escaneie o código QR para conectar"
+            "sending": "Transferindo {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/i18n/translate/ru-ru.json
+++ b/src/renderer/src/i18n/translate/ru-ru.json
@ -32,6 +32,7 @@
    },
    "gitBash": {
      "autoDetected": "Используется автоматически обнаруженный Git Bash",
+      "autoDiscoveredHint": "[to be translated]:Auto-discovered",
      "clear": {
        "button": "Очистить пользовательский путь"
      },
@ -39,6 +40,7 @@
      "error": {
        "description": "Для запуска агентов в Windows требуется Git Bash. Без него агент не может работать. Пожалуйста, установите Git для Windows с",
        "recheck": "Повторная проверка установки Git Bash",
+        "required": "[to be translated]:Git Bash path is required on Windows",
        "title": "Требуется Git Bash"
      },
      "found": {
@ -51,7 +53,9 @@
        "invalidPath": "Выбранный файл не является допустимым исполняемым файлом Git Bash (bash.exe).",
        "title": "Выберите исполняемый файл Git Bash"
      },
-      "success": "Git Bash успешно обнаружен!"
+      "placeholder": "[to be translated]:Select bash.exe path",
+      "success": "Git Bash успешно обнаружен!",
+      "tooltip": "[to be translated]:Git Bash is required to run agents on Windows. Install from git-scm.com if not available."
    },
    "input": {
      "placeholder": "Введите ваше сообщение здесь, отправьте с помощью {{key}} — @ выбрать путь, / выбрать команду"
@ -3218,9 +3222,6 @@
        },
        "content": "Экспорт части данных, включая историю чатов и настройки. Обратите внимание, процесс резервного копирования может занять некоторое время, благодарим за ваше терпение.",
        "lan": {
-          "auto_close_tip": "Автоматическое закрытие через {{seconds}} секунд...",
-          "confirm_close_message": "Передача файла в процессе. Закрытие прервет передачу. Вы уверены, что хотите принудительно закрыть?",
-          "confirm_close_title": "Подтвердить закрытие",
          "connected": "Подключено",
          "connection_failed": "Соединение не удалось",
          "content": "Убедитесь, что компьютер и телефон подключены к одной сети, чтобы использовать локальную передачу. Откройте приложение Cherry Studio и отсканируйте этот QR-код.",
@ -3241,8 +3242,6 @@
            "progress": "[to be translated]:Sending... {{progress}}%",
            "success": "[to be translated]:File sent successfully"
          },
-          "force_close": "Принудительное закрытие",
-          "generating_qr": "Генерация QR-кода...",
          "handshake": {
            "button": "[to be translated]:Handshake",
            "failed": "[to be translated]:Handshake failed: {{message}}",
@ -3255,14 +3254,10 @@
          "ip_addresses": "[to be translated]:IP addresses",
          "last_seen": "[to be translated]:Last seen at {{time}}",
          "metadata": "[to be translated]:Metadata",
-          "noZipSelected": "Архив не выбран",
          "no_connection_warning": "[to be translated]:Please open LAN Transfer on Cherry Studio mobile",
          "no_devices": "[to be translated]:No LAN peers found yet",
          "scan_devices": "[to be translated]:Scan devices",
-          "scan_qr": "Пожалуйста, отсканируйте QR-код с помощью вашего телефона",
          "scanning_hint": "[to be translated]:Scanning your local network for Cherry Studio peers...",
-          "selectZip": "Выберите архив",
-          "sendZip": "Начать восстановление данных",
          "send_file": "[to be translated]:Send File",
          "status": {
            "completed": "Перевод завершён",
@ -3272,8 +3267,7 @@
            "error": "Ошибка подключения",
            "initializing": "Инициализация соединения...",
            "preparing": "Подготовка передачи...",
-            "sending": "Передача {{progress}}%",
-            "waiting_qr_scan": "Пожалуйста, отсканируйте QR-код для подключения"
+            "sending": "Передача {{progress}}%"
          },
          "status_badge_idle": "[to be translated]:Idle",
          "status_badge_scanning": "[to be translated]:Scanning",
--- a/src/renderer/src/pages/settings/MCPSettings/BuiltinMCPServerList.tsx
+++ b/src/renderer/src/pages/settings/MCPSettings/BuiltinMCPServerList.tsx
@ -61,9 +61,14 @@ const BuiltinMCPServerList: FC = () => {
                  {getMcpTypeLabel(server.type ?? 'stdio')}
                </Tag>
                {server?.shouldConfig && (
-                  <Tag color="warning" style={{ borderRadius: 20, margin: 0, fontWeight: 500 }}>
-                    {t('settings.mcp.requiresConfig')}
-                  </Tag>
+                  <a
+                    href="https://docs.cherry-ai.com/advanced-basic/mcp/buildin"
+                    target="_blank"
+                    rel="noopener noreferrer">
+                    <Tag color="warning" style={{ borderRadius: 20, margin: 0, fontWeight: 500 }}>
+                      {t('settings.mcp.requiresConfig')}
+                    </Tag>
+                  </a>
                )}
              </ServerFooter>
            </ServerCard>
--- a/src/renderer/src/services/ApiService.ts
+++ b/src/renderer/src/services/ApiService.ts
@ -34,6 +34,10 @@ import {
  getProviderByModel,
  getQuickModel
 } from './AssistantService'
+import { ConversationService } from './ConversationService'
+import { injectUserMessageWithKnowledgeSearchPrompt } from './KnowledgeService'
+import type { BlockManager } from './messageStreaming'
+import type { StreamProcessorCallbacks } from './StreamProcessingService'
 // import { processKnowledgeSearch } from './KnowledgeService'
 // import {
 //   filterContextMessages,
@ -79,6 +83,59 @@ export async function fetchMcpTools(assistant: Assistant) {
  return mcpTools
 }

+/**
+ * 将用户消息转换为LLM可以理解的格式并发送请求
+ * @param request - 包含消息内容和助手信息的请求对象
+ * @param onChunkReceived - 接收流式响应数据的回调函数
+ */
+// 目前先按照函数来写,后续如果有需要到class的地方就改回来
+export async function transformMessagesAndFetch(
+  request: {
+    messages: Message[]
+    assistant: Assistant
+    blockManager: BlockManager
+    assistantMsgId: string
+    callbacks: StreamProcessorCallbacks
+    topicId?: string // 添加 topicId 用于 trace
+    options: {
+      signal?: AbortSignal
+      timeout?: number
+      headers?: Record<string, string>
+    }
+  },
+  onChunkReceived: (chunk: Chunk) => void
+) {
+  const { messages, assistant } = request
+
+  try {
+    const { modelMessages, uiMessages } = await ConversationService.prepareMessagesForModel(messages, assistant)
+
+    // replace prompt variables
+    assistant.prompt = await replacePromptVariables(assistant.prompt, assistant.model?.name)
+
+    // inject knowledge search prompt into model messages
+    await injectUserMessageWithKnowledgeSearchPrompt({
+      modelMessages,
+      assistant,
+      assistantMsgId: request.assistantMsgId,
+      topicId: request.topicId,
+      blockManager: request.blockManager,
+      setCitationBlockId: request.callbacks.setCitationBlockId!
+    })
+
+    await fetchChatCompletion({
+      messages: modelMessages,
+      assistant: assistant,
+      topicId: request.topicId,
+      requestOptions: request.options,
+      uiMessages,
+      onChunkReceived
+    })
+  } catch (error: any) {
+    onChunkReceived({ type: ChunkType.ERROR, error })
+  }
+}
+
 export async function fetchChatCompletion({
  messages,
  prompt,
--- a/src/renderer/src/services/KnowledgeService.ts
+++ b/src/renderer/src/services/KnowledgeService.ts
@ -2,10 +2,13 @@ import { loggerService } from '@logger'
 import type { Span } from '@opentelemetry/api'
 import { ModernAiProvider } from '@renderer/aiCore'
 import AiProvider from '@renderer/aiCore/legacy'
+import { getMessageContent } from '@renderer/aiCore/plugins/searchOrchestrationPlugin'
 import { DEFAULT_KNOWLEDGE_DOCUMENT_COUNT, DEFAULT_KNOWLEDGE_THRESHOLD } from '@renderer/config/constant'
 import { getEmbeddingMaxContext } from '@renderer/config/embedings'
+import { REFERENCE_PROMPT } from '@renderer/config/prompts'
 import { addSpan, endSpan } from '@renderer/services/SpanManagerService'
 import store from '@renderer/store'
+import type { Assistant } from '@renderer/types'
 import {
  type FileMetadata,
  type KnowledgeBase,
@ -16,13 +19,17 @@ import {
 } from '@renderer/types'
 import type { Chunk } from '@renderer/types/chunk'
 import { ChunkType } from '@renderer/types/chunk'
+import { MessageBlockStatus, MessageBlockType } from '@renderer/types/newMessage'
 import { routeToEndpoint } from '@renderer/utils'
 import type { ExtractResults } from '@renderer/utils/extract'
+import { createCitationBlock } from '@renderer/utils/messageUtils/create'
 import { isAzureOpenAIProvider, isGeminiProvider } from '@renderer/utils/provider'
+import type { ModelMessage, UserModelMessage } from 'ai'
 import { isEmpty } from 'lodash'

 import { getProviderByModel } from './AssistantService'
 import FileManager from './FileManager'
+import type { BlockManager } from './messageStreaming'

 const logger = loggerService.withContext('RendererKnowledgeService')

@ -338,3 +345,128 @@ export function processKnowledgeReferences(
    }
  }
 }
+
+export const injectUserMessageWithKnowledgeSearchPrompt = async ({
+  modelMessages,
+  assistant,
+  assistantMsgId,
+  topicId,
+  blockManager,
+  setCitationBlockId
+}: {
+  modelMessages: ModelMessage[]
+  assistant: Assistant
+  assistantMsgId: string
+  topicId?: string
+  blockManager: BlockManager
+  setCitationBlockId: (blockId: string) => void
+}) => {
+  if (assistant.knowledge_bases?.length && modelMessages.length > 0) {
+    const lastUserMessage = modelMessages[modelMessages.length - 1]
+    const isUserMessage = lastUserMessage.role === 'user'
+
+    if (!isUserMessage) {
+      return
+    }
+
+    const knowledgeReferences = await getKnowledgeReferences({
+      assistant,
+      lastUserMessage,
+      topicId: topicId
+    })
+
+    if (knowledgeReferences.length === 0) {
+      return
+    }
+
+    await createKnowledgeReferencesBlock({
+      assistantMsgId,
+      knowledgeReferences,
+      blockManager,
+      setCitationBlockId
+    })
+
+    const question = getMessageContent(lastUserMessage) || ''
+    const references = JSON.stringify(knowledgeReferences, null, 2)
+
+    const knowledgeSearchPrompt = REFERENCE_PROMPT.replace('{question}', question).replace('{references}', references)
+
+    if (typeof lastUserMessage.content === 'string') {
+      lastUserMessage.content = knowledgeSearchPrompt
+    } else if (Array.isArray(lastUserMessage.content)) {
+      const textPart = lastUserMessage.content.find((part) => part.type === 'text')
+      if (textPart) {
+        textPart.text = knowledgeSearchPrompt
+      } else {
+        lastUserMessage.content.push({
+          type: 'text',
+          text: knowledgeSearchPrompt
+        })
+      }
+    }
+  }
+}
+
+export const getKnowledgeReferences = async ({
+  assistant,
+  lastUserMessage,
+  topicId
+}: {
+  assistant: Assistant
+  lastUserMessage: UserModelMessage
+  topicId?: string
+}) => {
+  // 如果助手没有知识库，返回空字符串
+  if (!assistant || isEmpty(assistant.knowledge_bases)) {
+    return []
+  }
+
+  // 获取知识库ID
+  const knowledgeBaseIds = assistant.knowledge_bases?.map((base) => base.id)
+
+  // 获取用户消息内容
+  const question = getMessageContent(lastUserMessage) || ''
+
+  // 获取知识库引用
+  const knowledgeReferences = await processKnowledgeSearch(
+    {
+      knowledge: {
+        question: [question],
+        rewrite: ''
+      }
+    },
+    knowledgeBaseIds,
+    topicId!
+  )
+
+  // 返回提示词
+  return knowledgeReferences
+}
+
+export const createKnowledgeReferencesBlock = async ({
+  assistantMsgId,
+  knowledgeReferences,
+  blockManager,
+  setCitationBlockId
+}: {
+  assistantMsgId: string
+  knowledgeReferences: KnowledgeReference[]
+  blockManager: BlockManager
+  setCitationBlockId: (blockId: string) => void
+}) => {
+  // 创建引用块
+  const citationBlock = createCitationBlock(
+    assistantMsgId,
+    { knowledge: knowledgeReferences },
+    { status: MessageBlockStatus.SUCCESS }
+  )
+
+  // 处理引用块
+  blockManager.handleBlockTransition(citationBlock, MessageBlockType.CITATION)
+
+  // 设置引用块ID
+  setCitationBlockId(citationBlock.id)
+
+  // 返回引用块
+  return citationBlock
+}
--- a/src/renderer/src/services/OrchestrateService.ts
+++ b/src/renderer/src/services/OrchestrateService.ts
@ -1,91 +0,0 @@
-import type { Assistant, Message } from '@renderer/types'
-import type { Chunk } from '@renderer/types/chunk'
-import { ChunkType } from '@renderer/types/chunk'
-import { replacePromptVariables } from '@renderer/utils/prompt'
-
-import { fetchChatCompletion } from './ApiService'
-import { ConversationService } from './ConversationService'
-
-/**
- * The request object for handling a user message.
- */
-export interface OrchestrationRequest {
-  messages: Message[]
-  assistant: Assistant
-  options: {
-    signal?: AbortSignal
-    timeout?: number
-    headers?: Record<string, string>
-  }
-  topicId?: string // 添加 topicId 用于 trace
-}
-
-/**
- * The OrchestrationService is responsible for orchestrating the different services
- * to handle a user's message. It contains the core logic of the application.
- */
-// NOTE：暂时没有用到这个类
-export class OrchestrationService {
-  constructor() {
-    // In the future, this could be a singleton, but for now, a new instance is fine.
-    // this.conversationService = new ConversationService()
-  }
-
-  /**
-   * This is the core method to handle user messages.
-   * It takes the message context and an events object for callbacks,
-   * and orchestrates the call to the LLM.
-   * The logic is moved from `messageThunk.ts`.
-   * @param request The orchestration request containing messages and assistant info.
-   * @param events A set of callbacks to report progress and results to the UI layer.
-   */
-  async transformMessagesAndFetch(request: OrchestrationRequest, onChunkReceived: (chunk: Chunk) => void) {
-    const { messages, assistant } = request
-
-    try {
-      const { modelMessages, uiMessages } = await ConversationService.prepareMessagesForModel(messages, assistant)
-
-      await fetchChatCompletion({
-        messages: modelMessages,
-        assistant: assistant,
-        requestOptions: request.options,
-        onChunkReceived,
-        topicId: request.topicId,
-        uiMessages: uiMessages
-      })
-    } catch (error: any) {
-      onChunkReceived({ type: ChunkType.ERROR, error })
-    }
-  }
-}
-
-/**
- * 将用户消息转换为LLM可以理解的格式并发送请求
- * @param request - 包含消息内容和助手信息的请求对象
- * @param onChunkReceived - 接收流式响应数据的回调函数
- */
-// 目前先按照函数来写,后续如果有需要到class的地方就改回来
-export async function transformMessagesAndFetch(
-  request: OrchestrationRequest,
-  onChunkReceived: (chunk: Chunk) => void
-) {
-  const { messages, assistant } = request
-
-  try {
-    const { modelMessages, uiMessages } = await ConversationService.prepareMessagesForModel(messages, assistant)
-
-    // replace prompt variables
-    assistant.prompt = await replacePromptVariables(assistant.prompt, assistant.model?.name)
-
-    await fetchChatCompletion({
-      messages: modelMessages,
-      assistant: assistant,
-      requestOptions: request.options,
-      onChunkReceived,
-      topicId: request.topicId,
-      uiMessages
-    })
-  } catch (error: any) {
-    onChunkReceived({ type: ChunkType.ERROR, error })
-  }
-}
--- a/src/renderer/src/services/StreamProcessingService.ts
+++ b/src/renderer/src/services/StreamProcessingService.ts
@ -34,6 +34,10 @@ export interface StreamProcessorCallbacks {
  onLLMWebSearchInProgress?: () => void
  // LLM Web search complete
  onLLMWebSearchComplete?: (llmWebSearchResult: WebSearchResponse) => void
+  // Get citation block ID
+  getCitationBlockId?: () => string | null
+  // Set citation block ID
+  setCitationBlockId?: (blockId: string) => void
  // Image generation chunk received
  onImageCreated?: () => void
  onImageDelta?: (imageData: GenerateImageResponse) => void
--- a/src/renderer/src/services/messageStreaming/callbacks/citationCallbacks.ts
+++ b/src/renderer/src/services/messageStreaming/callbacks/citationCallbacks.ts
@ -121,6 +121,11 @@ export const createCitationCallbacks = (deps: CitationCallbacksDependencies) =>
    },

    // 暴露给外部的方法，用于textCallbacks中获取citationBlockId
-    getCitationBlockId: () => citationBlockId
+    getCitationBlockId: () => citationBlockId,
+
+    // 暴露给外部的方法，用于 KnowledgeService 中设置 citationBlockId
+    setCitationBlockId: (blockId: string) => {
+      citationBlockId = blockId
+    }
  }
 }
--- a/src/renderer/src/store/thunk/messageThunk.ts
+++ b/src/renderer/src/store/thunk/messageThunk.ts
@ -2,12 +2,11 @@ import { loggerService } from '@logger'
 import { AiSdkToChunkAdapter } from '@renderer/aiCore/chunk/AiSdkToChunkAdapter'
 import { AgentApiClient } from '@renderer/api/agent'
 import db from '@renderer/databases'
-import { fetchMessagesSummary } from '@renderer/services/ApiService'
+import { fetchMessagesSummary, transformMessagesAndFetch } from '@renderer/services/ApiService'
 import { DbService } from '@renderer/services/db/DbService'
 import FileManager from '@renderer/services/FileManager'
 import { BlockManager } from '@renderer/services/messageStreaming/BlockManager'
 import { createCallbacks } from '@renderer/services/messageStreaming/callbacks'
-import { transformMessagesAndFetch } from '@renderer/services/OrchestrateService'
 import { endSpan } from '@renderer/services/SpanManagerService'
 import { createStreamProcessor, type StreamProcessorCallbacks } from '@renderer/services/StreamProcessingService'
 import store from '@renderer/store'
@ -814,6 +813,9 @@ const fetchAndProcessAssistantResponseImpl = async (
        messages: messagesForContext,
        assistant,
        topicId,
+        blockManager,
+        assistantMsgId,
+        callbacks,
        options: {
          signal: abortController.signal,
          timeout: 30000,
--- a/yarn.lock
+++ b/yarn.lock
@ -7250,13 +7250,6 @@ __metadata:
  languageName: node
  linkType: hard

-"@socket.io/component-emitter@npm:~3.1.0":
-  version: 3.1.2
-  resolution: "@socket.io/component-emitter@npm:3.1.2"
-  checksum: 10c0/c4242bad66f67e6f7b712733d25b43cbb9e19a595c8701c3ad99cbeb5901555f78b095e24852f862fffb43e96f1d8552e62def885ca82ae1bb05da3668fd87d7
-  languageName: node
-  linkType: hard
-
 "@standard-schema/spec@npm:^1.0.0":
  version: 1.0.0
  resolution: "@standard-schema/spec@npm:1.0.0"
@ -8274,7 +8267,7 @@ __metadata:
  languageName: node
  linkType: hard

-"@types/cors@npm:^2.8.12, @types/cors@npm:^2.8.19":
+"@types/cors@npm:^2.8.19":
  version: 2.8.19
  resolution: "@types/cors@npm:2.8.19"
  dependencies:
@ -8831,15 +8824,6 @@ __metadata:
  languageName: node
  linkType: hard

-"@types/node@npm:>=10.0.0":
-  version: 24.3.1
-  resolution: "@types/node@npm:24.3.1"
-  dependencies:
-    undici-types: "npm:~7.10.0"
-  checksum: 10c0/99b86fc32294fcd61136ca1f771026443a1e370e9f284f75e243b29299dd878e18c193deba1ce29a374932db4e30eb80826e1049b9aad02d36f5c30b94b6f928
-  languageName: node
-  linkType: hard
-
 "@types/node@npm:^18.11.18":
  version: 18.19.86
  resolution: "@types/node@npm:18.19.86"
@ -10286,7 +10270,6 @@ __metadata:
    pdf-lib: "npm:^1.17.1"
    pdf-parse: "npm:^1.1.1"
    proxy-agent: "npm:^6.5.0"
-    qrcode.react: "npm:^4.2.0"
    react: "npm:^19.2.0"
    react-dom: "npm:^19.2.0"
    react-error-boundary: "npm:^6.0.0"
@ -10318,7 +10301,6 @@ __metadata:
    selection-hook: "npm:^1.0.12"
    sharp: "npm:^0.34.3"
    shiki: "npm:^3.12.0"
-    socket.io: "npm:^4.8.1"
    strict-url-sanitise: "npm:^0.0.1"
    string-width: "npm:^7.2.0"
    striptags: "npm:^3.2.0"
@ -10381,16 +10363,6 @@ __metadata:
  languageName: node
  linkType: hard

-"accepts@npm:~1.3.4":
-  version: 1.3.8
-  resolution: "accepts@npm:1.3.8"
-  dependencies:
-    mime-types: "npm:~2.1.34"
-    negotiator: "npm:0.6.3"
-  checksum: 10c0/3a35c5f5586cfb9a21163ca47a5f77ac34fa8ceb5d17d2fa2c0d81f41cbd7f8c6fa52c77e2c039acc0f4d09e71abdc51144246900f6bef5e3c4b333f77d89362
-  languageName: node
-  linkType: hard
-
 "acorn-jsx@npm:^5.3.2":
  version: 5.3.2
  resolution: "acorn-jsx@npm:5.3.2"
@ -11029,13 +11001,6 @@ __metadata:
  languageName: node
  linkType: hard

-"base64id@npm:2.0.0, base64id@npm:~2.0.0":
-  version: 2.0.0
-  resolution: "base64id@npm:2.0.0"
-  checksum: 10c0/6919efd237ed44b9988cbfc33eca6f173a10e810ce50292b271a1a421aac7748ef232a64d1e6032b08f19aae48dce6ee8f66c5ae2c9e5066c82b884861d4d453
-  languageName: node
-  linkType: hard
-
 "basic-ftp@npm:^5.0.2":
  version: 5.0.5
  resolution: "basic-ftp@npm:5.0.5"
@ -12272,7 +12237,7 @@ __metadata:
  languageName: node
  linkType: hard

-"cookie@npm:^0.7.1, cookie@npm:~0.7.2":
+"cookie@npm:^0.7.1":
  version: 0.7.2
  resolution: "cookie@npm:0.7.2"
  checksum: 10c0/9596e8ccdbf1a3a88ae02cf5ee80c1c50959423e1022e4e60b91dd87c622af1da309253d8abdb258fb5e3eacb4f08e579dc58b4897b8087574eee0fd35dfa5d2
@ -12309,7 +12274,7 @@ __metadata:
  languageName: node
  linkType: hard

-"cors@npm:^2.8.5, cors@npm:~2.8.5":
+"cors@npm:^2.8.5":
  version: 2.8.5
  resolution: "cors@npm:2.8.5"
  dependencies:
@ -12979,18 +12944,6 @@ __metadata:
  languageName: node
  linkType: hard

-"debug@npm:~4.3.1, debug@npm:~4.3.2, debug@npm:~4.3.4":
-  version: 4.3.7
-  resolution: "debug@npm:4.3.7"
-  dependencies:
-    ms: "npm:^2.1.3"
-  peerDependenciesMeta:
-    supports-color:
-      optional: true
-  checksum: 10c0/1471db19c3b06d485a622d62f65947a19a23fbd0dd73f7fd3eafb697eec5360cde447fb075919987899b1a2096e85d35d4eb5a4de09a57600ac9cf7e6c8e768b
-  languageName: node
-  linkType: hard
-
 "decamelize@npm:1.2.0":
  version: 1.2.0
  resolution: "decamelize@npm:1.2.0"
@ -13956,30 +13909,6 @@ __metadata:
  languageName: node
  linkType: hard

-"engine.io-parser@npm:~5.2.1":
-  version: 5.2.3
-  resolution: "engine.io-parser@npm:5.2.3"
-  checksum: 10c0/ed4900d8dbef470ab3839ccf3bfa79ee518ea8277c7f1f2759e8c22a48f64e687ea5e474291394d0c94f84054749fd93f3ef0acb51fa2f5f234cc9d9d8e7c536
-  languageName: node
-  linkType: hard
-
-"engine.io@npm:~6.6.0":
-  version: 6.6.4
-  resolution: "engine.io@npm:6.6.4"
-  dependencies:
-    "@types/cors": "npm:^2.8.12"
-    "@types/node": "npm:>=10.0.0"
-    accepts: "npm:~1.3.4"
-    base64id: "npm:2.0.0"
-    cookie: "npm:~0.7.2"
-    cors: "npm:~2.8.5"
-    debug: "npm:~4.3.1"
-    engine.io-parser: "npm:~5.2.1"
-    ws: "npm:~8.17.1"
-  checksum: 10c0/845761163f8ea7962c049df653b75dafb6b3693ad6f59809d4474751d7b0392cbf3dc2730b8a902ff93677a91fd28711d34ab29efd348a8a4b49c6b0724021ab
-  languageName: node
-  linkType: hard
-
 "enhanced-resolve@npm:^5.18.3":
  version: 5.18.3
  resolution: "enhanced-resolve@npm:5.18.3"
@ -19158,7 +19087,7 @@ __metadata:
  languageName: node
  linkType: hard

-"mime-types@npm:^2.1.12, mime-types@npm:^2.1.35, mime-types@npm:~2.1.34":
+"mime-types@npm:^2.1.12, mime-types@npm:^2.1.35":
  version: 2.1.35
  resolution: "mime-types@npm:2.1.35"
  dependencies:
@ -19657,13 +19586,6 @@ __metadata:
  languageName: node
  linkType: hard

-"negotiator@npm:0.6.3":
-  version: 0.6.3
-  resolution: "negotiator@npm:0.6.3"
-  checksum: 10c0/3ec9fd413e7bf071c937ae60d572bc67155262068ed522cf4b3be5edbe6ddf67d095ec03a3a14ebf8fc8e95f8e1d61be4869db0dbb0de696f6b837358bd43fc2
-  languageName: node
-  linkType: hard
-
 "negotiator@npm:^1.0.0":
  version: 1.0.0
  resolution: "negotiator@npm:1.0.0"
@ -21353,15 +21275,6 @@ __metadata:
  languageName: node
  linkType: hard

-"qrcode.react@npm:^4.2.0":
-  version: 4.2.0
-  resolution: "qrcode.react@npm:4.2.0"
-  peerDependencies:
-    react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
-  checksum: 10c0/68c691d130e5fda2f57cee505ed7aea840e7d02033100687b764601f9595e1116e34c13876628a93e1a5c2b85e4efc27d30b2fda72e2050c02f3e1c4e998d248
-  languageName: node
-  linkType: hard
-
 "qs@npm:^6.14.0":
  version: 6.14.0
  resolution: "qs@npm:6.14.0"
@ -23638,41 +23551,6 @@ __metadata:
  languageName: node
  linkType: hard

-"socket.io-adapter@npm:~2.5.2":
-  version: 2.5.5
-  resolution: "socket.io-adapter@npm:2.5.5"
-  dependencies:
-    debug: "npm:~4.3.4"
-    ws: "npm:~8.17.1"
-  checksum: 10c0/04a5a2a9c4399d1b6597c2afc4492ab1e73430cc124ab02b09e948eabf341180b3866e2b61b5084cb899beb68a4db7c328c29bda5efb9207671b5cb0bc6de44e
-  languageName: node
-  linkType: hard
-
-"socket.io-parser@npm:~4.2.4":
-  version: 4.2.4
-  resolution: "socket.io-parser@npm:4.2.4"
-  dependencies:
-    "@socket.io/component-emitter": "npm:~3.1.0"
-    debug: "npm:~4.3.1"
-  checksum: 10c0/9383b30358fde4a801ea4ec5e6860915c0389a091321f1c1f41506618b5cf7cd685d0a31c587467a0c4ee99ef98c2b99fb87911f9dfb329716c43b587f29ca48
-  languageName: node
-  linkType: hard
-
-"socket.io@npm:^4.8.1":
-  version: 4.8.1
-  resolution: "socket.io@npm:4.8.1"
-  dependencies:
-    accepts: "npm:~1.3.4"
-    base64id: "npm:~2.0.0"
-    cors: "npm:~2.8.5"
-    debug: "npm:~4.3.2"
-    engine.io: "npm:~6.6.0"
-    socket.io-adapter: "npm:~2.5.2"
-    socket.io-parser: "npm:~4.2.4"
-  checksum: 10c0/acf931a2bb235be96433b71da3d8addc63eeeaa8acabd33dc8d64e12287390a45f1e9f389a73cf7dc336961cd491679741b7a016048325c596835abbcc017ca9
-  languageName: node
-  linkType: hard
-
 "socks-proxy-agent@npm:^8.0.3, socks-proxy-agent@npm:^8.0.5":
  version: 8.0.5
  resolution: "socks-proxy-agent@npm:8.0.5"
@ -25169,13 +25047,6 @@ __metadata:
  languageName: node
  linkType: hard

-"undici-types@npm:~7.10.0":
-  version: 7.10.0
-  resolution: "undici-types@npm:7.10.0"
-  checksum: 10c0/8b00ce50e235fe3cc601307f148b5e8fb427092ee3b23e8118ec0a5d7f68eca8cee468c8fc9f15cbb2cf2a3797945ebceb1cbd9732306a1d00e0a9b6afa0f635
-  languageName: node
-  linkType: hard
-
 "undici@npm:6.21.2":
  version: 6.21.2
  resolution: "undici@npm:6.21.2"
@ -26203,21 +26074,6 @@ __metadata:
  languageName: node
  linkType: hard

-"ws@npm:~8.17.1":
-  version: 8.17.1
-  resolution: "ws@npm:8.17.1"
-  peerDependencies:
-    bufferutil: ^4.0.1
-    utf-8-validate: ">=5.0.2"
-  peerDependenciesMeta:
-    bufferutil:
-      optional: true
-    utf-8-validate:
-      optional: true
-  checksum: 10c0/f4a49064afae4500be772abdc2211c8518f39e1c959640457dcee15d4488628620625c783902a52af2dd02f68558da2868fd06e6fd0e67ebcd09e6881b1b5bfe
-  languageName: node
-  linkType: hard
-
 "xlsx@https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz":
  version: 0.20.2
  resolution: "xlsx@https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz"
Author	SHA1	Message	Date
eeee0717	f95b040b07	Merge branch 'main' into feat/bonjour	2025-12-18 12:33:20 +08:00
eeee0717	483dcb1dfc	fix: pr review	2025-12-18 11:32:13 +08:00
eeee0717	e711824701	chore: remove qrcode dependency	2025-12-18 10:48:32 +08:00
eeee0717	fc92f356ed	fix: pr review	2025-12-18 10:06:34 +08:00
beyondkmp	150bb3e3a0	fix: auto-discover and persist Git Bash path on Windows for scoop (#11921 ) * feat: auto-discover and persist Git Bash path on Windows - Add autoDiscoverGitBash function to find and cache Git Bash path when needed - Modify System_CheckGitBash IPC handler to auto-discover and persist path - Update Claude Code service with fallback auto-discovery mechanism - Git Bash path is now cached after first discovery, improving UX for Windows users * udpate * fix: remove redundant validation of auto-discovered Git Bash path The autoDiscoverGitBash function already returns a validated path, so calling validateGitBashPath again is unnecessary. Co-Authored-By: Claude <noreply@anthropic.com> * udpate * test: add unit tests for autoDiscoverGitBash function Add comprehensive test coverage for autoDiscoverGitBash including: - Discovery with no existing config path - Validation of existing config paths - Handling of invalid existing paths - Config persistence verification - Real-world scenarios (standard Git, portable Git, user-configured paths) Co-Authored-By: Claude <noreply@anthropic.com> * fix: remove unnecessary async keyword from System_CheckGitBash handler The handler doesn't use await since autoDiscoverGitBash is synchronous. Removes async for consistency with other IPC handlers. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * fix: rename misleading test to match actual behavior Renamed "should not call configManager.set multiple times on single discovery" to "should persist on each discovery when config remains undefined" to accurately describe that each call to autoDiscoverGitBash persists when the config mock returns undefined. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * refactor: use generic type parameter instead of type assertion Replace `as string \| undefined` with `get<string \| undefined>()` for better type safety when retrieving GitBashPath from config. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * refactor: simplify Git Bash path resolution in Claude Code service Remove redundant validateGitBashPath call since autoDiscoverGitBash already handles validation of configured paths before attempting discovery. Also remove unused ConfigKeys and configManager imports. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * fix: attempt auto-discovery when configured Git Bash path is invalid Previously, if a user had an invalid configured path (e.g., Git was moved or uninstalled), autoDiscoverGitBash would return null without attempting to find a valid installation. Now it logs a warning and attempts auto-discovery, providing a better user experience by automatically fixing invalid configurations. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * fix: ensure CLAUDE_CODE_GIT_BASH_PATH env var takes precedence over config Previously, if a valid config path existed, the environment variable CLAUDE_CODE_GIT_BASH_PATH was never checked. Now the precedence order is: 1. CLAUDE_CODE_GIT_BASH_PATH env var (highest - runtime override) 2. Configured path from settings 3. Auto-discovery via findGitBash This allows users to temporarily override the configured path without modifying their persistent settings. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * refactor: improve code quality and test robustness - Remove duplicate logging in Claude Code service (autoDiscoverGitBash logs internally) - Simplify Git Bash path initialization with ternary expression - Add afterEach cleanup to restore original env vars in tests - Extract mockExistingPaths helper to reduce test code duplication 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * feat: track Git Bash path source to distinguish manual vs auto-discovered - Add GitBashPathSource type and GitBashPathInfo interface to shared constants - Add GitBashPathSource config key to persist path origin ('manual' \| 'auto') - Update autoDiscoverGitBash to mark discovered paths as 'auto' - Update setGitBashPath IPC to mark user-set paths as 'manual' - Add getGitBashPathInfo API to retrieve path with source info - Update AgentModal UI to show different text based on source: - Manual: "Using custom path" with clear button - Auto: "Auto-discovered" without clear button 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * refactor: simplify Git Bash config UI as form field - Replace large Alert components with compact form field - Use static isWin constant instead of async platform detection - Show Git Bash field only on Windows with auto-fill support - Disable save button when Git Bash path is missing on Windows - Add "Auto-discovered" hint for auto-detected paths - Remove hasGitBash state, simplify checkGitBash logic 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * ui: add explicit select button for Git Bash path Replace click-on-input interaction with a dedicated "Select" button for clearer UX 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * refactor: simplify Git Bash UI by removing clear button - Remove handleClearGitBash function (no longer needed) - Remove clear button from UI (auto-discover fills value, user can re-select) - Remove auto-discovered hint (SourceHint) - Remove unused SourceHint styled component 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * feat: add reset button to restore auto-discovered Git Bash path - Add handleResetGitBash to clear manual setting and re-run auto-discovery - Show "Reset" button only when source is 'manual' - Show "Auto-discovered" hint when path was found automatically - User can re-select if auto-discovered path is not suitable 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * fix: re-run auto-discovery when resetting Git Bash path When setGitBashPath(null) is called (reset), now automatically re-runs autoDiscoverGitBash() to restore the auto-discovered path. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * feat(i18n): add Git Bash config translations Add translations for: - autoDiscoveredHint: hint text for auto-discovered paths - placeholder: input placeholder for bash.exe selection - tooltip: help tooltip text - error.required: validation error message Supported languages: en-US, zh-CN, zh-TW 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * update i18n * fix: auto-discover Git Bash when getting path info When getGitBashPathInfo() is called and no path is configured, automatically trigger autoDiscoverGitBash() first. This handles the upgrade scenario from old versions that don't have Git Bash path configured. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-12-18 09:57:23 +08:00
eeee0717	0dc9658846	fix: pr review	2025-12-18 09:48:52 +08:00
kangfenmao	739096deca	chore(release): v1.7.5 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2025-12-17 23:13:51 +08:00
LiuVaayne	1d5dafa325	refactor: rewrite filesystem MCP server with improved tool set (#11937 ) * refactor: rewrite filesystem MCP server with new tool set - Replace existing filesystem MCP with modular architecture - Implement 6 new tools: glob, ls, grep, read, write, delete - Add comprehensive TypeScript types and Zod schemas - Maintain security with path validation and allowed directories - Improve error handling and user feedback - Add result limits for performance (100 files/matches max) - Format output with clear, helpful messages - Keep backward compatibility with existing import patterns BREAKING CHANGE: Tools renamed from snake_case to lowercase - read_file → read - write_file → write - list_directory → ls - search_files → glob - New tools: grep, delete - Removed: edit_file, create_directory, directory_tree, move_file, get_file_info * 🐛 fix: remove filesystem allowed directories restriction * 🐛 fix: relax binary detection for text files * ✨ feat: add edit tool with fuzzy matching to filesystem MCP server - Add edit tool with 9 fallback replacers from opencode for robust string replacement (SimpleReplacer, LineTrimmedReplacer, BlockAnchorReplacer, WhitespaceNormalizedReplacer, etc.) - Add Levenshtein distance algorithm for similarity matching - Improve descriptions for all tools (read, write, glob, grep, ls, delete) following opencode patterns for better LLM guidance - Register edit tool in server and export from tools index * ♻️ refactor: replace allowedDirectories with baseDir in filesystem MCP server - Change server to use single baseDir (from WORKSPACE_ROOT env or userData/workspace default) - Remove list_allowed_directories tool as restriction mechanism is removed - Add ripgrep integration for faster grep searches with JS fallback - Simplify validatePath() by removing allowlist checks - Display paths relative to baseDir in tool outputs * 📝 docs: standardize filesystem MCP server tool descriptions - Unify description format to bullet-point style across all tools - Add absolute path requirement to ls, glob, grep schemas and descriptions - Update glob and grep to output absolute paths instead of relative paths - Add missing error case documentation for edit tool (old_string === new_string) - Standardize optional path parameter descriptions * ♻️ refactor: use ripgrep for glob tool and extract shared utilities - Extract shared ripgrep utilities (runRipgrep, getRipgrepAddonPath) to types.ts - Rewrite glob tool to use `rg --files --glob` for reliable file matching - Update grep tool to import shared ripgrep utilities * 🐛 fix: handle ripgrep exit code 2 with valid results in glob tool - Process ripgrep stdout when content exists, regardless of exit code - Exit code 2 can indicate partial errors while still returning valid results - Remove fallback directory listing (had buggy regex for root-level files) - Update tool description to clarify patterns without "/" match at any depth * 🔥 chore: remove filesystem.ts.backup file Remove unnecessary backup file from mcpServers directory * 🐛 fix: use correct default workspace path in filesystem MCP server Change default baseDir from userData/workspace to userData/Data/Workspace to match the app's data storage convention (Data/Files, Data/Notes, etc.) Addresses PR #11937 review feedback. * 🐛 fix: pass WORKSPACE_ROOT to FileSystemServer constructor The envs object passed to createInMemoryMCPServer was not being used for the filesystem server. Now WORKSPACE_ROOT is passed as a constructor parameter, following the same pattern as other MCP servers. * \feat: add link to documentation for MCP server configuration requirement Wrap the configuration requirement tag in a link to the documentation for better user guidance on MCP server settings. --------- Co-authored-by: kangfenmao <kangfenmao@qq.com>	2025-12-17 23:08:42 +08:00
Phantom	bdfda7afb1	fix: correct typo in Gemini 3 Pro Image Preview model name (#11969 )	2025-12-17 22:27:17 +08:00
kangfenmao	ef25eef0eb	feat(knowledge): use prompt injection for forced knowledge base search Change the default knowledge base retrieval behavior from tool call to prompt injection mode. This provides faster response times when knowledge base search is forced. Intent recognition mode (tool call) is still available as an opt-in option. - Remove toolChoiceMiddleware for forced knowledge base search - Add prompt injection for knowledge base references in KnowledgeService - Move transformMessagesAndFetch to ApiService, delete OrchestrateService - Export getMessageContent from searchOrchestrationPlugin - Add setCitationBlockId callback to citationCallbacks - Default knowledgeRecognition to 'off' (prompt mode) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2025-12-17 22:14:20 +08:00