@myassis/gateway 1.0.0

package/dist/services/tools/exec.js

@@ -0,0 +1,119 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import os from 'os';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('exec');
+const execAsync = promisify(exec);
+// 会话级工作目录状态：sessionId -> cwd
+// 让 cd 命令能跨多次 exec 调用持久化工作目录
+const sessionCwdMap = new Map();
+/** 解析 cd 参数，返回目标绝对路径。支持 ~、相对路径、绝对路径 */
+function resolveCdTarget(cdArg, currentCwd) {
+    const arg = cdArg.trim();
+    if (!arg)
+        return os.homedir(); // cd 无参数 → 回家目录
+    if (arg === '~' || arg.startsWith('~/')) {
+        return path.join(os.homedir(), arg.slice(1));
+    }
+    // Windows 盘符路径或 Unix 绝对路径
+    if (path.isAbsolute(arg))
+        return path.resolve(arg);
+    // 相对路径：基于当前 cwd 解析
+    return path.resolve(currentCwd, arg);
+}
+/** 检查命令是否以 cd 开头，若是则提取目标路径（支持 cd /d D:\path 这种 Windows 写法）*/
+function parseCdCommand(command) {
+    const trimmed = command.trim();
+    // 匹配：cd arg  或  cd /d arg（Windows）或  cd "path with spaces"
+    const match = trimmed.match(/^cd(?:\s+\/d)?\s+(.+)$/is);
+    if (!match) {
+        // 裸 cd（无参数）→ 返回 home
+        if (/^cd\s*$/i.test(trimmed))
+            return '';
+        return null;
+    }
+    // 去掉末尾可能存在的 && 其他命令，只取 cd 的目标
+    let target = match[1].trim();
+    // 去掉引号
+    target = target.replace(/^['"]|['"]$/g, '');
+    // 如果 target 里包含 && 或 ; ，只取第一部分
+    const cut = target.split(/&&|\|/)[0].trim();
+    return cut || '';
+}
+/** 获取某个 session 的当前工作目录 */
+export function getSessionCwd(sessionId) {
+    return sessionCwdMap.get(sessionId);
+}
+/** 设置某个 session 的工作目录 */
+export function setSessionCwd(sessionId, cwd) {
+    sessionCwdMap.set(sessionId, cwd);
+}
+/** 清除某个 session 的工作目录（可选，用于会话结束时清理） */
+export function clearSessionCwd(sessionId) {
+    sessionCwdMap.delete(sessionId);
+}
+export const execTool = {
+    name: 'exec',
+    description: '在本地计算机上执行命令行命令。适用于运行系统命令、脚本、查看文件、执行程序等场景。',
+    parameters: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: '要执行的命令行命令。',
+            },
+            cwd: {
+                type: 'string',
+                description: '命令执行的工作目录（可选）。',
+            },
+            timeout: {
+                type: 'number',
+                description: '命令超时时间（毫秒），默认 60000',
+                default: 60000,
+            }
+        },
+        required: ['command'],
+    },
+    handler: async (args, sessionId) => {
+        return new Promise(async (resolve) => {
+            const { cwd, timeout = 60000 } = args;
+            let command = args.command;
+            const dangerousPatterns = [
+                /rm\s+-rf\s+\//,
+                /format\s+[a-z]:/i,
+                /del\s+\/[sfq]\s+\*/i,
+                /shutdown/i,
+                /reboot/i,
+                /mkfs/i,
+                /dd\s+if=.*of=\/dev\//i,
+            ];
+            for (const reg of dangerousPatterns) {
+                if (reg.test(command)) {
+                    resolve({ success: false, errorMessage: '危险命令已拦截' });
+                    return;
+                }
+            }
+            const options = {
+                cwd,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+                windowsHide: true,
+            };
+            try {
+                const { stdout, stderr } = await execAsync(command, options);
+                resolve({
+                    success: true,
+                    output: stdout.toLocaleString().substring(0, 100000),
+                    errorMessage: stderr.toLocaleString().substring(0, 100000)
+                });
+                return;
+            }
+            catch (e) {
+                const error = e;
+                resolve({ success: false, errorMessage: error.stdout.toLocaleString().substring(0, 100) + error.stderr.toLocaleString() + error.message });
+                return;
+            }
+        });
+    },
+};

package/dist/services/tools/fetch.js

@@ -0,0 +1,155 @@
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('FetchTool');
+let _undiciCache = null;
+async function loadUndici() {
+    if (_undiciCache)
+        return _undiciCache;
+    try {
+        const undici = await import('undici');
+        _undiciCache = { ProxyAgent: undici.ProxyAgent, fetch: undici.fetch };
+        return _undiciCache;
+    }
+    catch (error) {
+        logger.debug('Failed to load undici:', error?.message);
+        return null;
+    }
+}
+function getProxyUrl() {
+    return process.env.HTTPS_PROXY || process.env.https_proxy ||
+        process.env.HTTP_PROXY || process.env.http_proxy || 'http://127.0.0.1:7890';
+}
+const DEFAULT_PROXY_DOMAINS = [
+    'googleapis.com', 'google.com', 'gstatic.com', 'youtube.com', 'yt3.ggpht.com',
+    'openai.com', 'api.openai.com', 'chat.openai.com',
+    'anthropic.com', 'api.anthropic.com',
+    'github.com', 'githubusercontent.com',
+    'twitter.com', 'x.com', 'twimg.com',
+    'wikipedia.org', 'reddit.com', 'discord.com', 'discordapp.com',
+    'facebook.com', 'instagram.com', 'whatsapp.com', 'cloudflare.com',
+];
+const DEFAULT_NO_PROXY_DOMAINS = [
+    '.cn', '.com.cn', '.org.cn', '.net.cn',
+    'baidu.com', 'bilibili.com', 'qq.com', 'weixin.qq.com',
+    'taobao.com', 'tmall.com', 'jd.com', 'alipay.com',
+    'aliyun.com', 'tencentcloudapi.com', 'volcengineapi.com',
+    'douban.com', 'zhihu.com', 'weibo.com', 'douyin.com',
+    '163.com', '126.com', 'netease.com', 'sina.com.cn',
+    'localhost', '127.0.0.1', '::1',
+];
+function parseNoProxyEnv() {
+    return (process.env.NO_PROXY || process.env.no_proxy || '').split(',').map(s => s.trim()).filter(Boolean);
+}
+function shouldUseProxy(targetUrl) {
+    let hostname;
+    try {
+        hostname = new URL(targetUrl).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    for (const pattern of parseNoProxyEnv()) {
+        if (hostname === pattern || hostname.endsWith('.' + pattern))
+            return false;
+    }
+    for (const pattern of DEFAULT_NO_PROXY_DOMAINS) {
+        if (hostname === pattern || hostname.endsWith('.' + pattern))
+            return false;
+    }
+    for (const pattern of DEFAULT_PROXY_DOMAINS) {
+        if (hostname === pattern || hostname.endsWith('.' + pattern))
+            return true;
+    }
+    return false;
+}
+let _proxyDispatcherCache = null;
+async function getProxyDispatcher() {
+    const proxyUrl = getProxyUrl();
+    if (_proxyDispatcherCache && _proxyDispatcherCache.url === proxyUrl)
+        return _proxyDispatcherCache.dispatcher;
+    const undici = await loadUndici();
+    if (!undici)
+        return undefined;
+    try {
+        const dispatcher = new undici.ProxyAgent(proxyUrl);
+        _proxyDispatcherCache = { url: proxyUrl, dispatcher };
+        logger.info(`[Fetch] ProxyAgent created: ${proxyUrl}`);
+        return dispatcher;
+    }
+    catch (error) {
+        logger.debug('Failed to create ProxyAgent:', error?.message);
+        return undefined;
+    }
+}
+function toTimeoutSignal(ms) {
+    const validMs = Number.isFinite(ms) && ms > 0 ? ms : 30000;
+    return AbortSignal.timeout(validMs);
+}
+export const fetchTool = {
+    name: 'fetch',
+    description: '发送 HTTP 请求',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: '请求 URL' },
+            method: { type: 'string', description: 'HTTP 方法', enum: ['GET', 'POST', 'PUT', 'DELETE'], default: 'GET' },
+            headers: { type: 'object', description: '请求头' },
+            body: { type: 'string', description: '请求体（POST/PUT）' },
+            timeout: { type: 'number', description: '超时（毫秒）', default: 30000 },
+        },
+        required: ['url'],
+    },
+    handler: async (args) => {
+        const { url, method = 'GET', headers = {}, body, timeout = 30000 } = args;
+        try {
+            new URL(url);
+        }
+        catch {
+            return { success: false, errorMessage: '无效的 URL 格式' };
+        }
+        const reqHeaders = { 'User-Agent': 'Mozilla/5.0', ...headers };
+        const fetchOptions = { method, headers: reqHeaders, signal: toTimeoutSignal(timeout) };
+        if (body && ['POST', 'PUT'].includes(method)) {
+            fetchOptions.body = body;
+            if (!headers['Content-Type']) {
+                reqHeaders['Content-Type'] = 'application/json';
+                fetchOptions.headers = reqHeaders;
+            }
+        }
+        const useProxy = shouldUseProxy(url);
+        const undici = await loadUndici();
+        if (useProxy) {
+            const dispatcher = await getProxyDispatcher();
+            if (dispatcher)
+                fetchOptions.dispatcher = dispatcher;
+        }
+        const fetchFn = (useProxy && undici?.fetch) ? undici.fetch : globalThis.fetch;
+        logger.debug('fetch options', { method, url, useProxy });
+        try {
+            const response = await fetchFn(url, fetchOptions);
+            let responseBody = '';
+            try {
+                responseBody = await response.text();
+            }
+            catch { /* empty */ }
+            const contentType = response.headers.get('content-type') || '';
+            let data = responseBody;
+            if (contentType.includes('application/json')) {
+                try {
+                    data = JSON.parse(responseBody);
+                }
+                catch { /* keep as string */ }
+            }
+            return { success: true, output: JSON.stringify({ status: response.status, statusText: response.statusText, headers: Object.fromEntries(response.headers.entries()), body: typeof data === 'string' ? data.substring(0, 5000) : data }) };
+        }
+        catch (error) {
+            const cause = error instanceof Error ? error.cause : undefined;
+            logger.error('fetch error:', error, 'cause:', cause);
+            const message = error instanceof Error ? error.message : String(error);
+            const causeMsg = cause instanceof Error ? cause.message : (cause ? String(cause) : '');
+            if (error instanceof DOMException && error.name === 'TimeoutError') {
+                return { success: false, errorMessage: `请求超时（${timeout}ms）` };
+            }
+            return { success: false, errorMessage: `请求失败: ${message}${causeMsg ? ' | cause: ' + causeMsg : ''}` };
+        }
+    },
+};

package/dist/services/tools/file.js

@@ -0,0 +1,315 @@
+/**
+ * 文件操作工具
+ * 提供文件和目录的基础操作：读取、写入、创建、删除、搜索等
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('FileTool');
+const execAsync = promisify(exec);
+const DEFAULT_EXCLUDE_DIRS = [
+    'node_modules', '.git', '.svn', '.hg', 'dist', 'build', 'out', '.next', '.nuxt',
+    '.cache', '__pycache__', '.venv', '.env', '.idea', '.vscode', '.DS_Store',
+    'target', 'Pods', '.gradle', '.dart_tool',
+];
+const ALLOWED_DIRS = [
+    os.homedir(), '/tmp', process.env.GATEWAY_DIR || '/workspace/projects/gateway',
+    process.env.USER_HOME || '',
+].filter(Boolean);
+function isPathAllowed(_filePath) {
+    return true;
+}
+async function listDir(dirPath) {
+    const items = await fs.readdir(dirPath, { withFileTypes: true });
+    return items.map(item => ({ name: item.name, type: item.isDirectory() ? 'directory' : 'file', path: path.join(dirPath, item.name) }));
+}
+function isDirExcluded(dirName, excludeDirs) {
+    const lower = dirName.toLowerCase();
+    return excludeDirs.some(excl => lower === excl.toLowerCase() || lower.startsWith(excl.toLowerCase()));
+}
+function isWildcardPattern(query) {
+    return (query.includes('*') || query.includes('?')) && !query.startsWith('/');
+}
+function wildcardToRegex(pattern, matchWhole = true) {
+    let regexStr = '';
+    for (const char of pattern) {
+        if (char === '*')
+            regexStr += '.*';
+        else if (char === '?')
+            regexStr += '.';
+        else if ('.\\^$|+()[]{}'.includes(char))
+            regexStr += '\\' + char;
+        else
+            regexStr += char;
+    }
+    return new RegExp(matchWhole ? `^${regexStr}$` : regexStr, 'g');
+}
+function matchText(text, query, caseSensitive, wholeWord) {
+    if (wholeWord) {
+        const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`\\b${escaped}\\b`, caseSensitive ? 'g' : 'gi');
+        return regex.test(text);
+    }
+    return caseSensitive ? text.includes(query) : text.toLowerCase().includes(query.toLowerCase());
+}
+function matchFileName(fileName, query, caseSensitive, wholeWord) {
+    if (wholeWord) {
+        const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`\\b${escaped}\\b`, caseSensitive ? 'g' : 'gi');
+        return regex.test(fileName);
+    }
+    return caseSensitive ? fileName.includes(query) : fileName.toLowerCase().includes(query.toLowerCase());
+}
+function parseSearchQuery(query) {
+    const match = /^\/(.+)\/([gimsuy]*)$/.exec(query);
+    if (match) {
+        try {
+            return { regex: new RegExp(match[1], match[2]), plainText: null };
+        }
+        catch {
+            return { regex: null, plainText: query };
+        }
+    }
+    return { regex: null, plainText: query };
+}
+async function searchFiles(dirPath, query, maxResults = 50, excludeDirs = DEFAULT_EXCLUDE_DIRS, caseSensitive = false, wholeWord = false) {
+    const results = [];
+    const searchMode = parseSearchQuery(query);
+    const wildcardRegex = isWildcardPattern(query) ? wildcardToRegex(query, true) : null;
+    async function searchDir(dir) {
+        if (results.length >= maxResults)
+            return;
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (results.length >= maxResults)
+                    break;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory() && !item.name.startsWith('.') && !isDirExcluded(item.name, excludeDirs)) {
+                    await searchDir(fullPath);
+                }
+                else if (item.isFile()) {
+                    const matched = wildcardRegex ? wildcardRegex.test(item.name) :
+                        matchFileName(item.name, searchMode.plainText || query, caseSensitive, wholeWord);
+                    if (matched)
+                        results.push(fullPath);
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    await searchDir(dirPath);
+    return results;
+}
+export const fileTool = {
+    name: 'file',
+    description: '文件和目录操作工具',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '操作类型：read、write、mkdir、delete、rmdir、list、open、search、searchContent',
+                enum: ['read', 'write', 'mkdir', 'delete', 'rmdir', 'list', 'open', 'search', 'searchContent'],
+            },
+            path: { type: 'string', description: '文件或目录路径' },
+            content: { type: 'string', description: '写入内容（write）' },
+            searchQuery: { type: 'string', description: '搜索关键词（search/searchContent）' },
+            maxResults: { type: 'number', description: '最大结果数', default: 50 },
+            excludeDirs: { type: 'string', description: '排除的目录（逗号分隔）' },
+            caseSensitive: { type: 'boolean', description: '区分大小写', default: false },
+            wholeWord: { type: 'boolean', description: '全字匹配', default: false },
+            offset: { type: 'number', description: '起始行号（从1开始）' },
+            limit: { type: 'number', description: '读取行数' },
+            maxContentResults: { type: 'number', description: '内容搜索最大结果数', default: 20 },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, path: filePath, content, searchQuery, maxResults = 50, excludeDirs, caseSensitive = false, wholeWord = false } = args;
+            const effectiveExcludeDirs = typeof excludeDirs === 'string' && excludeDirs.trim()
+                ? [...new Set([...DEFAULT_EXCLUDE_DIRS, ...excludeDirs.split(',').map((d) => d.trim()).filter(Boolean)])]
+                : DEFAULT_EXCLUDE_DIRS;
+            if (!isPathAllowed(filePath))
+                return { success: false, errorMessage: `路径不在允许范围内` };
+            switch (action) {
+                case 'read': {
+                    const stats = await fs.stat(filePath);
+                    if (stats.isDirectory()) {
+                        const items = await listDir(filePath);
+                        return { success: true, output: JSON.stringify({ type: 'directory', items }) };
+                    }
+                    const fileContent = await fs.readFile(filePath, 'utf-8');
+                    // split('\n') 会保留末尾空行，用 filter(Boolean) 去掉末尾空元素
+                    // 保持一致性：无论文件是否以 \n 结尾，行号都从 1 开始，终点为总行数
+                    const allLines = fileContent.split('\n').filter((_, i, arr) => !(i === arr.length - 1 && _ === ''));
+                    const totalLines = allLines.length;
+                    const offset = args.offset !== undefined ? Math.max(1, args.offset) : 1;
+                    const limit = args.limit !== undefined ? args.limit : 0;
+                    // limit=0 时读取到文件末尾
+                    const endLine = limit === 0 ? totalLines : Math.min(offset + limit - 1, totalLines);
+                    if (offset > totalLines) {
+                        return { success: true, output: JSON.stringify({ totalLines, message: `offset (${offset}) 超出文件总行数 (${totalLines})，文件已读完` }) };
+                    }
+                    // 显示真实行号（而非 1,2,3...）让 LLM 准确知道位置
+                    const contentLines = allLines.slice(offset - 1, endLine).map((item, index) => `${offset + index} ${item}`);
+                    // 原始内容（无行号前缀），供 LLM 用作 edit 的 oldContent 比对
+                    const rawContent = allLines.slice(offset - 1, endLine).join('\n');
+                    return {
+                        success: true,
+                        output: JSON.stringify({
+                            totalLines,
+                            readRange: { startLine: offset, endLine },
+                            // 带行号前缀的显示内容，LLM 可参考行号
+                            content: contentLines.join('\n'),
+                            // 原始内容（无行号），供 oldContent 比对使用
+                            rawContent,
+                        }),
+                    };
+                }
+                case 'write': {
+                    if (content === undefined)
+                        return { success: false, errorMessage: 'write 操作需要提供 content' };
+                    const dir = path.dirname(filePath);
+                    await fs.mkdir(dir, { recursive: true });
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    return { success: true, output: JSON.stringify({ path: filePath, size: content.length }) };
+                }
+                case 'mkdir': {
+                    await fs.mkdir(filePath, { recursive: true });
+                    return { success: true, output: JSON.stringify({ path: filePath }) };
+                }
+                case 'delete': {
+                    const stats = await fs.stat(filePath);
+                    if (stats.isDirectory())
+                        return { success: false, errorMessage: 'delete 用于删除文件，删除目录请使用 rmdir' };
+                    await fs.unlink(filePath);
+                    return { success: true, output: JSON.stringify({ path: filePath }) };
+                }
+                case 'rmdir': {
+                    const rmdirStat = await fs.stat(filePath);
+                    if (!rmdirStat.isDirectory())
+                        return { success: false, errorMessage: 'rmdir 用于删除目录' };
+                    await fs.rm(filePath, { recursive: true });
+                    return { success: true, output: JSON.stringify({ path: filePath }) };
+                }
+                case 'list': {
+                    const items = await listDir(filePath);
+                    return { success: true, output: JSON.stringify({ total: items.length, items }) };
+                }
+                case 'open': {
+                    const stats = await fs.stat(filePath);
+                    const targetPath = stats.isFile() ? path.dirname(filePath) : filePath;
+                    let command, ignoreExitCode = false;
+                    switch (os.platform()) {
+                        case 'darwin':
+                            command = `open "${targetPath}"`;
+                            break;
+                        case 'win32':
+                            command = `explorer "${targetPath}"`;
+                            ignoreExitCode = true;
+                            break;
+                        default:
+                            command = `xdg-open "${targetPath}"`;
+                            break;
+                    }
+                    try {
+                        await execAsync(command);
+                    }
+                    catch (error) {
+                        if (!ignoreExitCode || error.code !== 1)
+                            throw error;
+                    }
+                    return { success: true, output: JSON.stringify({ path: targetPath, platform: os.platform() }) };
+                }
+                case 'search': {
+                    if (!searchQuery)
+                        return { success: false, errorMessage: 'search 操作需要提供 searchQuery' };
+                    let searchRoot = filePath || os.homedir();
+                    try {
+                        const rootStat = await fs.stat(searchRoot);
+                        if (!rootStat.isDirectory())
+                            return { success: false, errorMessage: `path 必须是目录` };
+                    }
+                    catch {
+                        return { success: false, errorMessage: `搜索目录不存在或无法访问: ${searchRoot}` };
+                    }
+                    const results = await searchFiles(searchRoot, searchQuery, maxResults, effectiveExcludeDirs, caseSensitive, wholeWord);
+                    return { success: true, output: JSON.stringify({ query: searchQuery, total: results.length, results }) };
+                }
+                case 'searchContent': {
+                    if (!searchQuery)
+                        return { success: false, errorMessage: 'searchContent 操作需要提供 searchQuery' };
+                    const stats = await fs.stat(filePath);
+                    const isDir = stats.isDirectory();
+                    const results = [];
+                    const maxContent = args.maxContentResults || 20;
+                    const searchMode = parseSearchQuery(searchQuery);
+                    const wildcardRegex = isWildcardPattern(searchQuery) ? wildcardToRegex(searchQuery, false) : null;
+                    const BINARY_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg', '.mp3', '.mp4', '.avi', '.mov', '.wav', '.flac', '.zip', '.tar', '.gz', '.rar', '.7z', '.exe', '.dll', '.so', '.dylib', '.bin', '.dat', '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.sqlite', '.db', '.woff', '.woff2', '.ttf', '.eot', '.class', '.jar', '.pyc', '.o', '.obj']);
+                    async function searchInFile(targetPath) {
+                        try {
+                            const fileContent = await fs.readFile(targetPath, 'utf-8');
+                            const lines = fileContent.split('\n');
+                            for (let i = 0; i < lines.length; i++) {
+                                if (results.length >= maxContent)
+                                    return;
+                                const line = lines[i];
+                                let matched = false;
+                                if (searchMode.regex) {
+                                    matched = searchMode.regex.test(line);
+                                    searchMode.regex.lastIndex = 0;
+                                }
+                                else if (wildcardRegex)
+                                    matched = wildcardRegex.test(line);
+                                else if (searchMode.plainText)
+                                    matched = matchText(line, searchMode.plainText, caseSensitive, wholeWord);
+                                if (matched)
+                                    results.push({ file: targetPath, line: i + 1, content: line.substring(0, 200) });
+                            }
+                        }
+                        catch { /* ignore */ }
+                    }
+                    async function searchDirRecursive(dirPath) {
+                        if (results.length >= maxContent)
+                            return;
+                        try {
+                            const items = await fs.readdir(dirPath, { withFileTypes: true });
+                            for (const item of items) {
+                                if (results.length >= maxContent)
+                                    break;
+                                const fullPath = path.join(dirPath, item.name);
+                                if (item.isDirectory() && !item.name.startsWith('.') && !isDirExcluded(item.name, effectiveExcludeDirs)) {
+                                    await searchDirRecursive(fullPath);
+                                }
+                                else if (item.isFile()) {
+                                    const ext = path.extname(item.name).toLowerCase();
+                                    if (!BINARY_EXTS.has(ext))
+                                        await searchInFile(fullPath);
+                                }
+                            }
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (!isDir) {
+                        await searchInFile(filePath);
+                    }
+                    else {
+                        await searchDirRecursive(filePath);
+                    }
+                    return { success: true, output: JSON.stringify({ query: searchQuery, path: filePath, total: results.length, results }) };
+                }
+                default:
+                    return { success: false, errorMessage: `未知的文件操作: ${action}` };
+            }
+        }
+        catch (error) {
+            logger.error(`文件操作失败: ${error.message}`, { error, action: args?.action });
+            return { success: false, errorMessage: `文件操作失败: ${error.message}` };
+        }
+    },
+};

package/dist/services/tools/index.js

@@ -0,0 +1,48 @@
+/**
+ * 工具定义集合
+ */
+export * from './types';
+import { searchTool } from './search';
+import { calculatorTool } from './calculator';
+import { screenshotTool } from './screenshot';
+import { keyboardTool } from './keyboard';
+import { mouseTool } from './mouse';
+import { fetchTool } from './fetch';
+import { skillTool } from './skill';
+import { execTool } from './exec';
+import { fileTool } from './file';
+import { taskTool } from './task';
+import { modelTool } from './model';
+import { editTool } from './edit';
+import { webFetchTool } from './webFetch';
+export const tools = [
+    searchTool, calculatorTool, screenshotTool, keyboardTool, mouseTool,
+    skillTool, execTool, taskTool, modelTool, fetchTool,
+    editTool, webFetchTool, fileTool
+];
+export function getToolByName(name) {
+    return tools.find(tool => tool.name === name);
+}
+/**
+ * 执行工具调用，返回 ToolResult（AI 可见格式）
+ */
+export async function executeTool(name, args, sessionId, messageId) {
+    const tool = getToolByName(name);
+    if (!tool)
+        throw new Error(`Tool not found: ${name}`);
+    return await tool.handler(args, sessionId, messageId);
+}
+export function getToolDefinitions() {
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: 'object',
+                properties: tool.parameters.properties,
+                required: tool.parameters.required || [],
+            },
+        },
+    }));
+}