computer_mcp 1.0.2 → 1.0.4

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "computer_mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "MCP Streamable HTTP Server with file and command execution tools",
   "main": "server.js",
   "type": "module",
   "bin": {
-    "computer-mcp": "./server.js"
+    "computer-mcp": "server.js"
   },
   "files": [
     "server.js",

package/server.js

@@ -9,24 +9,37 @@ import { registerFileTools } from './tools/file.js';
 import { registerInteractiveBashTool } from './tools/interactive.js';
 import { loadSkills, getSkillDetails } from './tools/skills.js';
 
-// 创建 MCP 服务器
-const server = new McpServer(
-    {
-        name: 'computer-mcp-server',
-        version: '1.0.0'
-    },
-    {
-        capabilities: {
-            logging: {},
-            tools: {}
+/** 全局兜底：未捕获的同步异常与未处理的 Promise 拒绝只打日志，不退出进程 */
+function installGlobalProcessErrorHandlers() {
+    process.on('uncaughtException', (err, origin) => {
+        console.error('[process] uncaughtException', origin || 'sync', err?.stack || String(err));
+    });
+    process.on('unhandledRejection', (reason) => {
+        const msg =
+            reason instanceof Error ? reason.stack || String(reason) : String(reason);
+        console.error('[process] unhandledRejection', msg);
+    });
+}
+installGlobalProcessErrorHandlers();
+
+/** 每个 Streamable HTTP 会话需要独立的 McpServer（协议层与 transport 一对一） */
+function createComputerMcpServer() {
+    const server = new McpServer(
+        {
+            name: 'computer-mcp-server',
+            version: '1.0.0'
+        },
+        {
+            capabilities: {
+                logging: {},
+                tools: {}
+            }
         }
-    }
-);
-
-// 注册工具
-registerInteractiveBashTool(server);
-// registerBashTool(server);
-registerFileTools(server);
+    );
+    registerInteractiveBashTool(server);
+    registerFileTools(server);
+    return server;
+}
 
 const app = express();
 
@@ -106,26 +119,40 @@ app.get('/skills/:name', async (req, res) => {
     }
 });
 
-// 管理传输层的 Map
-const transports = new Map();
+// sessionId -> { transport, mcpServer }
+const sessions = new Map();
 
 // MCP 端点处理
 app.all('/mcp', async (req, res) => {
     try {
-        // 重用现有传输层或创建新的
-        const sessionId = req.headers['mcp-session-id'];
-        let transport = sessionId ? transports.get(sessionId) : undefined;
+        const rawSessionId = req.headers['mcp-session-id'];
+        const sessionId = Array.isArray(rawSessionId)
+            ? rawSessionId[rawSessionId.length - 1]
+            : rawSessionId;
+
+        let entry = sessionId ? sessions.get(sessionId) : undefined;
+        let transport = entry?.transport;
+        let mcpServer = entry?.mcpServer;
 
         if (!transport) {
+            mcpServer = createComputerMcpServer();
             transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: () => randomUUID(),
                 retryInterval: 2000, // 默认重试间隔用于 priming events
                 onsessioninitialized: id => {
                     console.log(`[${id}] Session initialized`);
-                    transports.set(id, transport);
+                    sessions.set(id, { transport, mcpServer });
+                },
+                onsessionclosed: async id => {
+                    sessions.delete(id);
+                    try {
+                        await mcpServer.close();
+                    } catch (e) {
+                        console.error('Error closing MCP server:', e);
+                    }
                 }
             });
-            await server.connect(transport);
+            await mcpServer.connect(transport);
         }
 
         await transport.handleRequest(req, res, req.body);
@@ -160,6 +187,19 @@ app.listen(PORT, error => {
 // 处理服务器关闭
 process.on('SIGINT', async () => {
     console.log('Shutting down server...');
+    for (const [, { transport, mcpServer }] of sessions) {
+        try {
+            await mcpServer.close();
+        } catch (e) {
+            console.error(e);
+        }
+        try {
+            await transport.close();
+        } catch (e) {
+            console.error(e);
+        }
+    }
+    sessions.clear();
     process.exit(0);
 });
 

package/tools/file.js

@@ -1,188 +1,405 @@
-import fs from "fs/promises";
-import path from "path";
-import * as z from 'zod/v4';
-
-// 文件大小限制：100万字符
-const MAX_FILE_SIZE = 1000000;
-
-/**
- * 检查文件大小是否超过限制
- * @param {string} filePath - 文件路径
- * @param {string} encoding - 文件编码
- * @returns {Promise<{valid: boolean, size: number, message?: string}>}
- */
-async function checkFileSize(filePath, encoding = 'utf-8') {
-    try {
-        const stats = await fs.stat(filePath);
-        const sizeInBytes = stats.size;
-
-        // 粗略估算字符数（根据编码）
-        // UTF-8: 平均每个字符约1-3字节，这里使用保守估计
-        let estimatedChars;
-        if (encoding === 'utf-8') {
-            estimatedChars = sizeInBytes; // 最坏情况：每字节一个字符
-        } else if (encoding === 'utf16le') {
-            estimatedChars = sizeInBytes / 2;
-        } else {
-            estimatedChars = sizeInBytes;
-        }
-
-        if (estimatedChars > MAX_FILE_SIZE) {
-            return {
-                valid: false,
-                size: Math.round(estimatedChars),
-                message: `文件太大，不能处理。文件大小约为 ${Math.round(estimatedChars).toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`
-            };
-        }
-
-        return {
-            valid: true,
-            size: Math.round(estimatedChars)
-        };
-    } catch (error) {
-        throw new Error(`检查文件大小失败: ${error.message}`);
-    }
-}
-
-/**
- * 注册文件操作工具
- * @param {McpServer} server - MCP 服务器实例
- */
-export function registerFileTools(server) {
-    // 注册读取文件工具
-    server.tool(
-        'read_file',
-        '读取文本文件的内容',
-        {
-            path: z.string().describe('文件路径'),
-            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8')
-        },
-        async ({ path: filePath, encoding = 'utf-8' }) => {
-            try {
-                // 先检查文件大小
-                const sizeCheck = await checkFileSize(filePath, encoding);
-                if (!sizeCheck.valid) {
-                    throw new Error(sizeCheck.message);
-                }
-
-                const content = await fs.readFile(filePath, encoding);
-
-                // 再次检查实际字符数
-                if (content.length > MAX_FILE_SIZE) {
-                    throw new Error(`文件太大，不能处理。文件包含 ${content.length.toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`);
-                }
-
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: content,
-                        },
-                    ],
-                };
-            } catch (error) {
-                throw new Error(`读取文件失败: ${error.message}`);
-            }
-        }
-    );
-
-    // 注册写入文件工具
-    server.tool(
-        'write_file',
-        '写入内容到文本文件。如果文件已存在会被覆盖。',
-        {
-            path: z.string().describe('文件路径'),
-            content: z.string().describe('要写入的内容'),
-            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8'),
-            create_dirs: z.boolean().describe('如果目录不存在是否创建（可选，默认 false）').optional().default(false)
-        },
-        async ({ path: filePath, content, encoding = 'utf-8', create_dirs = false }) => {
-            try {
-                if (create_dirs) {
-                    const dir = path.dirname(filePath);
-                    await fs.mkdir(dir, { recursive: true });
-                }
-
-                await fs.writeFile(filePath, content, encoding);
-
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `文件写入成功: ${filePath}\n写入字节数: ${Buffer.byteLength(content, encoding)}`,
-                        },
-                    ],
-                };
-            } catch (error) {
-                throw new Error(`写入文件失败: ${error.message}`);
-            }
-        }
-    );
-
-    // 注册修改文件工具
-    server.tool(
-        'edit_file',
-        '修改文本文件的内容。可以进行搜索替换操作。',
-        {
-            path: z.string().describe('文件路径'),
-            search: z.string().describe('要搜索的文本（支持正则表达式）'),
-            replace: z.string().describe('替换后的文本'),
-            regex: z.boolean().describe('是否使用正则表达式（可选，默认 false）').optional().default(false),
-            all: z.boolean().describe('是否替换所有匹配项（可选，默认 true）').optional().default(true),
-            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8')
-        },
-        async ({ path: filePath, search, replace, regex = false, all = true, encoding = 'utf-8' }) => {
-            try {
-                // 先检查文件大小
-                const sizeCheck = await checkFileSize(filePath, encoding);
-                if (!sizeCheck.valid) {
-                    throw new Error(sizeCheck.message);
-                }
-
-                let content = await fs.readFile(filePath, encoding);
-
-                // 再次检查实际字符数
-                if (content.length > MAX_FILE_SIZE) {
-                    throw new Error(`文件太大，不能处理。文件包含 ${content.length.toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`);
-                }
-
-                let searchPattern;
-                if (regex) {
-                    searchPattern = new RegExp(search, all ? 'g' : '');
-                } else {
-                    const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                    searchPattern = new RegExp(escapedSearch, all ? 'g' : '');
-                }
-
-                const matches = content.match(searchPattern);
-                const matchCount = matches ? matches.length : 0;
-
-                if (matchCount === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `未找到匹配的内容: "${search}"`,
-                            },
-                        ],
-                    };
-                }
-
-                const newContent = content.replace(searchPattern, replace);
-                await fs.writeFile(filePath, newContent, encoding);
-
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `文件修改成功: ${filePath}\n替换次数: ${matchCount}`,
-                        },
-                    ],
-                };
-            } catch (error) {
-                throw new Error(`修改文件失败: ${error.message}`);
-            }
-        }
-    );
-}
-
+import fs from "fs/promises";
+import path from "path";
+import * as z from 'zod/v4';
+
+// 文件大小限制：100万字符
+const MAX_FILE_SIZE = 1000000;
+
+function parseUnifiedDiff(diffText) {
+    const normalized = diffText.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+
+    let idx = 0;
+    while (idx < lines.length && lines[idx].trim() === '') idx++;
+
+    if (idx >= lines.length || !lines[idx].startsWith('--- ')) {
+        throw new Error('无效的 unified diff：缺少 "--- " 头部');
+    }
+    const oldFileHeader = lines[idx].slice(4).trim();
+    idx++;
+
+    if (idx >= lines.length || !lines[idx].startsWith('+++ ')) {
+        throw new Error('无效的 unified diff：缺少 "+++ " 头部');
+    }
+    const newFileHeader = lines[idx].slice(4).trim();
+    idx++;
+
+    const hunks = [];
+    const hunkHeaderRegex = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: .*)?$/;
+
+    while (idx < lines.length) {
+        if (lines[idx].trim() === '') {
+            idx++;
+            continue;
+        }
+
+        const headerMatch = lines[idx].match(hunkHeaderRegex);
+        if (!headerMatch) {
+            throw new Error(`无效的 hunk 头: ${lines[idx]}`);
+        }
+
+        const oldStart = Number.parseInt(headerMatch[1], 10);
+        const oldCount = headerMatch[2] ? Number.parseInt(headerMatch[2], 10) : 1;
+        const newStart = Number.parseInt(headerMatch[3], 10);
+        const newCount = headerMatch[4] ? Number.parseInt(headerMatch[4], 10) : 1;
+        idx++;
+
+        const hunkLines = [];
+        while (idx < lines.length && !lines[idx].startsWith('@@ ')) {
+            if (lines[idx].startsWith('\')) {
+                idx++;
+                continue;
+            }
+            if (!/^[ +\-]/.test(lines[idx])) {
+                throw new Error(`无效的 hunk 行: ${lines[idx]}`);
+            }
+            hunkLines.push(lines[idx]);
+            idx++;
+        }
+
+        hunks.push({
+            oldStart,
+            oldCount,
+            newStart,
+            newCount,
+            lines: hunkLines
+        });
+    }
+
+    return { oldFileHeader, newFileHeader, hunks };
+}
+
+function extractOldSideLines(hunkLines) {
+    const oldSide = [];
+    for (const rawLine of hunkLines) {
+        const marker = rawLine[0];
+        if (marker === ' ' || marker === '-') {
+            oldSide.push(rawLine.slice(1));
+        }
+    }
+    return oldSide;
+}
+
+function canMatchOldSideAt(sourceLines, oldSideLines, startIndex) {
+    if (startIndex < 0 || startIndex + oldSideLines.length > sourceLines.length) {
+        return false;
+    }
+    for (let i = 0; i < oldSideLines.length; i++) {
+        if (sourceLines[startIndex + i] !== oldSideLines[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function findHunkStartIndex(sourceLines, sourceIndex, hunk, maxOffset) {
+    const expected = hunk.oldStart - 1;
+    const minIndex = Math.max(sourceIndex, expected - maxOffset);
+    const maxIndex = Math.min(sourceLines.length, expected + maxOffset);
+    const oldSideLines = extractOldSideLines(hunk.lines);
+
+    // 优先在期望行号附近查找，兼容少量偏移
+    for (let candidate = minIndex; candidate <= maxIndex; candidate++) {
+        if (canMatchOldSideAt(sourceLines, oldSideLines, candidate)) {
+            return candidate;
+        }
+    }
+
+    // 兜底：从当前处理位置向后全量搜索，尽量提高补丁命中率
+    for (let candidate = sourceIndex; candidate <= sourceLines.length - oldSideLines.length; candidate++) {
+        if (canMatchOldSideAt(sourceLines, oldSideLines, candidate)) {
+            return candidate;
+        }
+    }
+
+    return -1;
+}
+
+function applyUnifiedDiffToContent(content, diffText, options = {}) {
+    const strict = options.strict ?? false;
+    const maxOffset = options.maxOffset ?? 8;
+    const { hunks } = parseUnifiedDiff(diffText);
+    if (hunks.length === 0) {
+        throw new Error('无效的 unified diff：未包含任何 hunk');
+    }
+
+    const eol = content.includes('\r\n') ? '\r\n' : '\n';
+    const normalizedContent = content.replace(/\r\n/g, '\n');
+    const sourceLines = normalizedContent.split('\n');
+    const result = [];
+    let sourceIndex = 0;
+    let additions = 0;
+    let deletions = 0;
+
+    for (const hunk of hunks) {
+        let targetSourceIndex = hunk.oldStart - 1;
+        if (!strict) {
+            targetSourceIndex = findHunkStartIndex(sourceLines, sourceIndex, hunk, maxOffset);
+            if (targetSourceIndex < 0) {
+                throw new Error(`无法定位 hunk（起始行 ${hunk.oldStart}，允许偏移 ±${maxOffset}）`);
+            }
+        }
+
+        if (targetSourceIndex < sourceIndex) {
+            throw new Error('hunk 顺序错误或存在重叠');
+        }
+
+        while (sourceIndex < targetSourceIndex) {
+            result.push(sourceLines[sourceIndex]);
+            sourceIndex++;
+        }
+
+        let seenOld = 0;
+        let seenNew = 0;
+
+        for (const rawLine of hunk.lines) {
+            const marker = rawLine[0];
+            const lineText = rawLine.slice(1);
+
+            if (marker === ' ') {
+                if (sourceIndex >= sourceLines.length || sourceLines[sourceIndex] !== lineText) {
+                    throw new Error(`上下文不匹配，期望 "${lineText}"`);
+                }
+                result.push(sourceLines[sourceIndex]);
+                sourceIndex++;
+                seenOld++;
+                seenNew++;
+            } else if (marker === '-') {
+                if (sourceIndex >= sourceLines.length || sourceLines[sourceIndex] !== lineText) {
+                    throw new Error(`删除行不匹配，期望 "${lineText}"`);
+                }
+                sourceIndex++;
+                seenOld++;
+                deletions++;
+            } else if (marker === '+') {
+                result.push(lineText);
+                seenNew++;
+                additions++;
+            } else {
+                throw new Error(`不支持的 hunk 标记: ${marker}`);
+            }
+        }
+
+        if (seenOld !== hunk.oldCount) {
+            throw new Error(`hunk oldCount 不匹配：声明 ${hunk.oldCount}，实际 ${seenOld}`);
+        }
+        if (seenNew !== hunk.newCount) {
+            throw new Error(`hunk newCount 不匹配：声明 ${hunk.newCount}，实际 ${seenNew}`);
+        }
+    }
+
+    while (sourceIndex < sourceLines.length) {
+        result.push(sourceLines[sourceIndex]);
+        sourceIndex++;
+    }
+
+    return {
+        content: result.join(eol),
+        additions,
+        deletions,
+        hunkCount: hunks.length
+    };
+}
+
+/**
+ * 检查文件大小是否超过限制
+ * @param {string} filePath - 文件路径
+ * @param {string} encoding - 文件编码
+ * @returns {Promise<{valid: boolean, size: number, message?: string}>}
+ */
+async function checkFileSize(filePath, encoding = 'utf-8') {
+    try {
+        const stats = await fs.stat(filePath);
+        const sizeInBytes = stats.size;
+
+        // 粗略估算字符数（根据编码）
+        // UTF-8: 平均每个字符约1-3字节，这里使用保守估计
+        let estimatedChars;
+        if (encoding === 'utf-8') {
+            estimatedChars = sizeInBytes; // 最坏情况：每字节一个字符
+        } else if (encoding === 'utf16le') {
+            estimatedChars = sizeInBytes / 2;
+        } else {
+            estimatedChars = sizeInBytes;
+        }
+
+        if (estimatedChars > MAX_FILE_SIZE) {
+            return {
+                valid: false,
+                size: Math.round(estimatedChars),
+                message: `文件太大，不能处理。文件大小约为 ${Math.round(estimatedChars).toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`
+            };
+        }
+
+        return {
+            valid: true,
+            size: Math.round(estimatedChars)
+        };
+    } catch (error) {
+        throw new Error(`检查文件大小失败: ${error.message}`);
+    }
+}
+
+/**
+ * 注册文件操作工具
+ * @param {McpServer} server - MCP 服务器实例
+ */
+export function registerFileTools(server) {
+    // 注册读取文件工具
+    server.tool(
+        'read_file',
+        '读取文本文件的内容',
+        {
+            path: z.string().describe('文件路径'),
+            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8')
+        },
+        async ({ path: filePath, encoding = 'utf-8' }) => {
+            try {
+                // 先检查文件大小
+                const sizeCheck = await checkFileSize(filePath, encoding);
+                if (!sizeCheck.valid) {
+                    throw new Error(sizeCheck.message);
+                }
+
+                const content = await fs.readFile(filePath, encoding);
+
+                // 再次检查实际字符数
+                if (content.length > MAX_FILE_SIZE) {
+                    throw new Error(`文件太大，不能处理。文件包含 ${content.length.toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`);
+                }
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: content,
+                        },
+                    ],
+                };
+            } catch (error) {
+                throw new Error(`读取文件失败: ${error.message}`);
+            }
+        }
+    );
+
+    // 注册带行号读取工具
+    server.tool(
+        'read_file_numbered',
+        '读取文本文件内容，并在每行前加行号（格式：行号|内容）',
+        {
+            path: z.string().describe('文件路径'),
+            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8')
+        },
+        async ({ path: filePath, encoding = 'utf-8' }) => {
+            try {
+                const sizeCheck = await checkFileSize(filePath, encoding);
+                if (!sizeCheck.valid) {
+                    throw new Error(sizeCheck.message);
+                }
+
+                const content = await fs.readFile(filePath, encoding);
+                if (content.length > MAX_FILE_SIZE) {
+                    throw new Error(`文件太大，不能处理。文件包含 ${content.length.toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`);
+                }
+
+                const normalized = content.replace(/\r\n/g, '\n');
+                const lines = normalized.split('\n');
+                const width = String(lines.length).length;
+                const numbered = lines
+                    .map((line, index) => `${String(index + 1).padStart(width, '0')}|${line}`)
+                    .join('\n');
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: numbered,
+                        },
+                    ],
+                };
+            } catch (error) {
+                throw new Error(`读取文件失败: ${error.message}`);
+            }
+        }
+    );
+
+    // 注册写入文件工具
+    server.tool(
+        'write_file',
+        '写入内容到文本文件。如果文件已存在会被覆盖。',
+        {
+            path: z.string().describe('文件路径'),
+            content: z.string().describe('要写入的内容'),
+            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8'),
+            create_dirs: z.boolean().describe('如果目录不存在是否创建（可选，默认 false）').optional().default(false)
+        },
+        async ({ path: filePath, content, encoding = 'utf-8', create_dirs = false }) => {
+            try {
+                if (create_dirs) {
+                    const dir = path.dirname(filePath);
+                    await fs.mkdir(dir, { recursive: true });
+                }
+
+                await fs.writeFile(filePath, content, encoding);
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `文件写入成功: ${filePath}\n写入字节数: ${Buffer.byteLength(content, encoding)}`,
+                        },
+                    ],
+                };
+            } catch (error) {
+                throw new Error(`写入文件失败: ${error.message}`);
+            }
+        }
+    );
+
+    // 注册修改文件工具
+    server.tool(
+        'edit_file',
+        '使用标准 unified diff 格式修改文本文件内容。',
+        {
+            path: z.string().describe('文件路径'),
+            diff: z.string().describe('标准 unified diff 文本（需包含 --- / +++ / @@ hunk）'),
+            strict: z.boolean().describe('是否严格按 hunk 行号匹配（可选，默认 false）').optional().default(false),
+            max_offset: z.number().int().min(0).max(200).describe('宽松模式下允许的最大行号偏移（可选，默认 8）').optional().default(8),
+            encoding: z.enum(['utf-8', 'ascii', 'utf16le', 'latin1']).describe('文件编码（可选，默认 utf-8）').optional().default('utf-8')
+        },
+        async ({ path: filePath, diff, strict = false, max_offset = 8, encoding = 'utf-8' }) => {
+            try {
+                // 先检查文件大小
+                const sizeCheck = await checkFileSize(filePath, encoding);
+                if (!sizeCheck.valid) {
+                    throw new Error(sizeCheck.message);
+                }
+
+                const content = await fs.readFile(filePath, encoding);
+
+                // 再次检查实际字符数
+                if (content.length > MAX_FILE_SIZE) {
+                    throw new Error(`文件太大，不能处理。文件包含 ${content.length.toLocaleString()} 字符，超过了 ${MAX_FILE_SIZE.toLocaleString()} 字符的限制。`);
+                }
+
+                const patched = applyUnifiedDiffToContent(content, diff, {
+                    strict,
+                    maxOffset: max_offset
+                });
+                await fs.writeFile(filePath, patched.content, encoding);
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `文件修改成功: ${filePath}\n模式: ${strict ? '严格' : '宽松'}\n最大偏移: ${max_offset}\n应用 hunk 数: ${patched.hunkCount}\n新增行: ${patched.additions}\n删除行: ${patched.deletions}`,
+                        },
+                    ],
+                };
+            } catch (error) {
+                throw new Error(`修改文件失败: ${error.message}`);
+            }
+        }
+    );
+}
+