@myassis/gateway 1.0.82 → 1.0.84

package/dist/services/session/Session.js

@@ -40,6 +40,13 @@ const ContextBuilder_js_1 = require("../memory/ContextBuilder.js");
 const SessionManager_js_1 = require("./SessionManager.js");
 const logger = (0, shared_1.getLogger)('Session');
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * 不向其他终端镜像的 SSE 事件类型。
+ *
+ * heartbeat 仅用于保持 SSE 连接存活；approval_pending 需要发起端弹窗确认，
+ * 广播出去会让多个终端同时弹窗并重复回传批准结果。
+ */
+const NON_MIRRORED_SSE_EVENTS = new Set(['heartbeat', 'approval_pending']);
 // 批准等待缓存：token -> { resolve, reject, expiresAt }
 const approvalWaiters = new Map();
 /**
@@ -495,6 +502,71 @@ class Session {
         lines.push('调用时必须传入完整步骤列表，且同一时刻最多一个步骤为 in_progress。');
         return lines.join('\n');
     }
+    /**
+     * 把当前计划推送到 Desktop。
+     *
+     * 用动态 import 获取 webSocketService：WebSocketService 反向依赖本文件的
+     * handleApprovalResponse，静态引入会形成循环依赖。
+     */
+    async getWebSocketService() {
+        try {
+            const { webSocketService } = await Promise.resolve().then(() => __importStar(require('../WebSocketService.js')));
+            return webSocketService;
+        }
+        catch (error) {
+            logger.error('加载 WebSocketService 失败:', error);
+            return null;
+        }
+    }
+    async notifyPlanUpdate() {
+        try {
+            const webSocketService = await this.getWebSocketService();
+            if (!webSocketService)
+                return;
+            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;
@@ -534,7 +606,7 @@ class Session {
      * Stream chat response (SSE) - 使用 ModelSelector 根据选择的模型调用
      * 支持工具调用流程
      */
-    async streamChat(content, attachments = [], res, userMessageId, assistantMessageId, childAgent = false) {
+    async streamChat(content, attachments = [], res, userMessageId, assistantMessageId, childAgent = false, clientId) {
         // 如果正在生成，等待当前生成完成（最多等待 2 秒）
         if (this.isGenerating) {
             const maxWait = 2000;
@@ -562,8 +634,35 @@ class Session {
         this.currentMessageId = assistantMessageId;
         const memoryManager = new MemoryManager_js_1.MemoryManager(this, this.abortController.signal, childAgent, res);
         const historyMessages = await memoryManager.getHistoryMessagesAsync();
-        // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式）
+        // 同一用户可能同时在多个终端登录，而 SSE 只能回给发起请求的那个终端。
+        // 这里预先取到 WebSocketService，把每个 SSE 事件同步给该用户的其他连接，
+        // 从而让所有终端看到同一份会话流。子 Agent 的内部流不需要同步。
+        const wsService = childAgent ? null : await this.getWebSocketService();
+        /** 把 SSE 事件镜像给当前用户的其他终端（排除发起端，避免重复渲染） */
+        const mirrorToOtherClients = (data) => {
+            if (!wsService)
+                return;
+            if (NON_MIRRORED_SSE_EVENTS.has(data?.type))
+                return;
+            try {
+                wsService.sendToUser(String(this.userId), {
+                    type: 'session_stream',
+                    payload: {
+                        sessionId: this.id,
+                        agentId: this.agentId,
+                        userMessageId,
+                        assistantMessageId,
+                        event: data,
+                    },
+                }, { excludeClientId: clientId });
+            }
+            catch (error) {
+                logger.error('SSE mirror error:', error);
+            }
+        };
+        // SSE 辅助方法：res 为 null 时跳过写入（本地执行模式），但仍同步给其他终端
         const sendSSE = (res, data) => {
+            mirrorToOtherClients(data);
             if (!res)
                 return;
             try {
@@ -583,6 +682,19 @@ 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 等必要字段)
@@ -645,6 +757,8 @@ class Session {
         let toolRound = 0;
         // 计划模式：距上次调用 updatePlan 已经过的工具轮次，用于在中间过程强制提醒模型同步进度
         let roundsSincePlanUpdate = 0;
+        // 计划模式：收尾时提醒模型补完计划的次数，避免反复提醒导致死循环
+        let planFinalizeNudges = 0;
         // 当前裁剪级别，遇到上下文超限时逐级加重
         let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
         /** 判断错误是否为上下文超限 */
@@ -999,7 +1113,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 +1188,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/dist/stores/authStore.js

@@ -17,8 +17,36 @@ const logger = (0, shared_1.getLogger)('authStore');
 // 认证数据存储文件路径（使用应用数据目录，支持 STORAGE_DIR 环境变量）
 const AUTH_STORAGE_DIR = process.env.STORAGE_DIR || path_1.default.join(os_1.default.homedir(), 'myassis-gateway-storage');
 const AUTH_STORAGE_FILE = path_1.default.join(AUTH_STORAGE_DIR, 'auth', 'auth.json');
-// 内存中的认证数据
+/**
+ * 内存中的认证数据：userId -> 该用户的所有终端会话（新的在前）。
+ *
+ * 同一账号可以在多个终端（桌面、移动端等）同时登录，每个终端持有
+ * 各自的 accessToken/refreshToken，所以这里必须保存多条而不是一条，
+ * 否则后登录的终端会把先登录的挤下线，先登录终端的请求会全部 401。
+ */
 let authMap = null;
+/** 单个用户保留的最大会话数，防止反复登录导致无限增长 */
+const MAX_SESSIONS_PER_USER = 20;
+/** 会话是否已过期（没有 expiresAt 的旧数据视为未过期） */
+function isExpired(auth) {
+    return typeof auth.expiresAt === 'number' && auth.expiresAt <= Date.now();
+}
+/**
+ * 规整某个用户的会话列表：去掉过期会话、按登录时间倒序、限制数量。
+ * 全部过期时保留最新一条，避免用户凭据被清空后无法自愈刷新。
+ */
+function normalizeSessions(sessions) {
+    const sorted = [...sessions].sort((a, b) => (b.loginAt ?? 0) - (a.loginAt ?? 0));
+    const alive = sorted.filter((x) => !isExpired(x));
+    const kept = alive.length > 0 ? alive : sorted.slice(0, 1);
+    return kept.slice(0, MAX_SESSIONS_PER_USER);
+}
+/** 遍历所有用户的所有会话 */
+function allSessions() {
+    if (!authMap)
+        return [];
+    return Array.from(authMap.values()).flat();
+}
 // 确保存储目录存在
 function ensureStorageDir() {
     const dir = path_1.default.dirname(AUTH_STORAGE_FILE);
@@ -32,8 +60,13 @@ function loadFromFile() {
         if (fs_1.default.existsSync(AUTH_STORAGE_FILE)) {
             const data = fs_1.default.readFileSync(AUTH_STORAGE_FILE, 'utf-8');
             const obj = JSON.parse(data);
+            // 兼容旧格式：userId -> AuthData（单终端），统一升级为会话数组
+            const entries = Object.entries(obj).map(([userId, value]) => {
+                const sessions = Array.isArray(value) ? value : [value];
+                return [userId, normalizeSessions(sessions.filter(Boolean))];
+            });
             logger.debug('Auth data loaded from file');
-            return new Map(Object.entries(obj));
+            return new Map(entries.filter(([, sessions]) => sessions.length > 0));
         }
     }
     catch (error) {
@@ -90,36 +123,89 @@ exports.authStore = {
         if (authMap === null) {
             this.load();
         }
-        authMap.set(authData.user.id, authData);
+        const userId = authData.user.id;
+        const session = { ...authData, loginAt: authData.loginAt ?? Date.now() };
+        // 多终端并存：新增一条会话，而不是覆盖该用户已有的会话。
+        // 同一 token/refreshToken 重复登录时替换旧记录，避免重复堆积。
+        const existing = (authMap.get(userId) ?? []).filter((x) => x.accessToken !== session.accessToken &&
+            (!session.refreshToken || x.refreshToken !== session.refreshToken));
+        authMap.set(userId, normalizeSessions([session, ...existing]));
         saveAuthToFile(authMap);
         // 用户登录后初始化 SessionManager
-        (0, index_js_1.getSessionManager)(authData.user.id).initialize();
-        logger.debug('Auth saved for user:', authData.user.nickname);
+        (0, index_js_1.getSessionManager)(userId).initialize();
+        logger.debug(`Auth saved for user: ${authData.user.nickname}（会话数: ${authMap.get(userId).length}）`);
     },
-    //获取所有认证用户
+    /**
+     * 获取所有认证用户（每个用户一条代表性会话）
+     *
+     * 供后台任务按用户维度轮询使用，因此这里按用户去重，
+     * 需要某个用户的全部终端会话时用 getSessions。
+     */
     getAll() {
         if (authMap === null) {
             this.load();
         }
-        return authMap;
+        const result = new Map();
+        authMap.forEach((sessions, userId) => {
+            const current = normalizeSessions(sessions)[0];
+            if (current) {
+                result.set(userId, current);
+            }
+        });
+        return result;
     },
     /**
-     * 获取当前认证数据
+     * 获取某个用户的所有终端会话（新的在前）
+     */
+    getSessions(userId) {
+        if (authMap === null) {
+            this.load();
+        }
+        return normalizeSessions(authMap.get(String(userId)) ?? []);
+    },
+    /**
+     * 获取用户当前可用的认证数据（多终端时取最新的有效会话）
      */
     get(userId) {
-        return authMap.get(userId);
+        return this.getSessions(userId)[0] || null;
+    },
+    /**
+     * 按 accessToken 精确获取某个终端的认证数据
+     */
+    getByToken(token) {
+        if (authMap === null) {
+            this.load();
+        }
+        return allSessions().find((x) => x.accessToken === token) || null;
+    },
+    /**
+     * 按 refreshToken 精确获取某个终端的认证数据
+     */
+    getByRefreshToken(refreshToken) {
+        if (authMap === null) {
+            this.load();
+        }
+        return allSessions().find((x) => x.refreshToken === refreshToken) || null;
     },
     /**
      * 获取用户信息
      */
     getUser(userId) {
-        return authMap.get(userId).user || null;
+        return this.get(userId)?.user || null;
     },
     /**
-     * 获取刷新 Token
+     * 获取刷新 Token（多终端时取最新会话的）
      */
     getRefreshToken(userId) {
-        return authMap.get(userId)?.refreshToken || null;
+        return this.get(userId)?.refreshToken || null;
+    },
+    /**
+     * 按 accessToken 获取对应终端的刷新 Token
+     *
+     * 登出只应失效发起登出的那个终端，所以不能退化成用户维度的最新会话。
+     */
+    getRefreshTokenByToken(token) {
+        return this.getByToken(token)?.refreshToken || null;
     },
     /**
      * 更新 Token
@@ -138,8 +224,9 @@ exports.authStore = {
             return false;
         }
         // 按旧 token 定位记录；若传入的旧 token 已被替换过，则回退用新 token 匹配（幂等）
-        const auth = Array.from(authMap.values()).find(x => x.accessToken === oldToken)
-            || Array.from(authMap.values()).find(x => x.accessToken === newToken);
+        const sessions = allSessions();
+        const auth = sessions.find(x => x.accessToken === oldToken)
+            || sessions.find(x => x.accessToken === newToken);
         if (!auth) {
             logger.warn('updateToken: no auth record matched the given token');
             return false;
@@ -161,7 +248,7 @@ exports.authStore = {
      */
     getUserId(token) {
         if (authMap) {
-            return Array.from(authMap.values()).find(x => x.accessToken === token)?.user?.id || null;
+            return allSessions().find(x => x.accessToken === token)?.user?.id || null;
         }
         else {
             return null;
@@ -176,22 +263,24 @@ exports.authStore = {
         logger.debug('Auth cleared');
     },
     /**
-     * 移除单个用户的认证数据，不影响其他已登录用户
+     * 移除某个用户的全部终端会话（注销账号等场景）
      * @returns 是否确实移除了记录
      */
     remove(userId) {
         if (!authMap) {
             this.load();
         }
-        const removed = authMap.delete(userId);
+        const removed = authMap.delete(String(userId));
         if (removed) {
             saveAuthToFile(authMap);
-            logger.debug('Auth removed for user:', userId);
+            logger.debug('All auth sessions removed for user:', userId);
         }
         return removed;
     },
     /**
-     * 按 accessToken 定位并移除单个用户的认证数据
+     * 按 accessToken 移除单个终端的会话
+     *
+     * 只下线发起登出的终端，该用户在其他终端的登录状态保持不变。
      * @returns 是否确实移除了记录
      */
     removeByToken(token) {
@@ -199,17 +288,37 @@ exports.authStore = {
         if (!userId) {
             return false;
         }
-        return this.remove(userId);
+        const sessions = authMap.get(userId) ?? [];
+        const remaining = sessions.filter((x) => x.accessToken !== token);
+        if (remaining.length === sessions.length) {
+            return false;
+        }
+        if (remaining.length > 0) {
+            authMap.set(userId, remaining);
+        }
+        else {
+            authMap.delete(userId);
+        }
+        saveAuthToFile(authMap);
+        logger.debug(`Auth session removed for user: ${userId}（剩余会话数: ${remaining.length}）`);
+        return true;
     },
     /**
      * 更新用户信息
      */
     updateUser(token, userData) {
         if (authMap) {
-            const auth = Array.from(authMap.values()).find(x => x.accessToken === token);
-            auth.user = { ...auth.user, ...userData };
+            const target = this.getByToken(token);
+            if (!target) {
+                logger.warn('updateUser: no auth session matched the given token');
+                return;
+            }
+            // 用户资料是账号级信息，需要同步到该用户的所有终端会话
+            this.getSessions(target.user.id).forEach((auth) => {
+                auth.user = { ...auth.user, ...userData };
+            });
             saveAuthToFile(authMap);
-            logger.debug('User updated:', auth.user?.nickname || auth.user?.account);
+            logger.debug('User updated:', target.user?.nickname || target.user?.account);
         }
     },
 };

package/package.json

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