@myassis/gateway 1.0.82 → 1.0.83

package/dist/main.js

@@ -31,6 +31,21 @@ const WebSocketService_js_1 = require("./services/WebSocketService.js");
 const TaskSchedulerService_js_1 = require("./services/TaskSchedulerService.js");
 const ServiceManager_js_1 = require("./services/ServiceManager.js");
 const logger = (0, shared_1.getLogger)('index');
+// 内置放通的官方域名（含子域名），无需用户手动 addCors
+const DEFAULT_CORS_DOMAINS = ['my-assis.com'];
+// 判断来源主机是否命中某个域名（自身或其子域名）
+function matchDomain(originHost, domain) {
+    // 允许配置成裸域名（app.example.com）、带协议的完整来源（https://app.example.com）或通配符（*.example.com）
+    const d = domain
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '')
+        .replace(/^\*\./, '');
+    if (!d)
+        return false;
+    return originHost === d || originHost.endsWith('.' + d);
+}
 // ─── CLI 模式 ─────────────────────────────────────────
 // gateway install | start | stop | uninstall | status | update
 const cliCommand = process.argv[2];
@@ -137,9 +152,11 @@ if (cliCommand) {
                 }
             }
             else if (cliCommand === 'listCors') {
+                console.log(`内置 CORS 域名 (${DEFAULT_CORS_DOMAINS.length}):`);
+                DEFAULT_CORS_DOMAINS.forEach(d => console.log(`  - *.${d}`));
                 const domains = persistStore_js_1.persistStore.getCorsDomains();
                 if (domains.length === 0) {
-                    console.log('暂无自定义 CORS 域名（仅使用内置内网规则）');
+                    console.log('暂无自定义 CORS 域名（仅使用内置内网与内置域名规则）');
                 }
                 else {
                     console.log(`自定义 CORS 域名 (${domains.length}):`);
@@ -147,35 +164,27 @@ if (cliCommand) {
                 }
             }
             else if (cliCommand === '--help' || cliCommand === '-h') {
-                console.log(`我的助手 Gateway CLI
-
-用法: gateway <命令>
-
-服务管理命令:
-  install       安装 Gateway 服务（后台运行）
-  uninstall     卸载 Gateway 服务
-  start         启动 Gateway 服务
-  stop          停止 Gateway 服务
-  restart       重启 Gateway 服务
-  update        更新 Gateway（需重新安装）
-  status        查看服务状态
-
-CORS 管理命令:
-  addCors <域名>      添加允许的跨域域名
-  removeCors <域名>    移除允许的跨域域名
-  listCors            列出所有自定义跨域域名
-
-其他:
-  --help, -h          显示本帮助信息
+                console.log(`我的助手 Gateway CLI
+
+用法: gateway <命令>
+
+服务管理命令:
+  install       安装 Gateway 服务（后台运行）
+  uninstall     卸载 Gateway 服务
+  start         启动 Gateway 服务
+  stop          停止 Gateway 服务
+  restart       重启 Gateway 服务
+  update        更新 Gateway（需重新安装）
+  status        查看服务状态
+
+CORS 管理命令:
+  addCors <域名>      添加允许的跨域域名
+  removeCors <域名>    移除允许的跨域域名
+  listCors            列出所有跨域域名（含内置域名）
+
+其他:
+  --help, -h          显示本帮助信息
 `);
-                const domains = persistStore_js_1.persistStore.getCorsDomains();
-                if (domains.length === 0) {
-                    console.log('暂无自定义 CORS 域名（仅使用内置内网规则）');
-                }
-                else {
-                    console.log(`自定义 CORS 域名 (${domains.length}):`);
-                    domains.forEach(d => console.log(`  - ${d}`));
-                }
             }
             else {
                 const fnMap = {
@@ -233,19 +242,31 @@ else {
             if (lanPatterns.some(pattern => pattern.test(origin))) {
                 return callback(null, true);
             }
-            // 检查自定义域名（支持子域名匹配）
-            const customDomains = persistStore_js_1.persistStore.getCorsDomains();
-            const originLower = origin.toLowerCase();
-            if (customDomains.some(d => {
-                const dLower = d.toLowerCase();
-                return originLower === dLower || originLower.endsWith('.' + dLower);
-            })) {
+            let originHost = '';
+            try {
+                originHost = new URL(origin).hostname.toLowerCase();
+            }
+            catch {
+                originHost = origin.toLowerCase();
+            }
+            // 检查内置官方域名与用户自定义域名（均支持子域名匹配）
+            const allowedDomains = [...DEFAULT_CORS_DOMAINS, ...persistStore_js_1.persistStore.getCorsDomains()];
+            if (allowedDomains.some(d => matchDomain(originHost, d))) {
                 return callback(null, true);
             }
             callback(new Error('Not allowed by CORS'));
         },
         credentials: true,
     };
+    // Chrome Private Network Access：公网页面（网页版）访问本机 Gateway 时，
+    // 预检请求会带 Access-Control-Request-Private-Network，必须显式放行。
+    // 必须注册在 cors() 之前，否则 cors 会先结束 OPTIONS 预检，响应头加不上。
+    app.use((req, res, next) => {
+        if (req.headers['access-control-request-private-network']) {
+            res.setHeader('Access-Control-Allow-Private-Network', 'true');
+        }
+        next();
+    });
     app.use((0, cors_1.default)(corsOptions));
     app.use(express_1.default.json({ limit: '10mb' }));
     // Health check

package/dist/services/ServiceManager.js

@@ -112,65 +112,168 @@ function getStoredPid() {
  *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
  *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
  */
-async function stopGatewayProcess() {
-    const pid = getStoredPid();
-    if (!pid)
+/**
+ * 探测进程是否存活（signal 0 不会真的发信号）
+ */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 轮询等待指定进程退出，返回是否已退出
+ */
+async function waitForPidExit(pid, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!isPidAlive(pid))
+            return true;
+        await new Promise(r => setTimeout(r, 200));
+    }
+    return !isPidAlive(pid);
+}
+/**
+ * 读取守护进程 PID
+ */
+function getDaemonPid() {
+    try {
+        if (!fs_1.default.existsSync(GATEWAY_DAEMON_PID_FILE))
+            return null;
+        // 去除 PowerShell Out-File -Encoding UTF8 写入的 BOM，否则 parseInt 会得到 NaN
+        const raw = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 结束守护进程（运行 launcher.ps1 的那个 PowerShell）
+ *
+ * 必须在结束 gateway 之前调用：守护进程每 5s 轮询一次，若发现 gateway 已退出
+ * 且此刻停止标记不存在，就会立即重新拉起，表现为「stop 之后网关又活了」。
+ */
+async function stopDaemonProcess() {
+    if (process.platform !== 'win32')
         return;
-    // —— 场景 1：要停的就是自己 —— 走优雅退出
-    if (pid === process.pid) {
+    const daemonPid = getDaemonPid();
+    if (daemonPid && daemonPid !== process.pid && isPidAlive(daemonPid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+            process.kill(daemonPid, 'SIGTERM');
         }
         catch { /* ignore */ }
-        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
-        setTimeout(() => {
+        if (!(await waitForPidExit(daemonPid, 3000))) {
             try {
-                process.emit('SIGTERM');
+                process.kill(daemonPid, 'SIGKILL');
             }
             catch { /* ignore */ }
-            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
-            setTimeout(() => process.exit(0), 5000).unref();
-        }, 100).unref();
-        return;
-    }
-    // —— 场景 2：停的是别人（孤儿进程 / 旧实例）—— 才真正发信号
-    try {
-        process.kill(pid, 'SIGTERM');
-        await new Promise(r => setTimeout(r, 2000));
+            await waitForPidExit(daemonPid, 2000);
+        }
     }
-    catch { /* ignore */ }
-    // 强制终止（如果还没退出）
     try {
-        process.kill(pid, 'SIGKILL');
+        fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
     }
     catch { /* ignore */ }
+}
+/**
+ * PID 文件丢失/过期时的兜底：按 exe 路径匹配并结束 gateway 进程
+ *
+ * PID 文件位于 %TEMP%，可能被系统清理策略删除，此时仅靠 PID 会漏杀。
+ * 仅在打包为 exe 时启用：开发模式下 execPath 是 node.exe，按路径匹配会误杀其它 Node 进程。
+ */
+async function stopGatewayByExePath() {
+    if (process.platform !== 'win32' || !isPackagedExe())
+        return 0;
+    const exe = process.execPath;
+    const name = path_1.default.basename(exe, path_1.default.extname(exe));
+    const q = (v) => v.replace(/'/g, "''");
     try {
-        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
-    }
-    catch { /* ignore */ }
-    // 同时杀掉守护进程（防止它重新拉起 gateway）
-    if (process.platform === 'win32') {
-        try {
-            const daemonPidStr = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
-            const daemonPid = parseInt(daemonPidStr, 10);
-            if (daemonPid && !isNaN(daemonPid)) {
-                try {
-                    process.kill(daemonPid, 'SIGTERM');
-                }
-                catch { /* ignore */ }
-                await new Promise(r => setTimeout(r, 500));
+        const { stdout } = await execAsync(`powershell -NoProfile -Command "Get-Process -Name '${q(name)}' -ErrorAction SilentlyContinue | ` +
+            `Where-Object { $_.Id -ne ${process.pid} -and $_.Path -ieq '${q(exe)}' } | ` +
+            `ForEach-Object { $_.Id }"`, { timeout: 10000, windowsHide: true });
+        const pids = stdout.split(/\r?\n/)
+            .map(line => parseInt(line.trim(), 10))
+            .filter(n => !isNaN(n) && n !== process.pid);
+        for (const orphan of pids) {
+            try {
+                process.kill(orphan, 'SIGTERM');
+            }
+            catch { /* ignore */ }
+            if (!(await waitForPidExit(orphan, 3000))) {
                 try {
-                    process.kill(daemonPid, 'SIGKILL');
+                    process.kill(orphan, 'SIGKILL');
                 }
                 catch { /* ignore */ }
             }
         }
+        return pids.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 停止 Gateway 用户进程（优雅终止）
+ *
+ * 注意：当 pid 指向当前进程自己时，绝不能使用 process.kill(pid)。
+ *   - Windows 上 Node 的 process.kill 等同 TerminateProcess，无清理机会，
+ *     server.close() / WebSocket / 文件句柄都不会被释放，会导致后续 exe 解锁超时。
+ *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
+ *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
+ *
+ * 返回：self 表示停的是当前进程（无法在本进程内校验最终结果），
+ *       stopped 表示已确认目标进程退出。
+ */
+async function stopGatewayProcess() {
+    const pid = getStoredPid();
+    // 先断开守护进程，否则它会在 gateway 退出后立刻把它重新拉起
+    await stopDaemonProcess();
+    // —— 场景 1：要停的就是自己 —— 走优雅退出
+    if (pid && pid === process.pid) {
+        try {
+            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+        }
         catch { /* ignore */ }
+        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
+        setTimeout(() => {
+            try {
+                process.emit('SIGTERM');
+            }
+            catch { /* ignore */ }
+            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
+            setTimeout(() => process.exit(0), 5000).unref();
+        }, 100).unref();
+        return { stopped: true, self: true };
+    }
+    // —— 场景 2：停的是别人（CLI 停后台实例 / 孤儿进程）—— 才真正发信号
+    let stopped = true;
+    if (pid && isPidAlive(pid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+            process.kill(pid, 'SIGTERM');
         }
         catch { /* ignore */ }
+        stopped = await waitForPidExit(pid, 5000);
+        if (!stopped) {
+            // 优雅关闭超时，强制终止
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch { /* ignore */ }
+            stopped = await waitForPidExit(pid, 3000);
+        }
     }
+    try {
+        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+    }
+    catch { /* ignore */ }
+    // 兜底：清理没被 PID 文件记录到的残留进程
+    await stopGatewayByExePath();
+    return { stopped, self: false };
 }
 /**
  * 写入 Gateway 启动脚本（用户级，不弹出窗口）
@@ -226,8 +329,14 @@ function writeGatewayLauncherScript(exePath, scriptPath, workDir) {
         '# 守护循环：监控进程状态，异常退出则自动重启',
         'while ($true) {',
         '  try {',
-        '    # 每 5 秒检查一次进程是否仍在运行',
-        '    Start-Sleep -Seconds 5',
+        '    # 每 1 秒检查一次：轮询间隔过长会错过 stop 写入的停止标记，导致误重启',
+        '    Start-Sleep -Seconds 1',
+        '',
+        '    # 优先判定停止标记：无论 gateway 是否已退出，主动停止时守护都应该退出',
+        '    if (Test-Path $stopFlag) {',
+        "      Write-Log '检测到停止标记，守护进程退出'",
+        '      break',
+        '    }',
         '',
         '    # 进程已退出',
         '    if ($proc.HasExited) {',
@@ -364,6 +473,11 @@ async function startServiceWindows() {
         return { success: true, message: 'Gateway 已在运行' };
     }
     try {
+        // 清除上一次 stop 可能残留的停止标记，否则新守护会立即退出
+        try {
+            fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
+        }
+        catch { /* ignore */ }
         const exe = getGatewayExePath();
         const workDir = path_1.default.dirname(exe);
         if (!fs_1.default.existsSync(GATEWAY_LAUNCHER_FILE)) {
@@ -388,9 +502,15 @@ async function startServiceWindows() {
 }
 async function restartServiceWindows() {
     try {
-        await stopService();
+        const stopResult = await stopService();
+        if (!stopResult.success) {
+            return { success: false, message: `重启失败（停止阶段）: ${stopResult.message}` };
+        }
         await new Promise(r => setTimeout(r, 1000));
-        await startService();
+        const startResult = await startService();
+        if (!startResult.success) {
+            return { success: false, message: `重启失败（启动阶段）: ${startResult.message}` };
+        }
         return { success: true, message: 'Gateway 重启成功' };
     }
     catch (err) {
@@ -399,23 +519,33 @@ async function restartServiceWindows() {
 }
 async function stopServiceWindows() {
     try {
+        if (!isGatewayRunning() && !getDaemonPid()) {
+            return { success: true, message: 'Gateway 未在运行' };
+        }
         // 写入停止标记，告知守护进程这是主动停止，不要重启
         try {
+            fs_1.default.mkdirSync(path_1.default.dirname(GATEWAY_STOP_FLAG_FILE), { recursive: true });
             fs_1.default.writeFileSync(GATEWAY_STOP_FLAG_FILE, '1', 'utf8');
         }
         catch { /* ignore */ }
-        // 给守护进程一点时间检测到标记
-        await new Promise(r => setTimeout(r, 200));
-        await stopGatewayProcess();
-        // 清理停止标记和守护进程 PID 文件
+        const { stopped, self } = await stopGatewayProcess();
+        // 自停场景（HTTP 接口调用）退出发生在本函数返回之后，无法在此校验，
+        // 也不能删停止标记（它要留给守护进程判定主动停止）
+        if (self) {
+            return { success: true, message: 'Gateway 正在退出' };
+        }
+        // 确认退出后才能清理停止标记，否则残留守护会把 gateway 重新拉起
+        if (!stopped) {
+            return { success: false, message: 'Gateway 进程未能终止，请手动结束进程后重试' };
+        }
         try {
             fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
         }
         catch { /* ignore */ }
-        try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+        // 最终校验：避免在没真正停掉时还报成功
+        if (isGatewayRunning()) {
+            return { success: false, message: 'Gateway 仍在运行，停止失败' };
         }
-        catch { /* ignore */ }
         return { success: true, message: 'Gateway 已停止' };
     }
     catch (err) {
@@ -451,21 +581,21 @@ async function installLinux() {
         if (installed)
             await stopService();
         const execStart = isPkg ? exe : `${exe} ${script}`;
-        const unitContent = `[Unit]
-Description=${exports.SERVICE_DISPLAY_NAME}
-After=network.target
-
-[Service]
-Type=simple
-User=${process.env.USER || 'root'}
-WorkingDirectory=${workDir}
-ExecStart=${execStart}
-Restart=always
-RestartSec=5
-Environment=NODE_ENV=production
-
-[Install]
-WantedBy=multi-user.target
+        const unitContent = `[Unit]
+Description=${exports.SERVICE_DISPLAY_NAME}
+After=network.target
+
+[Service]
+Type=simple
+User=${process.env.USER || 'root'}
+WorkingDirectory=${workDir}
+ExecStart=${execStart}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
 `;
         await fs_1.default.promises.writeFile('/tmp/myassis-gateway.service', unitContent, 'utf8');
         await execAsync('cp /tmp/myassis-gateway.service /etc/systemd/system/myassis-gateway.service', { timeout: 10000 });

package/dist/services/session/Session.js

@@ -495,6 +495,59 @@ class Session {
         lines.push('调用时必须传入完整步骤列表，且同一时刻最多一个步骤为 in_progress。');
         return lines.join('\n');
     }
+    /**
+     * 把当前计划推送到 Desktop。
+     *
+     * 用动态 import 获取 webSocketService：WebSocketService 反向依赖本文件的
+     * handleApprovalResponse，静态引入会形成循环依赖。
+     */
+    async notifyPlanUpdate() {
+        try {
+            const { webSocketService } = await Promise.resolve().then(() => __importStar(require('../WebSocketService.js')));
+            webSocketService.sendToUser(String(this.userId), {
+                type: 'plan_updated',
+                payload: {
+                    sessionId: this.id,
+                    agentId: this.agentId,
+                    steps: this.plan,
+                    updatedAt: this.planUpdatedAt,
+                },
+            });
+        }
+        catch (error) {
+            logger.error('推送计划更新失败:', error);
+        }
+    }
+    /**
+     * 构造「收尾时计划未完成」的提醒。
+     *
+     * 模型准备结束回复时，如果计划里还有未完成的步骤，说明它要么漏了同步，
+     * 要么还有事情没做完。返回提醒文案要求它先处理；无需提醒时返回 null。
+     */
+    buildPlanFinalizeReminder() {
+        if (this.plan.length === 0 || this.isPlanCompleted())
+            return null;
+        const unfinished = this.plan.filter(item => item.status !== 'completed');
+        const list = unfinished.map(item => `「${item.step}」`).join('、');
+        return `【计划未完成提醒】你准备结束本轮回复，但计划中仍有 ${unfinished.length} 个步骤未标记完成：${list}。
+`
+            + `请判断：如果这些步骤其实已经做完了，立即调用 updatePlan 把它们全部置为 completed；
+`
+            + `如果确实还没做，请继续完成剩余工作并同步计划状态。不要在计划未收尾的情况下结束回复。`;
+    }
+    /**
+     * 本轮结束时兜底处理未完成的计划。
+     *
+     * 即使提醒过模型，它仍可能不收尾。此时清空计划，避免 Desktop 的
+     * 进度圈永远停留在未完成状态。
+     */
+    async finalizePlanOnComplete() {
+        if (this.plan.length === 0 || this.isPlanCompleted())
+            return;
+        logger.warn(`会话 ${this.id} 结束时计划仍未完成，已自动清除计划以释放进度圈`);
+        this.clearPlan();
+        await this.notifyPlanUpdate();
+    }
     // 清除未读消息数并持久化
     clearUnreadCount() {
         this.unreadCount = 0;
@@ -645,6 +698,8 @@ class Session {
         let toolRound = 0;
         // 计划模式：距上次调用 updatePlan 已经过的工具轮次，用于在中间过程强制提醒模型同步进度
         let roundsSincePlanUpdate = 0;
+        // 计划模式：收尾时提醒模型补完计划的次数，避免反复提醒导致死循环
+        let planFinalizeNudges = 0;
         // 当前裁剪级别，遇到上下文超限时逐级加重
         let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
         /** 判断错误是否为上下文超限 */
@@ -999,7 +1054,25 @@ class Session {
                 return await processModelResponse();
             }
             else {
-                // ========== 没有工具调用，保存消息并结束 ==========
+                // ========== 没有工具调用，准备结束本轮 ==========
+                // 计划模式：计划还没收尾时，先提醒模型补完状态（最多提醒一次，避免死循环）
+                if (planFinalizeNudges < 1) {
+                    const finalizeReminder = this.buildPlanFinalizeReminder();
+                    if (finalizeReminder) {
+                        planFinalizeNudges++;
+                        messages.push({
+                            role: 'assistant',
+                            content: llmResult.content || llmResult.reasoningContent || '',
+                            attachments: []
+                        });
+                        messages.push({
+                            role: 'user',
+                            content: finalizeReminder,
+                            attachments: []
+                        });
+                        return await processModelResponse();
+                    }
+                }
                 if (llmResult.content || llmResult.reasoningContent) {
                     // 分段发送内容，每段约50个字符
                     const chunkSize = 1;
@@ -1056,6 +1129,8 @@ class Session {
                         logger.error('Error closing SSE connection:', e);
                     }
                 }
+                // 计划模式：本轮已结束，若计划仍未完成则兜底清除，避免进度圈残留
+                void this.finalizePlanOnComplete();
                 // 非当前查看的 session，助手回复完成后增加未读计数
                 (0, SessionManager_js_1.getSessionManager)(this.userId).onMessageComplete(this.id);
                 // 只在非 abort 的情况下保存（abort 由 stopGenerating 负责保存）

package/dist/services/tools/plan.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatePlanTool = void 0;
 const SessionManager_js_1 = require("../session/SessionManager.js");
-const WebSocketService_js_1 = require("../WebSocketService.js");
 const shared_1 = require("@myassis/shared");
 const logger = (0, shared_1.getLogger)('PlanTool');
 const VALID_STATUS = ['pending', 'in_progress', 'completed'];
@@ -84,15 +83,7 @@ exports.updatePlanTool = {
             }
             session.updatePlan(steps);
             // 推送计划进度到 Desktop，驱动底部进度圈刷新
-            WebSocketService_js_1.webSocketService.sendToUser(String(userId), {
-                type: 'plan_updated',
-                payload: {
-                    sessionId,
-                    agentId: session.agentId,
-                    steps: session.plan,
-                    updatedAt: session.planUpdatedAt,
-                },
-            });
+            await session.notifyPlanUpdate();
             const completed = steps.filter(s => s.status === 'completed').length;
             return {
                 success: true,

package/package.json

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