@myassis/gateway 1.0.84 → 1.0.86

package/dist/routes/agent.js

@@ -366,6 +366,33 @@ router.get('/sessions/:sessionId/messages', ensureAgentManager, async (req, res)
         res.status(500).json({ success: false, error: 'Failed to get messages' });
     }
 });
+/**
+ * GET /api/agent/sessions/:sessionId/messages/sync?sinceSeq=N
+ *
+ * 断线重连后的增量补拉。WebSocket 重连退避最长 30s，这期间的会话流
+ * 事件无法补发，不拉一次就会永久分歧。只回 seq 大于终端游标的部分，
+ * 同时回完整 id 列表用于剪除离线期间被删掉的消息。
+ *
+ * 注意路径要注册在 /messages/:messageId 类路由之前，否则 sync 会被当成 messageId。
+ */
+router.get('/sessions/:sessionId/messages/sync', ensureAgentManager, async (req, res) => {
+    try {
+        const userId = req.userId;
+        const { sessionId } = req.params;
+        const sinceSeq = parseInt(req.query.sinceSeq, 10) || 0;
+        const session = (0, index_js_2.getSessionManager)(userId).getSession(sessionId);
+        if (!session) {
+            return res.status(404).json({ success: false, error: 'Session not found' });
+        }
+        session.loadMessages();
+        const result = session.getMessagesChangedSince(sinceSeq);
+        return res.json({ success: true, data: result });
+    }
+    catch (error) {
+        logger.error(`Sync messages error: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to sync messages' });
+    }
+});
 /**
  * DELETE /api/agent/sessions/:sessionId/messages/:messageId
  * Delete a specific message
@@ -488,7 +515,9 @@ router.post('/sessions/:sessionId/reset', async (req, res) => {
     try {
         const userId = req.userId;
         const { sessionId } = req.params;
-        const stopped = (0, index_js_2.getSessionManager)(userId).stopSession(sessionId);
+        // 终端标识：停止事件广播给其他终端时排除发起端
+        const clientId = req.body?.clientId || req.headers['x-client-id'] || undefined;
+        const stopped = (0, index_js_2.getSessionManager)(userId).stopSession(sessionId, clientId);
         res.json({ success: true, data: { stopped } });
     }
     catch (error) {

package/dist/services/ServiceManager.js

@@ -12,6 +12,7 @@ const axios_1 = __importDefault(require("axios"));
 const shared_1 = require("@myassis/shared");
 const os_1 = __importDefault(require("os"));
 const net_1 = __importDefault(require("net"));
+const index_js_1 = require("../config/index.js");
 const logger = (0, shared_1.getLogger)('ServiceManager');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 exports.SERVICE_NAME = 'myassis-gateway';
@@ -71,6 +72,51 @@ function getGatewayExePath() {
     const nodeExec = getNodeExec();
     return nodeExec;
 }
+/**
+ * 探测 Gateway 是否真的在提供服务。
+ *
+ * 仅看 PID 是不够的：启错的进程（比如裸 node REPL）照样存活、PID 也写入了，
+ * start 会报「启动成功」而客户端根本连不上。这里真实请求一次 /health。
+ */
+async function isGatewayServing(timeoutMs = 1500) {
+    try {
+        const res = await axios_1.default.get(`http://127.0.0.1:${index_js_1.appConfig.port}/health`, {
+            timeout: timeoutMs,
+            // 只要能返回 HTTP 响应就说明服务已监听，状态码不重要
+            validateStatus: () => true,
+        });
+        return !!res;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gateway 启动需要的命令行参数。
+ *
+ * 打包为 exe 时 exe 本身就是程序，无需参数；
+ * npm install -g 安装时 exe 是 node.exe，必须把 dist/index.js 传给它——
+ * 否则启动的是一个没有脚本的裸 node（REPL），进程存在、PID 也写了，
+ * 但根本没有监听端口，表现为「start 报成功但连不上」。
+ */
+function getGatewayArgs() {
+    if (isPackagedExe())
+        return [];
+    const script = getServiceScript();
+    return script ? [script] : [];
+}
+/**
+ * Gateway 运行的工作目录。
+ *
+ * 非打包模式下不能用 node.exe 所在目录（例如 C:\Program Files\nodejs），
+ * 否则相对路径资源与数据目录定位都会错；应该用包目录。
+ */
+function getGatewayWorkDir() {
+    if (isPackagedExe())
+        return path_1.default.dirname(process.execPath);
+    const script = getServiceScript();
+    return script ? path_1.default.dirname(path_1.default.dirname(script)) : path_1.default.dirname(process.execPath);
+}
 /**
  * 检查 Gateway 进程是否在运行
  */
@@ -281,9 +327,15 @@ async function stopGatewayProcess() {
 function writeGatewayLauncherScript(exePath, scriptPath, workDir) {
     // 写入 BOM + UTF-8 内容
     const bs = (p) => p.replace(/\\/g, '\\\\');
+    // npm 安装模式下 exe 是 node.exe，必须带上入口脚本才能真正启动服务
+    const launchArgs = getGatewayArgs();
+    const argListLiteral = launchArgs.length > 0
+        ? '@(' + launchArgs.map(a => `'${bs(a)}'`).join(', ') + ')'
+        : '@()';
     const content = [
         "$ErrorActionPreference = 'Continue'",
         `$exe = '${bs(exePath)}'`,
+        `$gatewayArgs = ${argListLiteral}`,
         `$workDir = '${bs(workDir)}'`,
         `$pidFile = '${bs(GATEWAY_PID_FILE)}'`,
         `$stopFlag = '${bs(GATEWAY_STOP_FLAG_FILE)}'`,
@@ -306,7 +358,13 @@ function writeGatewayLauncherScript(exePath, scriptPath, workDir) {
         '  # 1) 管道缓冲区填满后 gateway 卡死（4KB 缓冲区无人读取）',
         '  # 2) 父 PS 句柄继承导致 gateway 写 stdout 崩溃',
         '  try {',
-        '    $proc = Start-Process -FilePath $exe -WorkingDirectory $workDir -WindowStyle Hidden -PassThru -ErrorAction Stop',
+        '    # 生产模式标记：main.ts 靠它判定是否重定向 stdout 到日志文件',
+        "    $env:NODE_ENV = 'production'",
+        '    if ($gatewayArgs.Count -gt 0) {',
+        '      $proc = Start-Process -FilePath $exe -ArgumentList $gatewayArgs -WorkingDirectory $workDir -WindowStyle Hidden -PassThru -ErrorAction Stop',
+        '    } else {',
+        '      $proc = Start-Process -FilePath $exe -WorkingDirectory $workDir -WindowStyle Hidden -PassThru -ErrorAction Stop',
+        '    }',
         '    if ($proc -and $proc.Id) {',
         '      $proc.Id.ToString() | Out-File -FilePath $pidFile -Encoding UTF8',
         "      Write-Log \"Gateway 已启动，PID=$($proc.Id)\"",
@@ -427,7 +485,7 @@ async function unregisterRunKey() {
 // ─── Windows 用户级实现 ─────────────────────────────────────
 async function installWindows() {
     const exe = getGatewayExePath();
-    const workDir = path_1.default.dirname(exe);
+    const workDir = getGatewayWorkDir();
     logger.info(`installWindows: exe=${exe}, workDir=${workDir}`);
     const { installed } = await queryServiceWindows();
     if (installed)
@@ -469,7 +527,7 @@ async function uninstallWindows() {
     }
 }
 async function startServiceWindows() {
-    if (isGatewayRunning()) {
+    if (isGatewayRunning() && await isGatewayServing()) {
         return { success: true, message: 'Gateway 已在运行' };
     }
     try {
@@ -479,20 +537,32 @@ async function startServiceWindows() {
         }
         catch { /* ignore */ }
         const exe = getGatewayExePath();
-        const workDir = path_1.default.dirname(exe);
+        const workDir = getGatewayWorkDir();
         if (!fs_1.default.existsSync(GATEWAY_LAUNCHER_FILE)) {
             writeGatewayLauncherScript(exe, GATEWAY_LAUNCHER_FILE, workDir);
         }
         // 使用 Start-Process 在后台启动守护脚本（-WindowStyle Hidden 隐藏窗口）
         // 守护脚本会持续运行并监控 gateway 进程，异常时自动重启
         await execAsync(`powershell -NoProfile -ExecutionPolicy Bypass -Command "Start-Process -FilePath powershell.exe -ArgumentList '-NoProfile','-ExecutionPolicy','Bypass','-WindowStyle','Hidden','-File','${GATEWAY_LAUNCHER_FILE}' -WindowStyle Hidden"`, { timeout: 5000, windowsHide: true });
-        const maxWait = 8000;
+        // 等到真正能接请求为止：进程起来到监听端口之间还要跑迁移、加载模型等，
+        // 只等 PID 会在服务就绪前就报成功，紧跟着的连接就会失败。
+        const maxWait = 30000;
         const start = Date.now();
-        while (!isGatewayRunning() && Date.now() - start < maxWait) {
+        let processSeen = false;
+        while (Date.now() - start < maxWait) {
+            if (isGatewayRunning()) {
+                processSeen = true;
+                if (await isGatewayServing()) {
+                    return { success: true, message: 'Gateway 启动成功（已启用异常自动重启）' };
+                }
+            }
             await new Promise(r => setTimeout(r, 500));
         }
-        if (isGatewayRunning()) {
-            return { success: true, message: 'Gateway 启动成功（已启用异常自动重启）' };
+        if (processSeen) {
+            return {
+                success: false,
+                message: `Gateway 进程已启动但 ${index_js_1.appConfig.port} 端口未就绪，请查看日志: ${path_1.default.join(GATEWAY_DATA_DIR, 'gateway-daemon.log')}`,
+            };
         }
         return { success: false, message: 'Gateway 进程未能启动，请检查日志' };
     }
@@ -719,7 +789,7 @@ async function ensureAutoStartHealthy() {
         logger.warn(`检测到 Run key 不健康，自动修复。current='${currentValue}'`);
         // 4) 重写 launcher 脚本到新路径
         const exe = getGatewayExePath();
-        const workDir = path_1.default.dirname(exe);
+        const workDir = getGatewayWorkDir();
         writeGatewayLauncherScript(exe, GATEWAY_LAUNCHER_FILE, workDir);
         // 5) 重新注册完整 powershell 命令行
         await registerRunKey(GATEWAY_LAUNCHER_FILE);

package/dist/services/memory/MemoryManager.js

@@ -64,12 +64,28 @@ class MemoryManager {
     config = DEFAULT_CONFIG;
     childAgent;
     res;
+    mirror;
     summaryModels = null;
-    constructor(session, signal, childAgent, res = null) {
+    constructor(session, signal, childAgent, res = null, mirror = null) {
         this.session = session;
         this.signal = signal;
         this.childAgent = childAgent;
         this.res = res;
+        this.mirror = mirror;
+    }
+    /**
+     * 发送 SSE 事件：先镜像给该用户的其他终端，再写回发起端。
+     *
+     * 旧实现只写 res，导致「上下文压缩中」等事件无法多终端同步。
+     */
+    emitSSE(data) {
+        try {
+            this.mirror?.(data);
+        }
+        catch {
+            // 镜像失败不影响发起端
+        }
+        sendSSE(this.res, data);
     }
     /**
      * 构造注入上下文的摘要消息。
@@ -421,7 +437,7 @@ ${conversation}
     async generateSummaryAsync(messages, lastSummary) {
         // 非 childAgent 会话通知 Desktop 显示"上下文压缩中"
         if (!this.childAgent) {
-            sendSSE(this.res, { type: 'context_compressing' });
+            this.emitSSE({ type: 'context_compressing' });
         }
         const MAX_INPUT_CHARS = 30000; // 单次摘要最大输入字符数
         // 格式化所有消息用于估算长度

package/dist/services/session/Session.js

@@ -255,16 +255,29 @@ class Session {
     addUserMessage(content, userMessageId, attachments) {
         const message = this.getUserMessage(content, userMessageId, attachments);
         this.messages.push(message);
-        this.toInsertMessages.push(message);
+        this.enqueueMessageSave(message);
         return message;
     }
     /**
      * Add assistant message
      */
     addAssistantMessage(content, toolCalls, modelName, id) {
+        const messageId = id ? id : (0, uuid_1.v4)();
+        // 本轮可能已经通过 persistAssistantProgress 落过盘并入过 this.messages，
+        // 这里必须复用同一条，否则 messages 里会出现两条同 id 的助手消息，
+        // 上下文重复、前端也会渲染出两个气泡。
+        const existing = this.messages.find(m => m.id === messageId && m.role === 'assistant');
+        if (existing) {
+            existing.content = content;
+            existing.toolCalls = toolCalls;
+            existing.modelName = modelName;
+            existing.updatedAt = Date.now();
+            this.enqueueMessageSave(existing);
+            return existing;
+        }
         const message = {
             sessionId: this.id,
-            id: id ? id : (0, uuid_1.v4)(),
+            id: messageId,
             role: 'assistant',
             content,
             toolCalls,
@@ -272,26 +285,72 @@ class Session {
             modelName
         };
         this.messages.push(message);
-        this.toInsertMessages.push(message);
+        this.enqueueMessageSave(message);
         return message;
     }
     /**
-     * Save a single message to store
+     * 把消息加入待落库队列（按 id 去重）。
+     *
+     * 同一条助手消息在一轮里会被反复标记为待保存（每个工具轮次、正文就绪、收尾各一次），
+     * 队列里只保留一份引用即可——落库时读的是对象的最新字段。
+     */
+    enqueueMessageSave(message) {
+        if (!this.toInsertMessages.some(m => m.id === message.id)) {
+            this.toInsertMessages.push(message);
+        }
+    }
+    /**
+     * 冲刷待落库队列。
+     *
+     * 原先只在 streamChat 的 finally 里调用一次，意味着一轮对话（可能持续几分钟、
+     * 跑十几个工具）期间进程崩溃/被杀，用户消息和已经产出的助手内容会全部丢失。
+     * 现在改为在流程中的关键节点多次调用，每次都是幂等 UPSERT。
      */
     async saveMessage() {
         const store = this.store;
+        if (this.toInsertMessages.length === 0) {
+            return;
+        }
+        // 取出快照后立刻清空：落库期间若有新消息入队，属于下一次冲刷的范围，
+        // 不能因为本次失败/成功而被连带清掉或重复写入。
+        const pending = this.toInsertMessages;
+        this.toInsertMessages = [];
         this.updatedAt = Date.now();
         try {
             store.transaction(() => {
-                for (let message of this.toInsertMessages) {
-                    store.insertMessage(this.id, message);
+                for (const message of pending) {
+                    store.upsertMessage(this.id, message);
                 }
-                this.toInsertMessages = [];
                 store.updateSession(this.toStoreData());
             });
         }
         catch (error) {
             logger.error('数据保存错误：', error);
+            // 落库失败的消息重新排回队列头部，等下一个节点重试，避免直接丢数据
+            this.toInsertMessages = pending.concat(this.toInsertMessages);
+        }
+    }
+    /**
+     * 会话进行中增量保存助手消息。
+     *
+     * 在每个工具轮次结束、以及正文流式输出完成后调用，让数据库里始终有一份
+     * 接近最新的助手消息。这样即使进程异常退出，用户也能看到已经完成的部分，
+     * 而不是整轮消失。
+     *
+     * @param content 当前已产出的正文
+     * @param toolCalls 当前已完成的工具调用
+     * @param modelName 参与本轮的模型名
+     */
+    persistAssistantProgress(content, toolCalls, modelName) {
+        if (!this.currentMessageId)
+            return;
+        try {
+            this.addAssistantMessage(content, toolCalls, modelName, this.currentMessageId);
+            void this.saveMessage();
+        }
+        catch (error) {
+            // 增量保存是尽力而为的容灾手段，失败不能中断正在进行的对话
+            logger.warn('助手消息增量保存失败:', error?.message);
         }
     }
     /**
@@ -381,6 +440,25 @@ class Session {
     getMessageCount() {
         return this.messages.length;
     }
+    /**
+     * 取断线期间的消息变更（新增 / 修改 / 删除）。
+     *
+     * WebSocket 重连的退避最长 30s，这期间错过的会话流事件无法补发，
+     * 而重连后又没有任何信号告诉终端「你落后了」，各终端就会永久分歧。
+     * 终端报上自己的 seq 游标，这里只回变更部分。
+     *
+     * @param sinceSeq 终端已知的最大 seq，0 表示全量
+     */
+    getMessagesChangedSince(sinceSeq) {
+        const store = this.store;
+        return {
+            messages: store.findMessagesChangedSince(this.id, sinceSeq),
+            // 删除不留痕迹，光靠 seq 发现不了离线期间被删的消息，
+            // 因此一并回完整 id 列表让终端剪除多余项
+            messageIds: store.findMessageIdsBySessionId(this.id),
+            maxSeq: store.getMaxMessageSeq(),
+        };
+    }
     /**
      * Get messages by page (descending order)
      */
@@ -632,8 +710,6 @@ class Session {
         const settings = await dataService_js_1.settingsService.get(token);
         const streamDelay = this.getStreamDelay(settings.streamSpeed);
         this.currentMessageId = assistantMessageId;
-        const memoryManager = new MemoryManager_js_1.MemoryManager(this, this.abortController.signal, childAgent, res);
-        const historyMessages = await memoryManager.getHistoryMessagesAsync();
         // 同一用户可能同时在多个终端登录，而 SSE 只能回给发起请求的那个终端。
         // 这里预先取到 WebSocketService，把每个 SSE 事件同步给该用户的其他连接，
         // 从而让所有终端看到同一份会话流。子 Agent 的内部流不需要同步。
@@ -660,6 +736,25 @@ class Session {
                 logger.error('SSE mirror error:', error);
             }
         };
+        // 其他终端没有参与本次请求，需要补一条用户消息才能对齐会话。
+        // 必须在 message_start 之前同步：否则接收端会先插入助手占位，
+        // 导致助手消息排在用户消息前面。
+        //
+        // 同时带上助手占位标记：接收端据此在用户消息后面立即插入「思考中」
+        // 占位气泡，与发起端表现一致（占位文案由接收端按自身语言生成）。
+        if (!childAgent) {
+            mirrorToOtherClients({
+                type: 'user_message',
+                message: this.getUserMessage(content, userMessageId, attachments),
+                assistantPlaceholder: true,
+            });
+        }
+        // 必须在加载历史（可能触发上下文压缩）之前发出：
+        // context_compressing 是对助手消息的原地更新，接收端必须先有占位气泡。
+        // MemoryManager 会在压缩历史时发出 context_compressing，
+        // 把镜像函数传进去，使该事件也能同步到其他终端。
+        const memoryManager = new MemoryManager_js_1.MemoryManager(this, this.abortController.signal, childAgent, res, mirrorToOtherClients);
+        const historyMessages = await memoryManager.getHistoryMessagesAsync();
         // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式），但仍同步给其他终端
         const sendSSE = (res, data) => {
             mirrorToOtherClients(data);
@@ -682,19 +777,6 @@ class Session {
                 clearInterval(heartbeatInterval);
             }
         }, 15000);
-        // 其他终端没有参与本次请求，需要补一条用户消息才能对齐会话。
-        // 必须在 message_start 之前同步：否则接收端会先插入助手占位，
-        // 导致助手消息排在用户消息前面。
-        //
-        // 同时带上助手占位标记：接收端据此在用户消息后面立即插入「思考中」
-        // 占位气泡，与发起端表现一致（占位文案由接收端按自身语言生成）。
-        if (!childAgent) {
-            mirrorToOtherClients({
-                type: 'user_message',
-                message: this.getUserMessage(content, userMessageId, attachments),
-                assistantPlaceholder: true,
-            });
-        }
         // Send message start event
         sendSSE(res, { type: 'message_start' });
         // Build messages for API call (保留 tool_call_id 等必要字段)
@@ -739,6 +821,9 @@ class Session {
         if (!childAgent) {
             this.addUserMessage(content, userMessageId, attachments);
             messages.push(this.messages.at(-1));
+            // 用户消息一旦确定就立即落库：后面的模型调用可能耗时数分钟，
+            // 期间进程退出不该让用户刚发的话凭空消失。
+            void this.saveMessage();
         }
         else {
             messages.push(this.getUserMessage(content, userMessageId, attachments));
@@ -1081,6 +1166,11 @@ class Session {
                 };
                 await Promise.all(llmResult.toolCalls.map(x => startToolCall(x)));
                 toolCalls.push(toolCall);
+                // 本轮工具已执行完，增量落库一次。工具轮次可能很多且每轮都耗时，
+                // 这里保存能让崩溃后仍保留已完成的工具调用记录。
+                if (!childAgent) {
+                    this.persistAssistantProgress(llmResult.content || llmResult.reasoningContent || '', toolCalls, [...new Set(modelNames)].join(','));
+                }
                 // 计划模式：本轮是否调用了 updatePlan
                 const calledUpdatePlan = llmResult.toolCalls.some((tc) => tc.toolName === 'updatePlan');
                 roundsSincePlanUpdate = calledUpdatePlan ? 0 : roundsSincePlanUpdate + 1;
@@ -1147,6 +1237,9 @@ class Session {
                 }
                 if (!childAgent) {
                     this.addAssistantMessage(llmResult.content || llmResult.reasoningContent, toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    // 正文已完整产出，先落库再发 complete：
+                    // 客户端收到 complete 后就认为这条消息定稿了，此时库里必须已经有它。
+                    await this.saveMessage();
                 }
                 sendSSE(res, { type: 'complete', modelName: [...new Set(modelNames)].join(",") });
                 sendSSE(res, { type: '[DONE]' });
@@ -1161,7 +1254,9 @@ class Session {
             logger.error('stream chat ', error);
             if (!childAgent) {
                 if (toolCalls) {
-                    this.addAssistantMessage('', toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
+                    // 用 '' 覆盖会把已经增量保存的正文清空，这里保留已有内容
+                    const saved = this.messages.find(m => m.id === this.currentMessageId && m.role === 'assistant');
+                    this.addAssistantMessage(saved?.content || '', toolCalls, [...new Set(modelNames)].join(','), this.currentMessageId);
                 }
                 if (error.message !== 'aborted') {
                     try {
@@ -1242,7 +1337,9 @@ class Session {
     /**
      * 停止当前正在进行的生成
      */
-    stopGenerating() {
+    stopGenerating(clientId) {
+        const wasGenerating = this.isGenerating;
+        const stoppedMessageId = this.currentMessageId;
         this.isGenerating = false;
         this.abortPrecompression();
         // 停止生成后清除计划，避免 Desktop 的进度圈停留在未完成状态
@@ -1251,6 +1348,39 @@ class Session {
             this.abortController.abort();
             this.abortController = null;
         }
+        // 通知其他终端本轮已被停止。
+        //
+        // 中断走的是 abort 分支，streamChat 既不会发 error 也不会发 [DONE]
+        // （见 catch 中的 error.message !== 'aborted' 判断），
+        // 因此镜像终端收不到任何终止事件，会永远卡在「思考中」占位和 loading 态。
+        // 这里必须显式广播一次。
+        if (wasGenerating) {
+            void this.notifySessionStopped(stoppedMessageId, clientId);
+        }
+    }
+    /**
+     * 向其他终端广播「本轮生成已停止」。
+     *
+     * @param assistantMessageId 被停止的助手消息 id，接收端据此定位占位气泡
+     * @param excludeClientId 发起停止的终端（它自己已在本地做过收尾，无需再处理）
+     */
+    async notifySessionStopped(assistantMessageId, excludeClientId) {
+        try {
+            const webSocketService = await this.getWebSocketService();
+            if (!webSocketService)
+                return;
+            webSocketService.sendToUser(String(this.userId), {
+                type: 'session_stopped',
+                payload: {
+                    sessionId: this.id,
+                    agentId: this.agentId,
+                    assistantMessageId,
+                },
+            }, { excludeClientId });
+        }
+        catch (error) {
+            logger.error('推送会话停止事件失败:', error);
+        }
     }
     /**
      * 获取 AbortController 用于中断请求

package/dist/services/session/SessionManager.js

@@ -111,14 +111,15 @@ class SessionManager {
     /**
      * Stop session generation
      */
-    stopSession(sessionId) {
+    stopSession(sessionId, clientId) {
         const session = this.getSession(sessionId);
         if (!session) {
             logger.warn(`Session ${sessionId} not found for stop`);
             return false;
         }
         if (session.isGenerating) {
-            session.stopGenerating();
+            // 透传发起端标识：停止事件广播时要排除它，它已在本地收尾
+            session.stopGenerating(clientId);
             logger.info(`Stopped session ${sessionId}`);
             return true;
         }

package/dist/services/session/SessionStore.js

@@ -81,17 +81,17 @@ class SessionStore {
     }
     // ========== Session Operations ==========
     insertSession(session) {
-        this.db.prepare(`
-      INSERT INTO sessions (id, user_id, agent_id, title, select_model_id, voice_state, created_at, updated_at,last_message_summary,last_message_summary_at,unread_count,is_current,message_queue,message_queue_auto_execute, use_system_mode)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?,?,?,?,?,?,?,?)
+        this.db.prepare(`
+      INSERT INTO sessions (id, user_id, agent_id, title, select_model_id, voice_state, created_at, updated_at,last_message_summary,last_message_summary_at,unread_count,is_current,message_queue,message_queue_auto_execute, use_system_mode)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?,?,?,?,?,?,?,?)
     `).run(session.id, session.userId, session.agentId || null, session.title, session.selectModelId || '', JSON.stringify(session.voiceState), session.createdAt, session.updatedAt, session.lastMessageSummary, session.lastMessageSummaryAt, session.unreadCount || 0, session.isCurrent ? 1 : 0, JSON.stringify(session.messageQueue || []), session.messageQueueAutoExecute === false ? 0 : 1, session.useSystemMode ? 1 : 0);
     }
     updateSession(session) {
-        this.db.prepare(`
-      UPDATE sessions 
-      SET user_id = ?, agent_id = ?, title = ?, select_model_id = ?,
-          voice_state = ?, updated_at = ?,last_message_summary=?,last_message_summary_at=?,unread_count=?,is_current=?,message_queue=?,message_queue_auto_execute=?, use_system_mode=?
-      WHERE id = ?
+        this.db.prepare(`
+      UPDATE sessions 
+      SET user_id = ?, agent_id = ?, title = ?, select_model_id = ?,
+          voice_state = ?, updated_at = ?,last_message_summary=?,last_message_summary_at=?,unread_count=?,is_current=?,message_queue=?,message_queue_auto_execute=?, use_system_mode=?
+      WHERE id = ?
     `).run(session.userId, session.agentId || null, session.title, session.selectModelId || '', JSON.stringify(session.voiceState), session.updatedAt, session.lastMessageSummary, session.lastMessageSummaryAt, session.unreadCount || 0, session.isCurrent ? 1 : 0, JSON.stringify(session.messageQueue || []), session.messageQueueAutoExecute === false ? 0 : 1, session.useSystemMode ? 1 : 0, session.id);
     }
     // 支持部分更新的 updateSession
@@ -141,27 +141,76 @@ class SessionStore {
         return rows.map(row => this.rowToSessionData(row));
     }
     // ========== Message Operations ==========
+    /**
+     * 取下一个消息行版本号。
+     *
+     * 刷新（insert / update）都要取新号，因此 seq 是「行版本」而不是「插入序号」：
+     * 助手消息在一轮里会被反复更新，只有每次都抬号，断线重连的终端才能
+     * 靠「seq > 本地游标」把被改过的消息也拉回来。
+     *
+     * 刷号器单独持久化（message_seq 表），不用 MAX(seq)+1：
+     * 删掉最后一条消息后 MAX 会回退，号被重用，已经看过该 seq 的终端就会
+     * 永久错过新消息。
+     *
+     * 注意排序仍用 created_at：seq 只作为变更游标，抬号不得改变消息在界面上的位置。
+     */
+    nextSeq() {
+        // 用 UPDATE ... RETURNING 一步完成自增与读取：
+        // 每个 Session 都新建一个 SessionStore（各自一个到同一文件的连接），
+        // 先 UPDATE 再 SELECT 在连接间不原子，会发出重复的 seq。
+        const row = this.db.prepare('UPDATE message_seq SET value = value + 1 WHERE id = 1 RETURNING value').get();
+        return row?.value ?? 1;
+    }
+    /** 当前最大消息行版本号（终端用作同步游标基准） */
+    getMaxMessageSeq() {
+        const row = this.db.prepare('SELECT value FROM message_seq WHERE id = 1').get();
+        return row?.value ?? 0;
+    }
     insertMessage(sessionId, msg) {
-        this.db.prepare(`
-      INSERT INTO messages (id, session_id, role, content, attachments, tool_calls, created_at, updated_at, model_name, feedback)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(msg.id, sessionId, msg.role, msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.createdAt, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null);
+        this.db.prepare(`
+      INSERT INTO messages (id, session_id, role, content, attachments, tool_calls, created_at, updated_at, model_name, feedback, seq)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(msg.id, sessionId, msg.role, msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.createdAt, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null, this.nextSeq());
+    }
+    /**
+     * 写入或更新消息（按 id 幂等）。
+     *
+     * 会话进行中需要多次落库同一条助手消息（工具轮次结束、正文就绪、收尾），
+     * 用 INSERT 会撞主键，用 UPDATE 首次又没有行，因此统一走 UPSERT。
+     *
+     * 冲突时刻意不更新 session_id / role / created_at：
+     * created_at 是消息列表的排序依据（findMessagesBySessionId ORDER BY created_at），
+     * 若每次落库都刷新它，同一轮的用户消息与助手消息顺序会被打乱。
+     */
+    upsertMessage(sessionId, msg) {
+        this.db.prepare(`
+      INSERT INTO messages (id, session_id, role, content, attachments, tool_calls, created_at, updated_at, model_name, feedback, seq)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        content = excluded.content,
+        attachments = excluded.attachments,
+        tool_calls = excluded.tool_calls,
+        updated_at = excluded.updated_at,
+        model_name = excluded.model_name,
+        feedback = excluded.feedback,
+        seq = excluded.seq
+    `).run(msg.id, sessionId, msg.role, msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.createdAt, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null, this.nextSeq());
     }
     insertMessages(sessionId, messages) {
-        const stmt = this.db.prepare(`
-      INSERT INTO messages (id, session_id, role, content, attachments,  tool_calls,created_at, updated_at, model_name, feedback)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        const stmt = this.db.prepare(`
+      INSERT INTO messages (id, session_id, role, content, attachments,  tool_calls,created_at, updated_at, model_name, feedback, seq)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const msg of messages) {
-            stmt.run(msg.id, sessionId, msg.role, msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.createdAt, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null);
+            stmt.run(msg.id, sessionId, msg.role, msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.createdAt, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null, this.nextSeq());
         }
     }
     updateMessage(sessionId, msg) {
-        this.db.prepare(`
-      UPDATE messages 
-      SET content = ?, attachments = ?, tool_calls = ?,  updated_at = ?, model_name = ?, feedback = ?
-      WHERE id = ? AND session_id = ?
-    `).run(msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null, msg.id, sessionId);
+        this.db.prepare(`
+      UPDATE messages 
+      SET content = ?, attachments = ?, tool_calls = ?,  updated_at = ?, model_name = ?, feedback = ?, seq = ?
+      WHERE id = ? AND session_id = ?
+    `).run(msg.content, JSON.stringify(msg.attachments || []), msg.toolCalls ? JSON.stringify(msg.toolCalls) : null, msg.updatedAt || msg.createdAt, msg.modelName || null, msg.feedback || null, this.nextSeq(), msg.id, sessionId);
     }
     deleteMessage(messageId) {
         this.db.prepare('DELETE FROM messages WHERE id = ?').run(messageId);
@@ -171,7 +220,29 @@ class SessionStore {
     }
     findMessagesBySessionId(sessionId) {
         const rows = this.db.prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC').all(sessionId);
-        return rows.map(row => ({
+        return rows.map(row => this.rowToMessage(row));
+    }
+    /**
+     * 取会话内 seq 大于 sinceSeq 的消息（新增与被修改的都在内）。
+     *
+     * 终端断线重连后报上自己的游标，只拉缺失的部分，不必全量重拉。
+     */
+    findMessagesChangedSince(sessionId, sinceSeq) {
+        const rows = this.db.prepare('SELECT * FROM messages WHERE session_id = ? AND seq > ? ORDER BY seq ASC').all(sessionId, sinceSeq);
+        return rows.map(row => this.rowToMessage(row));
+    }
+    /**
+     * 取会话内全部消息 id（按展示顺序）。
+     *
+     * 删除不会留下带 seq 的行，光靠增量查询发现不了「离线期间被删掉的消息」，
+     * 因此同步时一并返回 id 列表让终端剪除多余消息。
+     */
+    findMessageIdsBySessionId(sessionId) {
+        const rows = this.db.prepare('SELECT id FROM messages WHERE session_id = ? ORDER BY created_at ASC').all(sessionId);
+        return rows.map(row => row.id);
+    }
+    rowToMessage(row) {
+        return {
             id: row.id,
             sessionId: row.session_id,
             role: row.role,
@@ -181,8 +252,9 @@ class SessionStore {
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             modelName: row.model_name,
-            feedback: row.feedback || undefined
-        }));
+            feedback: row.feedback || undefined,
+            seq: row.seq ?? undefined
+        };
     }
     rowToSessionData(row) {
         return {

package/migrations/016_add_message_seq.sql

@@ -0,0 +1,27 @@
+-- 为消息表增加全局单调递增的 seq，用于多终端增量同步。
+--
+-- 原先消息只按 created_at 排序，没有单调游标：WebSocket 断线重连
+-- （退避最长 30s）期间丢的事件无法补拉，各终端会永久分歧。
+-- 有了 seq，终端只需报上自己看到的最大 seq 就能拉回缺失部分。
+ALTER TABLE messages ADD COLUMN seq INTEGER;
+
+-- 存量数据按 created_at（同时间再按 id）回填，保证与原有展示顺序一致
+UPDATE messages SET seq = (
+  SELECT COUNT(*) FROM messages m2
+  WHERE m2.created_at < messages.created_at
+     OR (m2.created_at = messages.created_at AND m2.id <= messages.id)
+) WHERE seq IS NULL;
+
+CREATE INDEX IF NOT EXISTS idx_messages_seq ON messages(seq);
+CREATE INDEX IF NOT EXISTS idx_messages_session_seq ON messages(session_id, seq);
+
+-- seq 发号器单独持久化：不能用 MAX(seq)+1 发号，
+-- 删除最后一条消息后号会被重用，已经看到该 seq 的终端就会永久错过新消息。
+CREATE TABLE IF NOT EXISTS message_seq (
+  id INTEGER PRIMARY KEY,
+  value INTEGER NOT NULL
+);
+
+INSERT INTO message_seq (id, value)
+SELECT 1, IFNULL((SELECT MAX(seq) FROM messages), 0)
+WHERE NOT EXISTS (SELECT 1 FROM message_seq WHERE id = 1);

package/package.json

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