@myassis/gateway 1.0.83 → 1.0.84

package/dist/main.js

@@ -25,6 +25,7 @@ const upload_js_1 = __importDefault(require("./routes/upload.js"));
 const version_js_1 = __importDefault(require("./routes/version.js"));
 const quota_js_1 = __importDefault(require("./routes/quota.js"));
 const errorHandler_js_1 = require("./middleware/errorHandler.js");
+const broadcast_js_1 = require("./middleware/broadcast.js");
 const index_js_2 = require("./stores/index.js");
 const persistStore_js_1 = require("./stores/persistStore.js");
 const WebSocketService_js_1 = require("./services/WebSocketService.js");
@@ -273,6 +274,9 @@ else {
     app.get('/health', (req, res) => {
         res.json({ status: 'ok', service: 'gateway', version: '2.0.0', wsOnline: WebSocketService_js_1.webSocketService.getOnlineCount() });
     });
+    // 写请求成功后向该用户的其他终端广播数据变更（多终端同步）。
+    // 必须注册在业务路由之前：它通过包装 res.json 生效。
+    app.use(broadcast_js_1.broadcastDataChanges);
     // Routes
     app.use('/api/v1/auth', auth_js_1.default);
     app.use('/api/v1/agent', agent_js_1.default);

package/dist/middleware/broadcast.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * 数据变更广播中间件
+ *
+ * 同一账号可能在多个终端登录。任何一个终端调用写接口（POST/PUT/PATCH/DELETE）
+ * 修改了数据后，其他终端的本地缓存就过期了，必须重新拉取才能看到最新状态。
+ * 本中间件在写请求成功返回后，向该用户的其他终端广播一条 `data_changed`，
+ * 由终端决定刷新哪部分数据。
+ *
+ * 设计取舍：
+ * - 只广播「什么变了」，不广播变更后的完整数据。写接口的响应体格式各异
+ *   （有的返回实体、有的只返回 success），统一封装成本高且容易泄漏内部结构；
+ *   让终端按资源类型走既有的加载逻辑更可靠。
+ * - 只在响应成功时广播。失败的写请求没有改变任何状态，广播会导致无谓刷新。
+ * - 发起端通过 clientId 排除。它自己已经拿到了响应，会走本地更新逻辑，
+ *   再收一次广播会造成重复请求甚至覆盖掉刚提交的本地状态。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcastDataChanges = void 0;
+const shared_1 = require("@myassis/shared");
+const WebSocketService_js_1 = require("../services/WebSocketService.js");
+const logger = (0, shared_1.getLogger)('middleware/broadcast');
+/**
+ * 路由前缀 -> 资源类型。
+ *
+ * 以挂载路径的第一段判定，避免为每个 handler 单独标注。
+ */
+const RESOURCE_BY_MOUNT = {
+    agent: 'agent',
+    models: 'model',
+    skills: 'skill',
+    tasks: 'task',
+    settings: 'settings',
+    quota: 'quota',
+};
+/**
+ * 不广播的路径片段。
+ *
+ * - auth/service/version：认证与本机服务管理，属于终端本地行为，
+ *   广播出去会让其他终端做无意义的刷新甚至误判登录态。
+ * - stream/reset：会话流有专门的 session_stream 同步通道（见 Session.streamChat），
+ *   这里再广播一次会造成重复渲染。
+ * - upload：上传结果通过消息体引用，消息本身会广播。
+ * - parse/api-key/rate/rating：不改变列表结构，或属于一次性动作。
+ */
+const SKIPPED_PATH_SEGMENTS = ['stream', 'reset', 'parse', 'api-key', 'set-current'];
+/** 业务路由的公共前缀，用于从完整路径中定位挂载段 */
+const API_PREFIX_SEGMENTS = ['api', 'v1'];
+/** HTTP 方法 -> 变更动作 */
+function toAction(method) {
+    switch (method.toUpperCase()) {
+        case 'POST':
+            return 'created';
+        case 'PUT':
+        case 'PATCH':
+            return 'updated';
+        case 'DELETE':
+            return 'deleted';
+        default:
+            return null;
+    }
+}
+/**
+ * 从请求路径推断资源类型。
+ *
+ * 注意：本中间件挂在 app 级别（早于所有 router.use），此时 Express 还没有匹配到
+ * 任何 router，req.baseUrl 恒为空字符串，req.path 才是完整路径 /api/v1/agent/xxx。
+ * 因此必须跳过 api/v1 前缀后取挂载段，不能依赖 req.baseUrl。
+ */
+function toResource(path) {
+    const segments = path.split('/').filter(Boolean);
+    let index = 0;
+    while (index < API_PREFIX_SEGMENTS.length && segments[index] === API_PREFIX_SEGMENTS[index]) {
+        index += 1;
+    }
+    const mount = segments[index];
+    return mount ? RESOURCE_BY_MOUNT[mount] ?? null : null;
+}
+/**
+ * 细化 agent 路由下的资源类型。
+ *
+ * /api/v1/agent 同时承载 agent、session 和 message 三种资源，
+ * 只看挂载路径会把会话与消息变更都标成 agent，导致终端刷新范围过大。
+ */
+function refineAgentResource(path) {
+    if (/\/messages(\/|$)/.test(path))
+        return 'message';
+    if (/\/sessions(\/|$)/.test(path))
+        return 'session';
+    return 'agent';
+}
+/** 响应体是否表示成功（无法判定时按成功处理） */
+function isSuccessful(statusCode, body) {
+    if (statusCode < 200 || statusCode >= 300)
+        return false;
+    if (body && typeof body === 'object' && 'success' in body) {
+        return body.success !== false;
+    }
+    return true;
+}
+/**
+ * 广播数据变更中间件。
+ *
+ * 挂在路由之前，通过包装 res.json 在响应发出后广播，
+ * 这样不需要改动任何 handler。
+ */
+function broadcastDataChanges(req, res, next) {
+    const action = toAction(req.method);
+    if (!action) {
+        next();
+        return;
+    }
+    const resource = toResource(req.path);
+    if (!resource) {
+        next();
+        return;
+    }
+    const pathSegments = req.path.split('/').filter(Boolean);
+    if (pathSegments.some((segment) => SKIPPED_PATH_SEGMENTS.includes(segment))) {
+        next();
+        return;
+    }
+    const originalJson = res.json.bind(res);
+    res.json = (body) => {
+        // 先把响应交回给发起端，广播失败不能影响本次请求
+        const result = originalJson(body);
+        try {
+            // userId 由 requireAuth 写入；未认证的写请求无从判断归属，直接跳过
+            const userId = req.userId;
+            if (userId && isSuccessful(res.statusCode, body)) {
+                const finalResource = resource === 'agent' ? refineAgentResource(req.path) : resource;
+                WebSocketService_js_1.webSocketService.sendToUser(String(userId), {
+                    type: 'data_changed',
+                    payload: {
+                        resource: finalResource,
+                        action,
+                        // 提供原始路径与方法，便于终端做更精细的判断或排查问题
+                        path: req.originalUrl,
+                        method: req.method,
+                        timestamp: Date.now(),
+                    },
+                }, { excludeClientId: getClientId(req) });
+            }
+        }
+        catch (error) {
+            logger.error('广播数据变更失败:', error);
+        }
+        return result;
+    };
+    next();
+}
+exports.broadcastDataChanges = broadcastDataChanges;
+/** 读取发起端的终端标识 */
+function getClientId(req) {
+    const header = req.headers['x-client-id'];
+    if (typeof header === 'string' && header)
+        return header;
+    const fromBody = req.body?.clientId;
+    return typeof fromBody === 'string' && fromBody ? fromBody : undefined;
+}

package/dist/routes/agent.js

@@ -440,7 +440,9 @@ router.post('/sessions/:sessionId/stream', ensureAgentManager, async (req, res)
     try {
         const userId = req.userId;
         const { sessionId } = req.params;
-        const { content, attachments, userMessageId, assistantMessageId } = req.body;
+        const { content, attachments, userMessageId, assistantMessageId, clientId } = req.body;
+        // 终端标识：用于把本次流事件同步给该用户的其他终端时排除发起端
+        const streamClientId = clientId || req.headers['x-client-id'] || undefined;
         if (!content && attachments.length === 0) {
             return res.status(400).json({ success: false, error: 'Content or attachments are required' });
         }
@@ -454,7 +456,7 @@ router.post('/sessions/:sessionId/stream', ensureAgentManager, async (req, res)
             res.setHeader('Connection', 'keep-alive');
             res.flushHeaders();
             // Stream response
-            await session.streamChat(content, attachments || [], res, userMessageId, assistantMessageId);
+            await session.streamChat(content, attachments || [], res, userMessageId, assistantMessageId, false, streamClientId);
             return;
         }
         res.status(404).json({ success: false, error: 'Session not found' });

package/dist/routes/auth.js

@@ -100,9 +100,8 @@ router.post('/refresh', async (req, res) => {
             res.status(400).json({ success: false, error: 'Missing refresh token' });
             return;
         }
-        // 刷新前先找到持有该 refreshToken 的旧 accessToken，用于定位记录
-        const oldToken = Array.from(index_js_2.authStore.getAll()?.values() ?? [])
-            .find(x => x.refreshToken === refreshToken)?.accessToken;
+        // 刷新前先找到持有该 refreshToken 的旧 accessToken，用于定位该终端的会话
+        const oldToken = index_js_2.authStore.getByRefreshToken(refreshToken)?.accessToken;
         const response = await index_js_1.authApi.refresh(refreshToken);
         // server 可能返回 {accessToken} 或 {data:{accessToken}}，两种都兼容
         const accessToken = response.data?.accessToken ?? response.accessToken;
@@ -139,7 +138,9 @@ router.post('/refresh', async (req, res) => {
 router.post('/logout', auth_js_1.requireAuth, async (req, res) => {
     const token = req.token;
     // 优先用客户端上报的 refreshToken，缺失时回退到 Gateway 本地持久化的那一个
-    const refreshToken = req.body?.refreshToken || index_js_2.authStore.getRefreshToken(req.userId) || undefined;
+    // 只登出当前终端：refreshToken 需按本次请求的 accessToken 定位，
+    // 否则会失效该用户在其他终端的会话
+    const refreshToken = req.body?.refreshToken || index_js_2.authStore.getRefreshTokenByToken(token) || undefined;
     try {
         if (refreshToken) {
             // 用 AsyncLocalStorage 将 token 注入 server 请求上下文；

package/dist/services/WebSocketService.js

@@ -6,12 +6,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webSocketService = void 0;
 const ws_1 = require("ws");
+const uuid_1 = require("uuid");
 const index_js_1 = require("../stores/index.js");
 const shared_1 = require("@myassis/shared");
 const Session_js_1 = require("./session/Session.js");
 const logger = (0, shared_1.getLogger)('WebSocketService');
 class WebSocketService {
     wss = null;
+    /** userId -> (连接 id -> 连接)：同一用户的多个终端可同时在线 */
     clients = new Map();
     heartbeatInterval = null;
     /**
@@ -31,30 +33,29 @@ class WebSocketService {
                 return;
             }
             const userId = clientKey;
-            logger.info(`用户 ${userId} 已连接`);
+            const connectionId = (0, uuid_1.v4)();
             const client = {
+                id: connectionId,
+                clientId: this.getQueryParam(req, 'clientId'),
                 ws,
                 userId,
                 connectedAt: Date.now(),
                 isAlive: true,
             };
-            // 如果同一用户已有连接，关闭旧连接
-            const existingClient = this.clients.get(userId);
-            if (existingClient && existingClient.ws.readyState === ws_1.WebSocket.OPEN) {
-                existingClient.ws.close(4002, 'Replaced by new connection');
-            }
-            this.clients.set(userId, client);
+            // 同一用户的多终端并存：按连接 id 保存，不再挤掉旧连接，
+            // 这样一个用户在不同终端都能收到同一份实时消息
+            const connections = this.getOrCreateConnections(userId);
+            connections.set(connectionId, client);
+            logger.info(`用户 ${userId} 已连接（当前连接数: ${connections.size}）`);
             // 心跳检测
             ws.on('pong', () => {
-                if (this.clients.has(userId)) {
-                    this.clients.get(userId).isAlive = true;
-                }
+                client.isAlive = true;
             });
             // 接收消息
             ws.on('message', (data) => {
                 try {
                     const message = JSON.parse(data.toString());
-                    this.handleMessage(userId, message);
+                    this.handleMessage(client, message);
                 }
                 catch {
                     logger.warn(`用户 ${userId} 发送了无效消息`);
@@ -62,35 +63,34 @@ class WebSocketService {
             });
             // 断开连接
             ws.on('close', () => {
-                logger.info(`用户 ${userId} 已断开`);
-                this.clients.delete(userId);
+                this.removeConnection(client);
+                logger.info(`用户 ${userId} 已断开（剩余连接数: ${this.getConnectionCount(userId)}）`);
             });
             ws.on('error', (error) => {
                 logger.error(`用户 ${userId} 连接错误:`, error);
-                this.clients.delete(userId);
+                this.removeConnection(client);
             });
             // 发送连接成功消息
-            this.sendToUser(userId, {
+            this.sendToConnection(client, {
                 type: 'connected',
                 payload: {
                     userId,
+                    connectionId,
                     timestamp: Date.now(),
                 },
             });
         });
         // 启动心跳检测
         this.heartbeatInterval = setInterval(() => {
-            this.wss.clients.forEach((ws) => {
-                const client = Array.from(this.clients.values()).find(c => c.ws === ws);
-                if (!client)
-                    return;
+            this.forEachConnection((client) => {
                 if (!client.isAlive) {
                     logger.info(`用户 ${client.userId} 心跳超时，断开`);
-                    this.clients.delete(client.userId);
-                    return ws.terminate();
+                    this.removeConnection(client);
+                    client.ws.terminate();
+                    return;
                 }
                 client.isAlive = false;
-                ws.ping();
+                client.ws.ping();
             });
         }, 30000);
         logger.info('WebSocket 服务已启动，路径: /ws');
@@ -103,12 +103,7 @@ class WebSocketService {
      */
     getClientKey(req) {
         // 优先从 URL 查询参数中提取 token
-        let token = null;
-        const url = req.url || '';
-        const match = url.match(/[?&]token=([^&]+)/);
-        if (match) {
-            token = decodeURIComponent(match[1]);
-        }
+        const token = this.getQueryParam(req, 'token');
         if (token) {
             const userId = index_js_1.authStore.getUserId(token);
             if (userId) {
@@ -117,13 +112,68 @@ class WebSocketService {
         }
         return null;
     }
+    /**
+     * 读取连接 URL 上的查询参数
+     */
+    getQueryParam(req, name) {
+        const url = req?.url || '';
+        const match = url.match(new RegExp(`[?&]${name}=([^&]+)`));
+        return match ? decodeURIComponent(match[1]) : undefined;
+    }
+    /**
+     * 获取（必要时创建）用户的连接集合
+     */
+    getOrCreateConnections(userId) {
+        let connections = this.clients.get(userId);
+        if (!connections) {
+            connections = new Map();
+            this.clients.set(userId, connections);
+        }
+        return connections;
+    }
+    /**
+     * 移除连接，用户没有连接后清理其条目
+     */
+    removeConnection(client) {
+        const connections = this.clients.get(client.userId);
+        if (!connections)
+            return;
+        connections.delete(client.id);
+        if (connections.size === 0) {
+            this.clients.delete(client.userId);
+        }
+    }
+    /**
+     * 遍历所有连接
+     */
+    forEachConnection(handler) {
+        this.clients.forEach((connections) => {
+            Array.from(connections.values()).forEach(handler);
+        });
+    }
+    /**
+     * 向单个连接发送消息
+     */
+    sendToConnection(client, message) {
+        if (client.ws.readyState !== ws_1.WebSocket.OPEN)
+            return false;
+        try {
+            client.ws.send(JSON.stringify(message));
+            return true;
+        }
+        catch (error) {
+            logger.error(`发送消息给用户 ${client.userId} 失败:`, error);
+            return false;
+        }
+    }
     /**
      * 处理客户端发来的消息
      */
-    handleMessage(userId, message) {
+    handleMessage(client, message) {
+        const userId = client.userId;
         switch (message.type) {
             case 'ping':
-                this.sendToUser(userId, { type: 'pong', payload: { timestamp: Date.now() } });
+                this.sendToConnection(client, { type: 'pong', payload: { timestamp: Date.now() } });
                 break;
             case 'subscribe':
                 logger.debug(`用户 ${userId} 订阅: ${message.payload?.channel || 'all'}`);
@@ -140,28 +190,41 @@ class WebSocketService {
         }
     }
     /**
-     * 向指定用户发送消息
+     * 向指定用户的所有终端发送消息
+     *
+     * 同一用户可能在多个终端登录，这里会广播给该用户的每个连接，
+     * 可通过 options.excludeClientId 跳过已经通过 SSE 收到事件的终端。
+     * 返回 true 表示至少有一个连接发送成功。
      */
-    sendToUser(userId, message) {
-        const client = this.clients.get(String(userId));
-        if (!client || client.ws.readyState !== ws_1.WebSocket.OPEN) {
-            return false;
-        }
-        try {
-            client.ws.send(JSON.stringify(message));
-            return true;
-        }
-        catch (error) {
-            logger.error(`发送消息给用户 ${userId} 失败:`, error);
+    sendToUser(userId, message, options = {}) {
+        const connections = this.clients.get(String(userId));
+        if (!connections || connections.size === 0) {
             return false;
         }
+        let sent = false;
+        Array.from(connections.values()).forEach((client) => {
+            if (options.excludeClientId && client.clientId === options.excludeClientId) {
+                return;
+            }
+            sent = this.sendToConnection(client, message) || sent;
+        });
+        return sent;
     }
     /**
-     * 检查用户是否在线
+     * 检查用户是否在线（任一终端在线即视为在线）
      */
     isUserOnline(userId) {
-        const client = this.clients.get(String(userId));
-        return !!client && client.ws.readyState === ws_1.WebSocket.OPEN;
+        return this.getConnectionCount(userId) > 0;
+    }
+    /**
+     * 获取用户当前的在线连接数
+     */
+    getConnectionCount(userId) {
+        const connections = this.clients.get(String(userId));
+        if (!connections)
+            return 0;
+        return Array.from(connections.values())
+            .filter((client) => client.ws.readyState === ws_1.WebSocket.OPEN).length;
     }
     /**
      * 发送任务通知
@@ -212,7 +275,7 @@ class WebSocketService {
      */
     broadcast(message) {
         const data = JSON.stringify(message);
-        this.clients.forEach((client) => {
+        this.forEachConnection((client) => {
             if (client.ws.readyState === ws_1.WebSocket.OPEN) {
                 try {
                     client.ws.send(data);
@@ -243,7 +306,7 @@ class WebSocketService {
             clearInterval(this.heartbeatInterval);
             this.heartbeatInterval = null;
         }
-        this.clients.forEach((client) => {
+        this.forEachConnection((client) => {
             client.ws.close(1001, 'Server shutting down');
         });
         this.clients.clear();

package/dist/services/dataService.js

@@ -54,8 +54,8 @@ exports.authService = {
     },
     // 登出
     logout: async (token, refreshToken) => {
-        const userId = index_js_2.authStore.getUserId(token);
-        const revokeToken = refreshToken || (userId ? index_js_2.authStore.getRefreshToken(userId) : null);
+        // 按 accessToken 定位当前终端的 refreshToken，避免踢掉其他终端
+        const revokeToken = refreshToken || index_js_2.authStore.getRefreshTokenByToken(token);
         if (revokeToken) {
             try {
                 await index_js_1.authApi.logout(revokeToken, token);
@@ -76,12 +76,11 @@ exports.authService = {
     // 删除账号
     deleteAccount: (password, token) => index_js_1.authApi.deleteAccount({ password }, token),
     // 获取当前用户（从内存）
-    getUser: (token) => index_js_2.authStore.get(token)?.user || null,
+    getUser: (token) => index_js_2.authStore.getByToken(token)?.user || null,
     // 刷新 Token
     refresh: async (refreshToken) => {
-        // 刷新前先定位旧 accessToken
-        const oldToken = Array.from(index_js_2.authStore.getAll()?.values() ?? [])
-            .find(x => x.refreshToken === refreshToken)?.accessToken;
+        // 刷新前先定位该终端的旧 accessToken
+        const oldToken = index_js_2.authStore.getByRefreshToken(refreshToken)?.accessToken;
         const response = await index_js_1.authApi.refresh(refreshToken);
         const accessToken = response.data?.accessToken ?? response.accessToken;
         const newRefreshToken = response.data?.refreshToken ?? response.refreshToken;

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();
 /**
@@ -501,9 +508,21 @@ class Session {
      * 用动态 import 获取 webSocketService：WebSocketService 反向依赖本文件的
      * handleApprovalResponse，静态引入会形成循环依赖。
      */
-    async notifyPlanUpdate() {
+    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: {
@@ -587,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;
@@ -615,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 {
@@ -636,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 等必要字段)

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.83",
+  "version": "1.0.84",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {