@myassis/gateway 1.0.34 → 1.0.36

package/dist/services/WebSocketService.js

@@ -8,6 +8,7 @@ exports.webSocketService = void 0;
 const ws_1 = require("ws");
 const index_js_1 = require("../stores/index.js");
 const shared_1 = require("@myassis/shared");
+const Session_js_1 = require("./session/Session.js");
 const logger = (0, shared_1.getLogger)('WebSocketService');
 class WebSocketService {
     wss = null;
@@ -127,6 +128,13 @@ class WebSocketService {
             case 'subscribe':
                 logger.debug(`用户 ${userId} 订阅: ${message.payload?.channel || 'all'}`);
                 break;
+            case 'approval_response':
+                // 处理批准响应
+                const { token, approved } = message.payload || {};
+                if (token) {
+                    (0, Session_js_1.handleApprovalResponse)(token, approved === true);
+                }
+                break;
             default:
                 logger.debug(`收到用户 ${userId} 的消息: ${message.type}`);
         }

package/dist/services/session/Session.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Session = void 0;
+exports.Session = exports.handleApprovalResponse = exports.registerApprovalWaiter = void 0;
 const uuid_1 = require("uuid");
 const shared_1 = require("@myassis/shared");
 const SessionStore_js_1 = require("./SessionStore.js");
@@ -16,6 +16,40 @@ const index_js_2 = require("../../config/index.js");
 const SessionManager_js_1 = require("./SessionManager.js");
 const logger = (0, shared_1.getLogger)('Session');
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// 批准等待缓存：token -> { resolve, reject, expiresAt }
+const approvalWaiters = new Map();
+/**
+ * 注册批准等待者
+ */
+function registerApprovalWaiter(token, timeout = 5 * 60 * 1000) {
+    return new Promise((resolve, reject) => {
+        approvalWaiters.set(token, {
+            resolve,
+            reject,
+            expiresAt: Date.now() + timeout,
+        });
+        // 超时自动拒绝
+        setTimeout(() => {
+            const waiter = approvalWaiters.get(token);
+            if (waiter) {
+                approvalWaiters.delete(token);
+                reject(new Error('批准请求超时'));
+            }
+        }, timeout);
+    });
+}
+exports.registerApprovalWaiter = registerApprovalWaiter;
+/**
+ * 处理批准响应（由 WebSocket 调用）
+ */
+function handleApprovalResponse(token, approved) {
+    const waiter = approvalWaiters.get(token);
+    if (waiter) {
+        approvalWaiters.delete(token);
+        waiter.resolve(approved);
+    }
+}
+exports.handleApprovalResponse = handleApprovalResponse;
 // AgentStore 单例 - 需要通过 SessionStore 获取数据库实例
 let agentStoreInstance = null;
 function getAgentStore() {
@@ -639,6 +673,141 @@ class Session {
                     sendSSE(res, toolStartEvent);
                     try {
                         const result = await (0, index_js_1.executeTool)(pendingToolCall.toolName, (0, LLMClient_js_1.parseAruments)(pendingToolCall.input), this.id, this.currentMessageId, this.userId);
+                        // 检查是否需要用户批准
+                        if (result.needsApproval) {
+                            // 发送需要批准的事件
+                            const approvalEvent = {
+                                type: 'approval_pending',
+                                id: pendingToolCall.id,
+                                toolName: pendingToolCall.toolName,
+                                actionName: pendingToolCall.actionName,
+                                input: pendingToolCall.input,
+                                approvalToken: result.approvalToken,
+                                errorMessage: result.errorMessage,
+                                toolCallId: toolCall.id,
+                                modelName,
+                                sessionId: this.id
+                            };
+                            sendSSE(res, approvalEvent);
+                            // 等待 Desktop 批准
+                            try {
+                                const approved = await registerApprovalWaiter(result.approvalToken);
+                                if (approved) {
+                                    // 用户批准，重新调用 executeTool 并传入 approved=true
+                                    const pending = (0, index_js_1.getAndRemovePendingApproval)(result.approvalToken);
+                                    if (pending) {
+                                        // 重新执行工具调用，传入 approved 参数
+                                        const approvedResult = await (0, index_js_1.executeTool)(pendingToolCall.toolName, { ...(0, LLMClient_js_1.parseAruments)(pendingToolCall.input), approved: true }, this.id, this.currentMessageId, this.userId);
+                                        toolResults.push({
+                                            id: pendingToolCall.id,
+                                            name: pendingToolCall.toolName,
+                                            output: approvedResult.output || approvedResult.errorMessage || '',
+                                            success: approvedResult.success,
+                                        });
+                                        toolCall.toolCalls.push({
+                                            id: pendingToolCall.id,
+                                            toolName: pendingToolCall.toolName,
+                                            input: pendingToolCall.input,
+                                            output: approvedResult.output || approvedResult.errorMessage || '',
+                                            status: approvedResult.success ? 'success' : 'error',
+                                            actionName: pendingToolCall.actionName
+                                        });
+                                        sendSSE(res, {
+                                            type: 'tool_call_result',
+                                            id: pendingToolCall.id,
+                                            toolName: pendingToolCall.toolName,
+                                            actionName: pendingToolCall.actionName,
+                                            output: JSON.stringify(approvedResult),
+                                            status: approvedResult.success ? 'success' : 'error',
+                                            toolCallId: toolCall.id,
+                                            modelName
+                                        });
+                                    }
+                                    else {
+                                        // 批准 token 已过期或不存在
+                                        toolResults.push({
+                                            id: pendingToolCall.id,
+                                            name: pendingToolCall.toolName,
+                                            output: '批准请求已过期',
+                                            success: false,
+                                        });
+                                        toolCall.toolCalls.push({
+                                            id: pendingToolCall.id,
+                                            toolName: pendingToolCall.toolName,
+                                            input: pendingToolCall.input,
+                                            output: '批准请求已过期',
+                                            status: 'error',
+                                            actionName: pendingToolCall.actionName
+                                        });
+                                        sendSSE(res, {
+                                            type: 'tool_call_result',
+                                            id: pendingToolCall.id,
+                                            toolName: pendingToolCall.toolName,
+                                            output: '批准请求已过期',
+                                            status: 'error',
+                                            toolCallId: toolCall.id,
+                                            actionName: pendingToolCall.actionName,
+                                            modelName
+                                        });
+                                    }
+                                }
+                                else {
+                                    // 用户拒绝
+                                    toolResults.push({
+                                        id: pendingToolCall.id,
+                                        name: pendingToolCall.toolName,
+                                        output: '用户拒绝执行',
+                                        success: false,
+                                    });
+                                    toolCall.toolCalls.push({
+                                        id: pendingToolCall.id,
+                                        toolName: pendingToolCall.toolName,
+                                        input: pendingToolCall.input,
+                                        output: '用户拒绝执行',
+                                        status: 'error',
+                                        actionName: pendingToolCall.actionName
+                                    });
+                                    sendSSE(res, {
+                                        type: 'tool_call_result',
+                                        id: pendingToolCall.id,
+                                        toolName: pendingToolCall.toolName,
+                                        output: '用户拒绝执行',
+                                        status: 'error',
+                                        toolCallId: toolCall.id,
+                                        actionName: pendingToolCall.actionName,
+                                        modelName
+                                    });
+                                }
+                            }
+                            catch (waitError) {
+                                // 等待超时或其他错误
+                                toolResults.push({
+                                    id: pendingToolCall.id,
+                                    name: pendingToolCall.toolName,
+                                    output: waitError.message,
+                                    success: false,
+                                });
+                                toolCall.toolCalls.push({
+                                    id: pendingToolCall.id,
+                                    toolName: pendingToolCall.toolName,
+                                    input: pendingToolCall.input,
+                                    output: waitError.message,
+                                    status: 'error',
+                                    actionName: pendingToolCall.actionName
+                                });
+                                sendSSE(res, {
+                                    type: 'tool_call_result',
+                                    id: pendingToolCall.id,
+                                    toolName: pendingToolCall.toolName,
+                                    output: waitError.message,
+                                    status: 'error',
+                                    toolCallId: toolCall.id,
+                                    actionName: pendingToolCall.actionName,
+                                    modelName
+                                });
+                            }
+                            return;
+                        }
                         toolResults.push({
                             id: pendingToolCall.id,
                             name: pendingToolCall.toolName,

package/dist/services/systemPrompt.js

@@ -125,7 +125,10 @@ async function getSystemPromptAsync(agent, customPrompt) {
   1.逐步思考，分步骤调用工具，工具调用前尽量返回content，明确当前工具调用的目的。
   2.工具调用的参数全部采用JSON语法，调用前先验证JSON语法正确后，再回复，切记未验证JSON语法就直接回复。
   【命令执行】执行命令时一定要根据当前系统来执行命令
-  【文件操作】文件编辑后一定要验证编辑是否成功，文件内容与预期是否一致，文件工具目前未提供批量替换操作，如果需要批量修改，请自行创建脚本来完成。
+  【文件操作】
+  1.文件编辑后一定要验证编辑是否成功，文件内容与预期是否一致。
+  2.文件工具目前未提供批量替换操作，如果需要批量修改，请自行创建脚本来完成。
+  3.大文件写入如果无法识别，请先写入主体内容，再使用edit工具进行修改来操作
   【特殊语法】mermaid折线图需要使用xychart-beta，完整示例如下：
   xychart-beta
     title "2025年上半年产品销量对比"

package/dist/services/tools/exec.js

@@ -3,14 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execTool = exports.clearSessionCwd = exports.setSessionCwd = exports.getSessionCwd = void 0;
+exports.execTool = exports.cleanupExpiredApprovals = exports.getAndRemovePendingApproval = exports.addPendingApproval = exports.clearSessionCwd = exports.setSessionCwd = exports.getSessionCwd = void 0;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const shared_1 = require("@myassis/shared");
+const crypto_1 = __importDefault(require("crypto"));
 const logger = (0, shared_1.getLogger)('exec');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// 待批准的命令缓存：token -> { command, cwd, timeout, sessionId, expiresAt }
+const pendingApprovals = new Map();
 // 会话级工作目录状态：sessionId -> cwd
 // 让 cd 命令能跨多次 exec 调用持久化工作目录
 const sessionCwdMap = new Map();
@@ -62,6 +65,63 @@ function clearSessionCwd(sessionId) {
     sessionCwdMap.delete(sessionId);
 }
 exports.clearSessionCwd = clearSessionCwd;
+/** 生成批准 token */
+function generateApprovalToken() {
+    return crypto_1.default.randomBytes(16).toString('hex');
+}
+/** 检查命令是否危险 */
+function isDangerousCommand(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))
+            return true;
+    }
+    return false;
+}
+/** 添加待批准命令，返回 token */
+function addPendingApproval(command, cwd, timeout, sessionId) {
+    const token = generateApprovalToken();
+    pendingApprovals.set(token, {
+        command,
+        cwd,
+        timeout,
+        sessionId,
+        expiresAt: Date.now() + 5 * 60 * 1000, // 5分钟过期
+    });
+    return token;
+}
+exports.addPendingApproval = addPendingApproval;
+/** 验证并获取待批准命令 */
+function getAndRemovePendingApproval(token) {
+    const pending = pendingApprovals.get(token);
+    if (!pending)
+        return null;
+    if (Date.now() > pending.expiresAt) {
+        pendingApprovals.delete(token);
+        return null;
+    }
+    pendingApprovals.delete(token);
+    return pending;
+}
+exports.getAndRemovePendingApproval = getAndRemovePendingApproval;
+/** 清理过期的待批准命令 */
+function cleanupExpiredApprovals() {
+    const now = Date.now();
+    for (const [token, pending] of pendingApprovals.entries()) {
+        if (now > pending.expiresAt) {
+            pendingApprovals.delete(token);
+        }
+    }
+}
+exports.cleanupExpiredApprovals = cleanupExpiredApprovals;
 exports.execTool = {
     name: 'exec',
     description: '在本地计算机上执行命令行命令。适用于运行系统命令、脚本、查看文件、执行程序等场景。',
@@ -86,22 +146,22 @@ exports.execTool = {
     },
     handler: async (args, sessionId) => {
         return new Promise(async (resolve) => {
-            const { cwd, timeout = 60000 } = args;
+            const { cwd, timeout = 60000, approved } = 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: '危险命令已拦截' });
+            // 检查危险命令（如果已批准则跳过）
+            if (!approved && isDangerousCommand(command)) {
+                if (!sessionId) {
+                    resolve({ success: false, errorMessage: '危险命令需要用户确认，但缺少会话ID' });
                     return;
                 }
+                const token = addPendingApproval(command, cwd, timeout, sessionId);
+                resolve({
+                    success: false,
+                    needsApproval: true,
+                    approvalToken: token,
+                    errorMessage: `危险命令需要用户确认：${command}`,
+                });
+                return;
             }
             const options = {
                 cwd,

package/dist/services/tools/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToolDefinitions = exports.executeTool = exports.getToolByName = exports.tools = void 0;
+exports.getToolDefinitions = exports.executeTool = exports.cleanupExpiredApprovals = exports.getAndRemovePendingApproval = exports.addPendingApproval = exports.getToolByName = exports.tools = void 0;
 /**
  * 工具定义集合
  */
@@ -27,6 +27,9 @@ const mouse_js_1 = require("./mouse.js");
 const fetch_js_1 = require("./fetch.js");
 const skill_js_1 = require("./skill.js");
 const exec_js_1 = require("./exec.js");
+Object.defineProperty(exports, "addPendingApproval", { enumerable: true, get: function () { return exec_js_1.addPendingApproval; } });
+Object.defineProperty(exports, "getAndRemovePendingApproval", { enumerable: true, get: function () { return exec_js_1.getAndRemovePendingApproval; } });
+Object.defineProperty(exports, "cleanupExpiredApprovals", { enumerable: true, get: function () { return exec_js_1.cleanupExpiredApprovals; } });
 const file_js_1 = require("./file.js");
 const task_js_1 = require("./task.js");
 const model_js_1 = require("./model.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myassis/gateway",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {