@myassis/gateway 1.0.82 → 1.0.84

package/dist/main.js

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