@myassis/gateway 1.0.101 → 1.0.102

package/dist/services/memory/ContextBuilder.js

@@ -4,6 +4,7 @@ exports.nextTrimLevel = exports.planTurnCompaction = exports.buildContext = expo
 const shared_1 = require("@myassis/shared");
 const index_js_1 = require("../../config/index.js");
 const ToolLedger_js_1 = require("./ToolLedger.js");
+const ToolCallArchive_js_1 = require("./ToolCallArchive.js");
 const logger = (0, shared_1.getLogger)('ContextBuilder');
 /**
  * 上下文构造与分级裁剪
@@ -165,12 +166,38 @@ function collectToolPairs(messages, from) {
     }
     return pairs;
 }
-/** 截断一个 pair 内的 content / reasoning_content / tool_calls.arguments */
-function clipPair(messages, pair, limit) {
+/** 为缺少 tool_call_id 的工具结果生成稳定的 archiveId（同一对消息在不同裁剪级别上结果一致，避免孤儿条目） */
+function stableArchiveId(sessionId, seed) {
+    let h = 2166136261;
+    const s = `${sessionId}:${seed}`;
+    for (let k = 0; k < s.length; k++) {
+        h ^= s.charCodeAt(k);
+        h = Math.imul(h, 16777619);
+    }
+    return `arc-${(h >>> 0).toString(36)}`;
+}
+/** 截断一个 pair 内的 content / reasoning_content / tool_calls.arguments，并在确有截断时归档完整内容 */
+function clipPair(messages, pair, limit, sessionId) {
     const head = messages[pair.start];
+    // 先收集每个工具调用的完整入参，避免裁剪覆盖后无法归档
+    const fullInputs = new Map();
+    if (Array.isArray(head?.tool_calls)) {
+        for (const tc of head.tool_calls) {
+            const id = tc?.id || tc?.function?.id;
+            const full = tc?.input ?? tc?.function?.arguments;
+            if (id && full != null) {
+                fullInputs.set(id, {
+                    input: typeof full === 'string' ? full : JSON.stringify(full),
+                    toolName: tc?.toolName || tc?.function?.name || 'unknown',
+                });
+            }
+        }
+    }
     head.content = clip(head.content, limit);
     head.reasoning_content = clip(head.reasoning_content, limit);
-    // 工具参数往往是上下文膨胀的主因（写文件 / patch 类调用）
+    // 工具参数往往是上下文膨胀的主因（写文件 / patch 类调用）；其完整入参会在下方
+    // 工具结果被截断时，与完整输出一并归档（见工具结果循环），此处不再单独归档，
+    // 以避免在「未真正裁剪」时产生无提示可引用的孤儿存档。
     if (Array.isArray(head.tool_calls)) {
         for (const tc of head.tool_calls) {
             tc.input = clipJsonArguments(tc.input, limit);
@@ -180,7 +207,18 @@ function clipPair(messages, pair, limit) {
         }
     }
     for (let i = pair.start + 1; i < pair.end; i++) {
-        messages[i].content = clip(messages[i].content, limit);
+        const msg = messages[i];
+        if (!msg || typeof msg.content !== 'string')
+            continue;
+        const original = msg.content;
+        if (original.length <= limit)
+            continue; // 仅当真正被截断才归档 + 提示
+        const archiveId = msg.tool_call_id
+            || stableArchiveId(sessionId ?? '', `tool:${i}:${original.slice(0, 32)}`);
+        const meta = msg.tool_call_id ? fullInputs.get(msg.tool_call_id) : undefined;
+        const toolName = msg.tool_call_name || meta?.toolName || 'unknown';
+        (0, ToolCallArchive_js_1.archiveToolCall)(sessionId ?? '', archiveId, toolName, meta?.input, original);
+        msg.content = clip(original, limit) + '\n' + (0, ToolCallArchive_js_1.formatDetailNote)(archiveId);
     }
 }
 /** 从工具参数中提取用于标识「这次调用做了什么」的关键字段 */
@@ -262,15 +300,25 @@ function skeletonOutput(content) {
  * 将一个工具调用对退化为骨架。
  *
  * 保留 assistant.tool_calls 与配对的 tool 消息（协议要求且模型需要看到调用事实），
- * 只把参数压成身份摘要、把输出压成一行结论。
+ * 只把参数压成身份摘要、把输出压成一行结论；并在输出确有精简时归档完整内容。
  */
-function skeletonizePair(messages, pair) {
+function skeletonizePair(messages, pair, sessionId) {
     const head = messages[pair.start];
     head.content = clip(head.content, SKELETON_OUTPUT_LIMIT);
     // 旧轮次的思维链对当前决策价值最低，直接丢弃
     delete head.reasoning_content;
-    if (Array.isArray(head.tool_calls)) {
+    // 收集完整入参用于归档（在工具结果被精简时与完整输出一并归档）
+    const fullInputs = new Map();
+    if (Array.isArray(head?.tool_calls)) {
         for (const tc of head.tool_calls) {
+            const id = tc?.id || tc?.function?.id;
+            const full = tc?.input ?? tc?.function?.arguments;
+            if (id && full != null) {
+                fullInputs.set(id, {
+                    input: typeof full === 'string' ? full : JSON.stringify(full),
+                    toolName: tc?.toolName || tc?.function?.name || 'unknown',
+                });
+            }
             tc.input = skeletonArguments(tc.input);
             if (tc.function) {
                 tc.function.arguments = skeletonArguments(tc.function.arguments);
@@ -278,16 +326,35 @@ function skeletonizePair(messages, pair) {
         }
     }
     for (let i = pair.start + 1; i < pair.end; i++) {
-        messages[i].content = skeletonOutput(messages[i].content);
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        const original = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content ?? '');
+        // 骨架化总是有损，但仅在原文较长时值得归档 + 提示
+        if (original.length <= SKELETON_OUTPUT_LIMIT) {
+            msg.content = skeletonOutput(original);
+            continue;
+        }
+        const archiveId = msg.tool_call_id
+            || stableArchiveId(sessionId ?? '', `tool:${i}:${original.slice(0, 32)}`);
+        const meta = msg.tool_call_id ? fullInputs.get(msg.tool_call_id) : undefined;
+        const toolName = msg.tool_call_name || meta?.toolName || 'unknown';
+        (0, ToolCallArchive_js_1.archiveToolCall)(sessionId ?? '', archiveId, toolName, meta?.input, original);
+        msg.content = skeletonOutput(original) + '\n' + (0, ToolCallArchive_js_1.formatDetailNote)(archiveId);
     }
 }
 /**
  * 把最早的工具调用对折叠进账本。
  *
  * 与已废弃的「直接丢弃」不同：调用事实不会消失，而是转成
- * 首条 system 消息中的「已完成操作」清单。
+ * 首条 system 消息中的「已完成操作」清单。被折叠工具调用的完整内容会归档，
+ * 并在账本末尾附上 detailTool 调阅提示。
+ *
+ * 注意：调用本函数时 `working` 已被本级别的骨架化/截断先行处理，因此归档用的
+ * 完整内容必须取自 `originals`（buildContext 入参的未改动副本），否则会存下已被
+ * 压缩过的内容而非原文。
  */
-function foldPairsToLedger(messages, pairs, foldCount, protectFrom) {
+function foldPairsToLedger(messages, originals, pairs, foldCount, protectFrom, sessionId) {
     if (foldCount <= 0)
         return messages;
     const foldIndexes = new Set();
@@ -298,18 +365,56 @@ function foldPairsToLedger(messages, pairs, foldCount, protectFrom) {
             folded.push(messages[j]);
         }
     }
+    // 用 originals 收集折叠区间内工具调用的【完整】入参，供归档使用
+    const fullInputs = new Map();
+    for (const idx of foldIndexes) {
+        const m = originals[idx];
+        if (m?.role === 'assistant' && Array.isArray(m.tool_calls)) {
+            for (const tc of m.tool_calls) {
+                const id = tc?.id || tc?.function?.id;
+                const full = tc?.input ?? tc?.function?.arguments;
+                if (id && full != null) {
+                    fullInputs.set(id, {
+                        input: typeof full === 'string' ? full : JSON.stringify(full),
+                        toolName: tc?.toolName || tc?.function?.name || 'unknown',
+                    });
+                }
+            }
+        }
+    }
+    // 归档被折叠工具调用的【完整】内容（取自 originals），并在账本末尾列出可调阅的 archiveId
+    const ledgerLines = [];
+    for (const idx of foldIndexes) {
+        const m = messages[idx];
+        const orig = originals[idx];
+        if (m?.role !== 'tool')
+            continue;
+        const original = typeof orig?.content === 'string' ? orig.content : JSON.stringify(orig?.content ?? '');
+        if (original.length <= SKELETON_OUTPUT_LIMIT)
+            continue;
+        const archiveId = m.tool_call_id
+            || stableArchiveId(sessionId ?? '', `fold:${m.seq ?? ''}:${original.slice(0, 32)}`);
+        const meta = m.tool_call_id ? fullInputs.get(m.tool_call_id) : undefined;
+        const toolName = m.tool_call_name || meta?.toolName || 'unknown';
+        (0, ToolCallArchive_js_1.archiveToolCall)(sessionId ?? '', archiveId, toolName, meta?.input, original);
+        ledgerLines.push(`- ${toolName}（完整内容请调阅工具 detailTool 查看，archiveId: "${archiveId}"）`);
+    }
     const ledger = (0, ToolLedger_js_1.renderRequestLedger)(folded);
+    let ledgerContent = ledger;
+    if (ledgerLines.length > 0) {
+        ledgerContent = `${ledger}\n\n【已折叠工具调用存档】以下调用已被折叠为账本，其完整入参/输出可用 detailTool 调阅：\n${ledgerLines.join('\n')}`;
+    }
     const kept = messages.filter((_, index) => !foldIndexes.has(index));
-    if (!ledger)
+    if (!ledgerContent)
         return kept;
     // 并入首条 system 消息：部分厂商只允许 system 位于首位
     if (kept[0]?.role === 'system' && typeof kept[0].content === 'string') {
-        kept[0] = { ...kept[0], content: `${kept[0].content}\n\n${ledger}` };
+        kept[0] = { ...kept[0], content: `${kept[0].content}\n\n${ledgerContent}` };
     }
     else {
         kept.splice(Math.min(protectFrom, kept.length), 0, {
             role: 'assistant',
-            content: ledger,
+            content: ledgerContent,
             attachments: [],
         });
     }
@@ -341,8 +446,9 @@ function degradeAttachments(messages, keepLastN) {
  * @param protectFrom 该下标之前的消息视为“历史/摘要”，工具对裁剪只作用于其后
  * @param maxChars   字符预算
  * @param minLevel   最低裁剪级别（用于超限重试时强制加重）
+ * @param sessionId  会话标识，用于裁剪时归档完整内容（缺省时不归档）
  */
-function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.contextMaxChars, minLevel = TrimLevel.OldToolPayload) {
+function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.contextMaxChars, minLevel = TrimLevel.OldToolPayload, sessionId) {
     let working = messages.map(cloneMessage);
     let level = TrimLevel.None;
     const overBudget = () => estimateChars(working) > maxChars;
@@ -357,7 +463,7 @@ function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.con
         if (target >= TrimLevel.SkeletonOldCalls) {
             const skeletonUntil = Math.max(0, pairs.length - index_js_1.appConfig.minToolPairKeep);
             for (let i = 0; i < skeletonUntil; i++) {
-                skeletonizePair(working, pairs[i]);
+                skeletonizePair(working, pairs[i], sessionId);
             }
         }
         // 2) 截断超出 keep 轮的旧工具负载（骨架化过的 pair 已经很小，重复处理无害）
@@ -366,7 +472,7 @@ function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.con
             ? Math.max(200, Math.floor(index_js_1.appConfig.oldToolContentLimit / 2))
             : index_js_1.appConfig.oldToolContentLimit;
         for (let i = 0; i < clipUntil; i++) {
-            clipPair(working, pairs[i], argLimit);
+            clipPair(working, pairs[i], argLimit, sessionId);
         }
         // 3) 降级旧附件
         if (target >= TrimLevel.Aggressive) {
@@ -374,7 +480,7 @@ function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.con
         }
         // 4) 最后手段：折叠为账本（调用事实保留在 system 清单中）
         if (target >= TrimLevel.FoldToLedger && pairs.length > index_js_1.appConfig.minToolPairKeep) {
-            working = foldPairsToLedger(working, pairs, pairs.length - index_js_1.appConfig.minToolPairKeep, protectFrom);
+            working = foldPairsToLedger(working, messages, pairs, pairs.length - index_js_1.appConfig.minToolPairKeep, protectFrom, sessionId);
         }
     };
     for (const target of [minLevel, TrimLevel.Aggressive, TrimLevel.SkeletonOldCalls, TrimLevel.FoldToLedger]) {

package/dist/services/memory/ToolCallArchive.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDetailNote = exports.clearSessionArchive = exports.getArchivedToolCall = exports.archiveToolCall = void 0;
+const shared_1 = require("@myassis/shared");
+/**
+ * 工具调用完整内容存档
+ *
+ * 背景：ContextBuilder 在上下文裁剪（截断 / 骨架化 / 折叠为账本）时会丢弃
+ * 工具调用的「完整内容」，只保留有损的事实。为了让模型在需要时能取回被丢弃的
+ * 原文，本模块在裁剪发生时把「完整入参 + 完整输出」按 archiveId 保存起来，
+ * 并在裁剪后的内容中追加「完整内容请调阅工具 detailTool 查看」的提示。
+ *
+ * 设计要点：
+ * - 以 sessionId -> (archiveId -> entry) 两级 Map 组织，detailTool 按会话隔离读取。
+ * - archiveId 默认取工具调用的 tool_call_id（天然稳定且唯一），因此多次裁剪同一
+ *   调用只会更新同一条记录（幂等合并），不会产生孤儿条目。
+ * - 仅在裁剪「真实发生」（原文超过阈值）时才写入，避免无谓占用内存。
+ */
+const logger = (0, shared_1.getLogger)('ToolCallArchive');
+/** sessionId -> (archiveId -> entry) */
+const store = new Map();
+/** 单会话最多保留的存档条数，超出后丢弃最早插入者 */
+const MAX_PER_SESSION = 1000;
+/**
+ * 保存 / 合并一次工具调用的完整内容。
+ *
+ * 以 archiveId 为键做幂等合并：多次裁剪同一调用只会更新同一条记录，
+ * 因此即便 buildContext 在多个 trim level 上尝试裁剪，也不会产生孤儿条目。
+ */
+function archiveToolCall(sessionId, archiveId, toolName, input, output) {
+    if (!sessionId || !archiveId)
+        return;
+    let sessionMap = store.get(sessionId);
+    if (!sessionMap) {
+        sessionMap = new Map();
+        store.set(sessionId, sessionMap);
+    }
+    const existing = sessionMap.get(archiveId);
+    sessionMap.set(archiveId, {
+        archiveId,
+        sessionId,
+        toolName: toolName || existing?.toolName || 'unknown',
+        input: input && input.length ? input : existing?.input || '',
+        output: output && output.length ? output : existing?.output || '',
+        archivedAt: Date.now(),
+    });
+    // 容量保护：超出后丢弃最早插入的条目
+    if (sessionMap.size > MAX_PER_SESSION) {
+        const oldest = sessionMap.keys().next().value;
+        if (oldest !== undefined)
+            sessionMap.delete(oldest);
+    }
+}
+exports.archiveToolCall = archiveToolCall;
+/** 按会话 + archiveId 取回被保存的完整内容 */
+function getArchivedToolCall(sessionId, archiveId) {
+    return store.get(sessionId)?.get(archiveId);
+}
+exports.getArchivedToolCall = getArchivedToolCall;
+/** 会话结束时清理，避免内存常驻 */
+function clearSessionArchive(sessionId) {
+    if (store.delete(sessionId)) {
+        logger.debug(`已清理会话 ${sessionId} 的工具调用存档`);
+    }
+}
+exports.clearSessionArchive = clearSessionArchive;
+/** 生成裁剪提示，引导模型通过 detailTool 调阅完整内容 */
+function formatDetailNote(archiveId) {
+    return `完整内容请调阅工具 detailTool 查看（archiveId: "${archiveId}"）`;
+}
+exports.formatDetailNote = formatDetailNote;

package/dist/services/session/Session.js

@@ -1020,7 +1020,7 @@ class Session {
             while (true) {
                 // 分级裁剪只截断旧工具负载（保留最近 turnCompactKeepPairs 轮完整内容），
                 // 不主动做摘要压缩；只有模型返回上下文超限错误时才在 catch 中触发轮内压缩。
-                const built = (0, ContextBuilder_js_1.buildContext)(messages, messagesLength, effectiveContextMaxChars, trimLevel);
+                const built = (0, ContextBuilder_js_1.buildContext)(messages, messagesLength, effectiveContextMaxChars, trimLevel, this.id);
                 if (built.trimmed) {
                     logger.debug(`上下文裁剪: level=${built.level} chars=${built.chars}`);
                 }

package/dist/services/session/SessionManager.js

@@ -7,6 +7,7 @@ const logger = (0, shared_1.getLogger)('SessionManager');
 const SessionStore_js_1 = require("./SessionStore.js");
 const authStore_js_1 = require("../../stores/authStore.js");
 const Session_js_1 = require("./Session.js");
+const ToolCallArchive_js_1 = require("../memory/ToolCallArchive.js");
 /**
  * SessionManager - Business logic layer
  * Manages sessions in memory
@@ -157,6 +158,7 @@ class SessionManager {
             SessionStore_js_1.sessionStore.deleteSession(sessionId);
         });
         this.sessions.delete(sessionId);
+        (0, ToolCallArchive_js_1.clearSessionArchive)(sessionId);
         logger.info(`Deleted session ${sessionId}`);
         return true;
     }

package/dist/services/tools/detailTool.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detailTool = void 0;
+const ToolCallArchive_js_1 = require("../memory/ToolCallArchive.js");
+/**
+ * detailTool —— 调阅被上下文裁剪的工具调用的完整内容。
+ *
+ * 当某次工具调用的结果 / 参数因上下文裁剪被压缩时，上下文里会附带形如
+ * 「完整内容请调阅工具 detailTool 查看（archiveId: "xxx"）」的提示。
+ * 传入对应的 archiveId 即可取回该次调用的完整入参与输出。
+ */
+exports.detailTool = {
+    name: 'detailTool',
+    description: '查看此前因上下文裁剪（截断 / 骨架化 / 折叠为账本）而被压缩的工具调用的完整内容。' +
+        '上下文中被裁剪的工具结果会附带「完整内容请调阅工具 detailTool 查看（archiveId: "xxx"）」的提示，' +
+        '传入其中的 archiveId 即可取回该次调用的完整入参（arguments）与输出（content）。仅在确实需要回看被裁剪内容时使用。',
+    parameters: {
+        type: 'object',
+        properties: {
+            archiveId: {
+                type: 'string',
+                description: '裁剪提示中给出的 archiveId，用于定位被保存的完整工具调用内容',
+            },
+        },
+        required: ['archiveId'],
+    },
+    handler: async (args, sessionId) => {
+        try {
+            const { archiveId } = args;
+            if (!archiveId || typeof archiveId !== 'string') {
+                return { success: false, errorMessage: '缺少 archiveId 参数' };
+            }
+            const entry = (0, ToolCallArchive_js_1.getArchivedToolCall)(String(sessionId || ''), archiveId);
+            if (!entry) {
+                return {
+                    success: false,
+                    errorMessage: `未找到 archiveId="${archiveId}" 对应的工具调用存档。` +
+                        '该存档可能来自更早的进程或会话，或该次调用并未被裁剪。',
+                };
+            }
+            const output = JSON.stringify({
+                toolName: entry.toolName,
+                archiveId: entry.archiveId,
+                archivedAt: entry.archivedAt,
+                input: entry.input || '',
+                output: entry.output || '',
+            }, null, 2);
+            return { success: true, output };
+        }
+        catch (error) {
+            return { success: false, errorMessage: `调阅工具调用存档失败: ${error?.message}` };
+        }
+    },
+};

package/dist/services/tools/index.js

@@ -38,10 +38,11 @@ const webFetch_js_1 = require("./webFetch.js");
 const sessionsSpawn_js_1 = require("./sessionsSpawn.js");
 const setSessionTitle_js_1 = require("./setSessionTitle.js");
 const plan_js_1 = require("./plan.js");
+const detailTool_js_1 = require("./detailTool.js");
 exports.tools = [
     search_js_1.searchTool, calculator_js_1.calculatorTool, screenshot_js_1.screenshotTool, keyboard_js_1.keyboardTool, mouse_js_1.mouseTool,
     skill_js_1.skillTool, exec_js_1.execTool, task_js_1.taskTool, model_js_1.modelTool, fetch_js_1.fetchTool,
-    edit_js_1.editTool, webFetch_js_1.webFetchTool, file_js_1.fileTool, sessionsSpawn_js_1.sessionsSpawnTool, setSessionTitle_js_1.setSessionTitleTool, plan_js_1.updatePlanTool
+    edit_js_1.editTool, webFetch_js_1.webFetchTool, file_js_1.fileTool, sessionsSpawn_js_1.sessionsSpawnTool, setSessionTitle_js_1.setSessionTitleTool, plan_js_1.updatePlanTool, detailTool_js_1.detailTool
 ];
 function getToolByName(name) {
     return exports.tools.find(tool => tool.name === name);

package/package.json

@@ -1,95 +1,95 @@
-{
-  "name": "@myassis/gateway",
-  "version": "1.0.101",
-  "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
-  "main": "dist/index.js",
-  "bin": {
-    "myassis-gateway": "dist/index.js",
-    "gateway": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "LICENSE",
-    "migrations"
-  ],
-  "exports": {
-    ".": {
-      "require": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "start": "node dist/index.js",
-    "build": "tsc --skipLibCheck",
-    "postbuild": "node scripts/add-shebang.js && npx tsc-alias",
-    "pkg:win": "node scripts/pkg-build-win.js node24-win-x64 myassis-gateway-win.exe",
-    "pkg:linux": "npx @yao-pkg/pkg . --targets node24-linux-x64 --output myassis-gateway-linux",
-    "pkg:all": "npm run pkg:win && npm run pkg:linux",
-    "pkg:linux-analyze": "npx @yao-pkg/pkg . --targets node24-linux-x64 --output myassis-gateway-linux --public-packages got --debug",
-    "test": "jest"
-  },
-  "keywords": [
-    "myassis",
-    "gateway",
-    "ai",
-    "local-ai",
-    "websocket",
-    "service"
-  ],
-  "author": "duzhengjie",
-  "dependencies": {
-    "@myassis/shared": "1.0.19",
-    "@nut-tree/nut-js": "^4.2.0",
-    "axios": "^1.15.2",
-    "bcryptjs": "^2.4.3",
-    "better-sqlite3": "12.9.0",
-    "cheerio": "^1.2.0",
-    "compression": "^1.7.4",
-    "cors": "^2.8.5",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "helmet": "^7.1.0",
-    "https-proxy-agent": "^9.0.0",
-    "jsonwebtoken": "^9.0.2",
-    "multer": "^2.1.1",
-    "screenshot-desktop": "^1.15.4",
-    "undici": "^8.2.0",
-    "uuid": "^9.0.1",
-    "ws": "^8.20.0"
-  },
-  "devDependencies": {
-    "@types/bcryptjs": "^2.4.6",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
-    "@types/jsonwebtoken": "^9.0.6",
-    "@types/multer": "^1.4.11",
-    "@types/node": "^20.11.0",
-    "@types/uuid": "^9.0.8",
-    "@types/ws": "^8.5.10",
-    "@yao-pkg/pkg": "^6.20.0",
-    "tsc-alias": "^1.8.10",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3",
-    "@yao-pkg/pkg-fetch": "3.6.3"
-  },
-  "pkg": {
-    "scripts": [
-      "dist/index.js"
-    ],
-    "assets": [
-      "dist/**/*",
-      "migrations/**/*",
-      "README*",
-      "node_modules/better-sqlite3/build/Release/better_sqlite3.node",
-      "node_modules/.pnpm/@nut-tree+libnut-linux@2.7.1/node_modules/@nut-tree/libnut-linux/build/Release/libnut.node",
-      "node_modules/.pnpm/@nut-tree+libnut-win32@2.7.1/node_modules/@nut-tree/libnut-win32/build/Release/libnut.node",
-      "nssm.exe"
-    ],
-    "targets": [
-      "node24-win-x64",
-      "node24-linux-x64"
-    ]
-  }
-}
+{
+  "name": "@myassis/gateway",
+  "version": "1.0.102",
+  "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
+  "main": "dist/index.js",
+  "bin": {
+    "myassis-gateway": "dist/index.js",
+    "gateway": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    "migrations"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "build": "tsc --skipLibCheck",
+    "postbuild": "node scripts/add-shebang.js && npx tsc-alias",
+    "pkg:win": "node scripts/pkg-build-win.js node24-win-x64 myassis-gateway-win.exe",
+    "pkg:linux": "npx @yao-pkg/pkg . --targets node24-linux-x64 --output myassis-gateway-linux",
+    "pkg:all": "npm run pkg:win && npm run pkg:linux",
+    "pkg:linux-analyze": "npx @yao-pkg/pkg . --targets node24-linux-x64 --output myassis-gateway-linux --public-packages got --debug",
+    "test": "jest"
+  },
+  "keywords": [
+    "myassis",
+    "gateway",
+    "ai",
+    "local-ai",
+    "websocket",
+    "service"
+  ],
+  "author": "duzhengjie",
+  "dependencies": {
+    "@myassis/shared": "1.0.19",
+    "@nut-tree/nut-js": "^4.2.0",
+    "axios": "^1.15.2",
+    "bcryptjs": "^2.4.3",
+    "better-sqlite3": "12.9.0",
+    "cheerio": "^1.2.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "helmet": "^7.1.0",
+    "https-proxy-agent": "^9.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.1.1",
+    "screenshot-desktop": "^1.15.4",
+    "undici": "^8.2.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/multer": "^1.4.11",
+    "@types/node": "^20.11.0",
+    "@types/uuid": "^9.0.8",
+    "@types/ws": "^8.5.10",
+    "@yao-pkg/pkg": "^6.20.0",
+    "tsc-alias": "^1.8.10",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "@yao-pkg/pkg-fetch": "3.6.3"
+  },
+  "pkg": {
+    "scripts": [
+      "dist/index.js"
+    ],
+    "assets": [
+      "dist/**/*",
+      "migrations/**/*",
+      "README*",
+      "node_modules/better-sqlite3/build/Release/better_sqlite3.node",
+      "node_modules/.pnpm/@nut-tree+libnut-linux@2.7.1/node_modules/@nut-tree/libnut-linux/build/Release/libnut.node",
+      "node_modules/.pnpm/@nut-tree+libnut-win32@2.7.1/node_modules/@nut-tree/libnut-win32/build/Release/libnut.node",
+      "nssm.exe"
+    ],
+    "targets": [
+      "node24-win-x64",
+      "node24-linux-x64"
+    ]
+  }
+}

package/scripts/pkg-build-win.js

@@ -1,50 +1,64 @@
-#!/usr/bin/env node
-// pkg-build-win.js - Windows pkg build using PKG_CACHE_PATH
-// Points to ~/.pkg-cache which contains the correct v3.6 patched binary (40.6 MB, hash matches)
-'use strict';
-const { spawn } = require('child_process');
-const path = require('path');
-const os = require('os');
-const fs = require('fs');
-
-const TARGET = process.argv[2] || 'node18-win-x64';
-const OUTPUT = process.argv[3] || 'myassis-gateway-win.exe';
-
-const CACHE_DIR = path.join(os.homedir(), '.pkg-cache');
-const V36_BINARY = path.join(CACHE_DIR, 'v3.6', 'fetched-v18.20.8-win-x64');
-const PKG_BIN = path.resolve(__dirname, '../node_modules/@yao-pkg/pkg/lib-es5/bin.js');
-
-function log(msg) { console.error('[pkg-build] ' + msg); }
-
-async function main() {
-    log(`Building for ${TARGET}`);
-    log(`Output: ${OUTPUT}`);
-
-    // Verify v3.6 binary exists
-    if (!fs.existsSync(V36_BINARY)) {
-        log(`ERROR: Patched binary not found at ${V36_BINARY}`);
-        log('Please run: node node_modules/@yao-pkg/pkg/lib-es5/bin.js --targets node18-win-x64 first');
-        process.exit(1);
-    }
-    const size = (fs.statSync(V36_BINARY).size / 1024 / 1024).toFixed(1);
-    log(`Using patched binary: ${V36_BINARY} (${size} MB)`);
-
-    // Use PKG_CACHE_PATH so pkg-fetch finds the correct v3.6 binary by hash
-    const env = { ...process.env };
-    delete env.PKG_NODE_PATH;  // MUST NOT use PKG_NODE_PATH - it bypasses placeholders check
-    env.PKG_CACHE_PATH = CACHE_DIR;
-    log(`PKG_CACHE_PATH=${CACHE_DIR}`);
-
-    log('Starting pkg...');
-    return new Promise((resolve) => {
-        const child = spawn(process.execPath, [PKG_BIN, '.', '--targets', TARGET, '--output', OUTPUT], {
-            cwd: path.resolve(__dirname, '..'),
-            env,
-            stdio: 'inherit'
-        });
-        child.on('exit', (code) => process.exit(code || 0));
-        child.on('error', (e) => { log('Spawn error: ' + e.message); process.exit(1); });
-    });
-}
-
-main().catch(e => { console.error('[pkg-build] Fatal:', e.message); process.exit(1); });
+#!/usr/bin/env node
+// pkg-build-win.js - Windows pkg build using PKG_CACHE_PATH
+// Points to ~/.pkg-cache which contains the correct v3.6 patched binary (40.6 MB, hash matches)
+'use strict';
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const TARGET = process.argv[2] || 'node18-win-x64';
+const OUTPUT = process.argv[3] || 'myassis-gateway-win.exe';
+
+const CACHE_DIR = path.join(os.homedir(), '.pkg-cache');
+const PKG_BIN = path.resolve(__dirname, '../node_modules/@yao-pkg/pkg/lib-es5/bin.js');
+
+function log(msg) { console.error('[pkg-build] ' + msg); }
+
+/** 根据 target (如 node24-win-x64) 在缓存目录中找到匹配的二进制 */
+function findCachedBinary(target) {
+  const m = target.match(/^node(\d+)-(.+)$/);
+  if (!m) return null;
+  const [, major, plat] = m;
+  const v36dir = path.join(CACHE_DIR, 'v3.6');
+  if (!fs.existsSync(v36dir)) return null;
+  const candidates = fs.readdirSync(v36dir)
+    .filter(f => new RegExp(`^fetched-v${major}\\.\\d+\\.\\d+-${plat}$`).test(f))
+    .sort()
+    .reverse();
+  return candidates.length > 0 ? path.join(v36dir, candidates[0]) : null;
+}
+
+async function main() {
+    log(`Building for ${TARGET}`);
+    log(`Output: ${OUTPUT}`);
+
+    // Verify cached binary exists (dynamically match by target)
+    const cachedBinary = findCachedBinary(TARGET);
+    if (!cachedBinary) {
+        log(`ERROR: No cached binary found for target ${TARGET} in ${CACHE_DIR}`);
+        log(`Please run: node node_modules/@yao-pkg/pkg/lib-es5/bin.js --targets ${TARGET} first`);
+        process.exit(1);
+    }
+    const size = (fs.statSync(cachedBinary).size / 1024 / 1024).toFixed(1);
+    log(`Using cached binary: ${cachedBinary} (${size} MB)`);
+
+    // Use PKG_CACHE_PATH so pkg-fetch finds the correct v3.6 binary by hash
+    const env = { ...process.env };
+    delete env.PKG_NODE_PATH;  // MUST NOT use PKG_NODE_PATH - it bypasses placeholders check
+    env.PKG_CACHE_PATH = CACHE_DIR;
+    log(`PKG_CACHE_PATH=${CACHE_DIR}`);
+
+    log('Starting pkg...');
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [PKG_BIN, '.', '--targets', TARGET, '--output', OUTPUT], {
+            cwd: path.resolve(__dirname, '..'),
+            env,
+            stdio: 'inherit'
+        });
+        child.on('exit', (code) => process.exit(code || 0));
+        child.on('error', (e) => { log('Spawn error: ' + e.message); process.exit(1); });
+    });
+}
+
+main().catch(e => { console.error('[pkg-build] Fatal:', e.message); process.exit(1); });