computer_mcp 1.0.1

package/README.md

@@ -0,0 +1,168 @@
+# Computer MCP Server
+
+一个基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的 Streamable HTTP 服务器，提供文件操作和命令执行功能。
+
+## 功能特性
+
+- ✅ **执行命令** - 运行系统命令并实时返回输出
+- ✅ **读取文件** - 读取文本文件内容
+- ✅ **写入文件** - 创建或覆盖文本文件
+- ✅ **修改文件** - 搜索替换文件内容（支持正则表达式）
+- ✅ **实时通知** - 命令执行过程中发送 MCP 通知消息
+- ✅ **Streamable HTTP** - 使用 HTTP 流式传输协议
+
+## 安装
+
+```bash
+npm install
+```
+
+## 启动服务器
+
+```bash
+# 生产模式
+npm start
+
+# 开发模式（自动重启）
+npm run dev
+```
+
+服务器默认运行在端口 `3000`，可以通过环境变量 `PORT` 修改：
+
+```bash
+PORT=8080 npm start
+```
+
+## 端点
+
+- **MCP 端点**: `POST http://localhost:3000/mcp`
+- **健康检查**: `GET http://localhost:3000/health`
+
+## 工具说明
+
+### 1. execute_command - 执行命令
+
+执行系统命令并返回结果。执行过程中会发送多条通知消息。
+
+**参数:**
+- `command` (必需): 要执行的命令
+- `args` (可选): 命令参数数组
+- `cwd` (可选): 工作目录
+- `timeout` (可选): 超时时间（毫秒，默认 30000）
+
+**示例:**
+```json
+{
+  "command": "ls",
+  "args": ["-la"],
+  "cwd": "/home/user"
+}
+```
+
+**返回:**
+```json
+{
+  "exitCode": 0,
+  "stdout": "...",
+  "stderr": "...",
+  "success": true
+}
+```
+
+### 2. read_file - 读取文件
+
+读取文本文件的内容。
+
+**参数:**
+- `path` (必需): 文件路径
+- `encoding` (可选): 文件编码（默认 utf-8）
+
+**示例:**
+```json
+{
+  "path": "/path/to/file.txt",
+  "encoding": "utf-8"
+}
+```
+
+### 3. write_file - 写入文件
+
+写入内容到文本文件，如果文件已存在会被覆盖。
+
+**参数:**
+- `path` (必需): 文件路径
+- `content` (必需): 要写入的内容
+- `encoding` (可选): 文件编码（默认 utf-8）
+- `create_dirs` (可选): 是否创建目录（默认 false）
+
+**示例:**
+```json
+{
+  "path": "/path/to/file.txt",
+  "content": "Hello, World!",
+  "create_dirs": true
+}
+```
+
+### 4. edit_file - 修改文件
+
+修改文本文件的内容，支持搜索替换。
+
+**参数:**
+- `path` (必需): 文件路径
+- `search` (必需): 要搜索的文本
+- `replace` (必需): 替换后的文本
+- `regex` (可选): 是否使用正则表达式（默认 false）
+- `all` (可选): 是否替换所有匹配项（默认 true）
+- `encoding` (可选): 文件编码（默认 utf-8）
+
+**示例:**
+```json
+{
+  "path": "/path/to/file.txt",
+  "search": "old text",
+  "replace": "new text",
+  "all": true
+}
+```
+
+## 通知消息
+
+在执行命令时，服务器会发送多条 MCP 通知消息：
+
+- **info**: 命令开始执行、执行完成
+- **debug**: 标准输出内容
+- **warning**: 标准错误输出、超时警告
+- **error**: 执行错误
+
+## Docker 部署
+
+```bash
+# 构建镜像
+./dockerBuild.sh
+
+# 运行容器
+docker run -d -p 3000:3000 computer-mcp-server
+```
+
+## 测试
+
+使用 `curl` 测试健康检查：
+
+```bash
+curl http://localhost:3000/health
+```
+
+测试 MCP 端点需要发送符合 MCP 协议的 JSON-RPC 请求。
+
+## 技术栈
+
+- Node.js
+- Express.js
+- @modelcontextprotocol/sdk
+- ES Modules
+
+## 许可证
+
+ISC
+

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "computer_mcp",
+  "version": "1.0.1",
+  "description": "MCP Streamable HTTP Server with file and command execution tools",
+  "main": "server.js",
+  "type": "module",
+  "bin": {
+    "computer-mcp": "./server.js"
+  },
+  "files": [
+    "server.js",
+    "tools"
+  ],
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js",
+    "test": "node test_mcp.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.1",
+    "cors": "^2.8.5",
+    "express": "^5.2.1"
+  }
+}

package/server.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/index.js";
+import express from "express";
+import { randomUUID } from 'node:crypto';
+import { registerBashTool } from './tools/bash.js';
+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: {}
+        }
+    }
+);
+
+// 注册工具
+registerInteractiveBashTool(server);
+// registerBashTool(server);
+registerFileTools(server);
+
+// // 创建 Express 应用
+// const app = createMcpExpressApp();
+const app = express();
+
+// 健康检查端点
+app.get('/health', (req, res) => {
+    res.json({
+        status: 'ok',
+        server: 'computer-mcp-server',
+        version: '1.0.0',
+    });
+});
+
+// 技能列表端点
+app.get('/skills', async (req, res) => {
+    try {
+        // 从 query 参数中获取 ids，支持 ?ids=id1,id2,id3 或 ?ids[]=id1&ids[]=id2
+        let ids = [];
+        if (req.query.ids) {
+            if (Array.isArray(req.query.ids)) {
+                ids = req.query.ids;
+            } else if (typeof req.query.ids === 'string') {
+                // 支持逗号分隔的 ID
+                ids = req.query.ids.split(',').map(id => id.trim()).filter(id => id);
+            }
+        }
+
+        const skills = await loadSkills(ids);
+        res.json({
+            success: true,
+            skills: skills
+        });
+    } catch (error) {
+        console.error('Error loading skills:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// 获取单个技能详情
+app.get('/skills/:name', async (req, res) => {
+    try {
+        const skillName = req.params.name;
+
+        // 从 query 参数中获取 ids
+        let ids = [];
+        if (req.query.ids) {
+            if (Array.isArray(req.query.ids)) {
+                ids = req.query.ids;
+            } else if (typeof req.query.ids === 'string') {
+                // 支持逗号分隔的 ID
+                ids = req.query.ids.split(',').map(id => id.trim()).filter(id => id);
+            }
+        }
+
+        const skill = await getSkillDetails(skillName, ids);
+
+        if (!skill) {
+            res.status(404).json({
+                success: false,
+                error: 'Skill not found'
+            });
+            return;
+        }
+
+        res.json({
+            success: true,
+            skill: skill
+        });
+    } catch (error) {
+        console.error('Error getting skill details:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// 管理传输层的 Map
+const transports = new Map();
+
+// MCP 端点处理
+app.all('/mcp', async (req, res) => {
+    try {
+        // 重用现有传输层或创建新的
+        const sessionId = req.headers['mcp-session-id'];
+        let transport = sessionId ? transports.get(sessionId) : undefined;
+
+        if (!transport) {
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                retryInterval: 2000, // 默认重试间隔用于 priming events
+                onsessioninitialized: id => {
+                    console.log(`[${id}] Session initialized`);
+                    transports.set(id, transport);
+                }
+            });
+            await server.connect(transport);
+        }
+
+        await transport.handleRequest(req, res, req.body);
+    } catch (error) {
+        console.error('Error handling MCP request:', error);
+        if (!res.headersSent) {
+            res.status(500).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32603,
+                    message: 'Internal server error'
+                },
+                id: null
+            });
+        }
+    }
+});
+
+// 启动服务器
+const PORT = process.env.PORT || 8000;
+app.listen(PORT, error => {
+    if (error) {
+        console.error('Failed to start server:', error);
+        process.exit(1);
+    }
+    console.log(`MCP Streamable HTTP 服务器运行在端口 ${PORT}`);
+    console.log(`端点: http://localhost:${PORT}/mcp`);
+    console.log(`健康检查: http://localhost:${PORT}/health`);
+    console.log(`技能列表: http://localhost:${PORT}/skills`);
+});
+
+// 处理服务器关闭
+process.on('SIGINT', async () => {
+    console.log('Shutting down server...');
+    process.exit(0);
+});
+

package/tools/bash.js

@@ -0,0 +1,147 @@
+import { spawn } from "child_process";
+import * as z from 'zod/v4';
+
+const MAX_OUTPUT_LINES = 100;
+const MAX_OUTPUT_CHARS = 5000;
+
+function trimCommandOutput(output) {
+    if (!output) {
+        return {
+            text: '',
+            truncated: false,
+            reasons: [],
+        };
+    }
+
+    const lines = output.split(/\r?\n/);
+    const lineTruncated = lines.length > MAX_OUTPUT_LINES;
+    const tailLines = lines.slice(-MAX_OUTPUT_LINES).join('\n');
+    const charTruncated = tailLines.length > MAX_OUTPUT_CHARS;
+
+    let text = tailLines;
+    if (charTruncated) {
+        text = tailLines.slice(-MAX_OUTPUT_CHARS);
+    }
+
+    const reasons = [];
+    if (lineTruncated) {
+        reasons.push(`已截断为最后 ${MAX_OUTPUT_LINES} 行`);
+    }
+    if (charTruncated) {
+        reasons.push(`已截断为最后 ${MAX_OUTPUT_CHARS} 字符`);
+    }
+
+    if (reasons.length > 0) {
+        const notice = `[输出已截断] ${reasons.join('，')}\n`;
+        text = `${notice}${text}`;
+    }
+
+    return {
+        text,
+        truncated: reasons.length > 0,
+        reasons,
+    };
+}
+
+/**
+ * 注册 bash 命令执行工具
+ * @param {McpServer} server - MCP 服务器实例
+ */
+export function registerBashTool(server) {
+    server.tool(
+        'bash',
+        '执行系统命令。可以运行任何 shell 命令并返回输出结果。',
+        {
+            command: z.string().describe('要执行的命令'),
+            args: z.array(z.string()).describe('命令参数（可选）').optional(),
+            cwd: z.string().describe('工作目录（可选）').optional()
+        },
+        async ({ command, args = [], cwd = process.cwd() }, extra) => {
+            // 发送通知的函数
+            const sendNotification = async (params) => {
+                try {
+                    await server.sendLoggingMessage(
+                        {
+                            level: params.level,
+                            logger: params.logger || 'bash',
+                            data: params.data,
+                        },
+                        extra.sessionId
+                    );
+                } catch (error) {
+                    console.error('Error sending notification:', error);
+                }
+            };
+
+            await sendNotification({
+                level: 'info',
+                data: `开始执行命令: ${command} ${args.join(' ')}`,
+            });
+
+            return new Promise((resolve, reject) => {
+                const child = spawn(command, args, {
+                    cwd,
+                    shell: true,
+                });
+
+                let stdout = '';
+                let stderr = '';
+
+                child.stdout.on('data', async (data) => {
+                    const output = data.toString();
+                    stdout += output;
+                    await sendNotification({
+                        level: 'debug',
+                        data: `[stdout] ${output.trim()}`,
+                    });
+                });
+
+                child.stderr.on('data', async (data) => {
+                    const output = data.toString();
+                    stderr += output;
+                    await sendNotification({
+                        level: 'warning',
+                        data: `[stderr] ${output.trim()}`,
+                    });
+                });
+
+                child.on('close', async (code) => {
+                    await sendNotification({
+                        level: code === 0 ? 'info' : 'error',
+                        data: `命令执行完成，退出码: ${code}`,
+                    });
+
+                    const trimmedStdout = trimCommandOutput(stdout);
+                    const trimmedStderr = trimCommandOutput(stderr);
+
+                    resolve({
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(
+                                    {
+                                        exitCode: code,
+                                        stdout: trimmedStdout.text,
+                                        stderr: trimmedStderr.text,
+                                        success: code === 0,
+                                    },
+                                    null,
+                                    2
+                                ),
+                            },
+                        ],
+                    });
+                });
+
+                child.on('error', async (error) => {
+                    await sendNotification({
+                        level: 'error',
+                        data: `命令执行错误: ${error.message}`,
+                    });
+                    reject(error);
+                });
+            });
+        }
+    );
+}
+

package/tools/file.js

@@ -0,0 +1,188 @@
+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}`);
+            }
+        }
+    );
+}
+

package/tools/interactive.js

@@ -0,0 +1,232 @@
+import { spawn } from "child_process";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomUUID } from "node:crypto";
+import { unlink, readFile, access, writeFile, chmod } from "fs/promises";
+import * as z from 'zod/v4';
+
+/**
+ * 注册交互式命令执行工具
+ * @param {McpServer} server - MCP 服务器实例
+ */
+export function registerInteractiveBashTool(server) {
+    server.tool(
+        'bash',
+        '执行交互式命令。使用 xfce4-terminal 启动 script 命令记录完整的交互式会话，包括用户输入和程序输出。会在图形界面中打开 xfce4-terminal 窗口供用户交互。适用于需要交互式输入的命令或脚本，当然也支持普通命令。',
+        {
+            script: z.string().describe('要执行的 shell 脚本内容或命令'),
+            cwd: z.string().describe('工作目录（可选）').optional()
+        },
+        async ({ script, cwd = process.cwd() }, extra) => {
+            // 发送通知的函数
+            const sendNotification = async (params) => {
+                try {
+                    await server.sendLoggingMessage(
+                        {
+                            level: params.level,
+                            logger: params.logger || 'interactive',
+                            data: params.data,
+                        },
+                        extra.sessionId
+                    );
+                } catch (error) {
+                    console.error('Error sending notification:', error);
+                }
+            };
+
+            // 创建临时文件
+            const scriptFile = join(tmpdir(), `script_${randomUUID()}.sh`);
+            const logFile = join(tmpdir(), `interactive_${randomUUID()}.log`);
+            const doneFlag = `${logFile}.done`;
+
+            try {
+                // 将脚本内容写入临时文件
+                await writeFile(scriptFile, script, 'utf-8');
+                // 设置脚本文件为可执行
+                await chmod(scriptFile, 0o755);
+            } catch (error) {
+                await sendNotification({
+                    level: 'error',
+                    data: `创建脚本文件失败: ${error.message}`,
+                });
+                throw error;
+            }
+
+            await sendNotification({
+                level: 'info',
+                data: `开始执行交互式命令\n脚本文件: ${scriptFile}\n日志文件: ${logFile}`,
+            });
+
+            return new Promise((resolve, reject) => {
+                // 构建完整的命令：使用 xfce4-terminal 启动 script 来记录会话
+                // xfce4-terminal --hold -e "bash -c \"script ... && touch done_flag\""
+
+                // 转义单引号以在 bash -c 中使用
+                const escapedScriptFile = scriptFile.replace(/'/g, "'\\''");
+                const escapedLogFile = logFile.replace(/'/g, "'\\''");
+                const escapedDoneFlag = doneFlag.replace(/'/g, "'\\''");
+
+                // 构建内部命令：运行 script，结束后 touch 标记文件
+                const innerCommand = `script -q -f -c 'bash ${escapedScriptFile}' '${escapedLogFile}' && touch '${escapedDoneFlag}'`;
+
+                const terminalArgs = [
+                    // '--hold',              // 命令结束后保持窗口打开
+                    '-e',                  // 执行命令
+                    `bash -c "${innerCommand}"` // 使用 bash -c 执行复合命令
+                ];
+
+                // 启动终端，不捕获其 stdio（避免 DBus 警告污染）
+                const child = spawn('xfce4-terminal', terminalArgs, {
+                    cwd,
+                    shell: false,
+                    stdio: ['ignore', 'ignore', 'ignore'],  // 忽略终端自身的输出
+                    detached: true  // 使终端独立运行
+                });
+
+                // 分离子进程，避免父进程等待
+                child.unref();
+
+                // 异步等待完成标记文件出现
+                const waitForCompletion = async () => {
+                    await sendNotification({
+                        level: 'info',
+                        data: '等待交互式程序运行完成...',
+                    });
+
+                    const maxWaitTime = 6 * 3600000; // 6 小时超时
+                    const pollInterval = 200;   // 每 200ms 检查一次
+                    const maxAttempts = maxWaitTime / pollInterval;
+                    let attempts = 0;
+
+                    // 记录开始时间和上次通知时间
+                    const startTime = Date.now();
+                    let lastNotifyTime = startTime;
+                    const notifyInterval = 1000; // 1秒发送一次
+
+                    while (attempts < maxAttempts) {
+                        try {
+                            // 检查标记文件是否存在
+                            await access(doneFlag);
+                            // 文件存在，脚本已完成
+                            break;
+                        } catch (error) {
+                            // 文件不存在，继续等待
+                            await new Promise(resolve => setTimeout(resolve, pollInterval));
+                            attempts++;
+
+                            // 检查是否需要发送时间通知
+                            const currentTime = Date.now();
+                            if (currentTime - lastNotifyTime >= notifyInterval) {
+                                const elapsedSeconds = Math.floor((currentTime - startTime) / 1000);
+                                const minutes = Math.floor(elapsedSeconds / 60);
+                                const seconds = elapsedSeconds % 60;
+                                const timeStr = minutes > 0
+                                    ? `${minutes}分${seconds}秒`
+                                    : `${seconds}秒`;
+
+                                await sendNotification({
+                                    level: 'info',
+                                    data: `已运行时间: ${timeStr}\r`,
+                                });
+
+                                lastNotifyTime = currentTime;
+                            }
+                        }
+                    }
+
+                    if (attempts >= maxAttempts) {
+                        console.error('等待脚本执行超时6小时');
+                        throw new Error('等待脚本执行超时');
+                    }
+
+                    // 读取日志文件内容
+                    let sessionOutput = '';
+                    try {
+                        sessionOutput = await readFile(logFile, 'utf-8');
+                        // 限制返回大小，只保留最后5000个字符
+                        const maxOutputLength = 5000;
+                        if (sessionOutput.length > maxOutputLength) {
+                            const truncated = sessionOutput.length - maxOutputLength;
+                            sessionOutput = `... [已截断前面 ${truncated} 个字符] ...\n\n` + sessionOutput.slice(-maxOutputLength);
+                        }
+                    } catch (readError) {
+                        await sendNotification({
+                            level: 'warning',
+                            data: `无法读取日志文件: ${readError.message}`,
+                        });
+                    }
+
+                    // 清理临时文件
+                    try {
+                        await unlink(scriptFile);
+                    } catch (unlinkError) {
+                        console.warn(`无法删除脚本文件 ${scriptFile}:`, unlinkError);
+                    }
+
+                    try {
+                        await unlink(logFile);
+                    } catch (unlinkError) {
+                        console.warn(`无法删除临时文件 ${logFile}:`, unlinkError);
+                    }
+
+                    try {
+                        await unlink(doneFlag);
+                    } catch (unlinkError) {
+                        console.warn(`无法删除标记文件 ${doneFlag}:`, unlinkError);
+                    }
+
+                    await sendNotification({
+                        level: 'info',
+                        data: '交互式命令执行完成',
+                    });
+
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: sessionOutput,
+                            },
+                        ],
+                    };
+                };
+
+                // 执行等待逻辑
+                waitForCompletion()
+                    .then(resolve)
+                    .catch(async (error) => {
+                        // 清理临时文件
+                        try {
+                            await unlink(scriptFile);
+                        } catch (unlinkError) {
+                            // 忽略删除错误
+                        }
+                        try {
+                            await unlink(logFile);
+                        } catch (unlinkError) {
+                            // 忽略删除错误
+                        }
+                        try {
+                            await unlink(doneFlag);
+                        } catch (unlinkError) {
+                            // 忽略删除错误
+                        }
+
+                        await sendNotification({
+                            level: 'error',
+                            data: `交互式命令执行错误: ${error.message}`,
+                        });
+                        reject(error);
+                    });
+
+                child.on('error', async (error) => {
+                    await sendNotification({
+                        level: 'error',
+                        data: `启动终端失败: ${error.message}`,
+                    });
+                    reject(error);
+                });
+            });
+        }
+    );
+}
+

package/tools/skills.js

@@ -0,0 +1,147 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * 解析 SKILL.md 文件的 YAML front matter
+ * @param {string} content - 文件内容
+ * @returns {object} 包含 name 和 description 的对象
+ */
+function parseSkillMd(content) {
+    const frontMatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+    const match = content.match(frontMatterRegex);
+
+    if (!match) {
+        return { name: null, description: null };
+    }
+
+    const frontMatter = match[1];
+    const lines = frontMatter.split('\n');
+    const result = {};
+
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.substring(0, colonIndex).trim();
+            const value = line.substring(colonIndex + 1).trim();
+            result[key] = value;
+        }
+    }
+
+    return {
+        name: result.name || null,
+        description: result.description || null,
+        // license: result.license || null
+    };
+}
+
+/**
+ * 递归扫描目录查找所有包含 SKILL.md 的技能目录
+ * @param {string} dirPath - 要扫描的目录路径
+ * @param {Array} skills - 技能数组（用于收集结果）
+ * @returns {Promise<void>}
+ */
+async function scanSkillsRecursively(dirPath, skills) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+        // 检查当前目录是否包含 SKILL.md
+        const skillMdPath = path.join(dirPath, 'SKILL.md');
+        let hasSkillMd = false;
+
+        try {
+            await fs.access(skillMdPath);
+            hasSkillMd = true;
+        } catch {
+            // SKILL.md 不存在
+        }
+
+        // 如果当前目录包含 SKILL.md，加载技能信息
+        if (hasSkillMd) {
+            try {
+                const content = await fs.readFile(skillMdPath, 'utf-8');
+                const metadata = parseSkillMd(content);
+                const dirName = path.basename(dirPath);
+
+                skills.push({
+                    name: metadata.name || dirName,
+                    description: metadata.description,
+                    path: dirPath,
+                    // license: metadata.license || null
+                });
+            } catch (error) {
+                console.warn(`Failed to read SKILL.md at ${skillMdPath}:`, error.message);
+            }
+        }
+
+        // 递归扫描所有子目录
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const subDirPath = path.join(dirPath, entry.name);
+                await scanSkillsRecursively(subDirPath, skills);
+            }
+        }
+    } catch (error) {
+        console.warn(`Failed to scan directory ${dirPath}:`, error.message);
+    }
+}
+
+/**
+ * 加载技能目录下的所有技能（递归扫描所有子目录）
+ * @param {Array<string>} ids - 可选的技能 ID 数组，用于加载 /readonly/skills/{id} 的技能
+ * @returns {Promise<Array>} 技能数组，每个元素包含 name, description, path
+ */
+export async function loadSkills(ids = []) {
+    const skills = [];
+
+    // 要扫描的目录列表
+    const dirsToScan = [
+        '/skills',
+        '/data/.skills',
+        '/data/skills',
+        '/data/.claude/skills',
+        '/root/.claude/skills',
+        '/data/.agents/skills',
+        '/root/.agents/skills',
+        '/data/.opencode/skills',
+        '/root/.opencode/skills'
+    ];
+
+    // 如果提供了 ids，添加 /readonly/skills/{id} 目录
+    if (ids && ids.length > 0) {
+        for (const id of ids) {
+            dirsToScan.push(`/readonly/skills/${id}`);
+        }
+    }
+
+    try {
+        // 扫描所有目录
+        for (const dir of dirsToScan) {
+            try {
+                await fs.access(dir);
+                // 递归扫描目录及所有子目录
+                await scanSkillsRecursively(dir, skills);
+                console.log(`Scanned directory: ${dir}`);
+            } catch (error) {
+                console.warn(`Skills directory ${dir} does not exist or is not accessible`);
+            }
+        }
+
+        console.log(`Loaded ${skills.length} skill(s) in total`);
+        return skills;
+    } catch (error) {
+        console.error('Error loading skills:', error);
+        throw error;
+    }
+}
+
+/**
+ * 获取指定技能的详细信息
+ * @param {string} skillName - 技能名称
+ * @param {Array<string>} ids - 可选的技能 ID 数组
+ * @returns {Promise<object|null>} 技能详细信息
+ */
+export async function getSkillDetails(skillName, ids = []) {
+    const skills = await loadSkills(ids);
+    return skills.find(skill => skill.name === skillName) || null;
+}
+