@myassis/gateway 1.0.85 → 1.0.87

package/dist/config/capabilities.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Gateway 能力位
+ *
+ * Desktop 需要在连接前知道当前网关支持哪些链路能力，
+ * 才能决定是否展示「中继模式」入口、以及是否提示用户升级网关。
+ * 能力位通过 /health 暴露（无需鉴权，Desktop 在登录前即可探测）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeatures = exports.getRelayStatus = exports.RELAY_SUPPORTED = exports.RELAY_PROTOCOL_VERSION = void 0;
+const RelayClient_js_1 = require("../services/relay/RelayClient.js");
+const relayConfig_js_1 = require("../services/relay/relayConfig.js");
+const protocol_js_1 = require("../services/relay/protocol.js");
+Object.defineProperty(exports, "RELAY_PROTOCOL_VERSION", { enumerable: true, get: function () { return protocol_js_1.RELAY_PROTOCOL_VERSION; } });
+/**
+ * 本网关是否已内置中继客户端实现。
+ * 与 RelayClient 的存在与否绑定；Desktop 据此判断是否展示中继入口。
+ */
+exports.RELAY_SUPPORTED = true;
+/** 汇总中继状态 */
+function getRelayStatus() {
+    const credential = (0, relayConfig_js_1.getRelayCredential)();
+    const status = RelayClient_js_1.relayClient.getStatus();
+    return {
+        supported: exports.RELAY_SUPPORTED,
+        enabled: (0, relayConfig_js_1.isRelayEnabled)(),
+        connected: status.connected,
+        paired: credential !== null,
+        // gatewayId 是中继寻址标识，未配对时不暴露空串以免前端误判为已配对
+        gatewayId: credential?.gatewayId,
+        protocolVersion: protocol_js_1.RELAY_PROTOCOL_VERSION,
+    };
+}
+exports.getRelayStatus = getRelayStatus;
+/**
+ * 能力位列表。
+ * 采用 `名称@版本` 形式，便于 Desktop 做区间兼容判断。
+ */
+function getFeatures() {
+    const features = ['direct@1'];
+    if (exports.RELAY_SUPPORTED) {
+        features.push(`relay@${protocol_js_1.RELAY_PROTOCOL_VERSION}`);
+    }
+    return features;
+}
+exports.getFeatures = getFeatures;

package/dist/main.js

@@ -10,6 +10,7 @@ const helmet_1 = __importDefault(require("helmet"));
 const compression_1 = __importDefault(require("compression"));
 const http_1 = __importDefault(require("http"));
 const index_js_1 = require("./config/index.js");
+const capabilities_js_1 = require("./config/capabilities.js");
 const shared_1 = require("@myassis/shared");
 const auth_js_1 = __importDefault(require("./routes/auth.js"));
 const agent_js_1 = __importDefault(require("./routes/agent.js"));
@@ -24,12 +25,14 @@ const tasks_js_1 = __importDefault(require("./routes/tasks.js"));
 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 relay_js_1 = __importDefault(require("./routes/relay.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 RelayClient_js_1 = require("./services/relay/RelayClient.js");
 const ServiceManager_js_1 = require("./services/ServiceManager.js");
 const logger = (0, shared_1.getLogger)('index');
 // 内置放通的官方域名（含子域名），无需用户手动 addCors
@@ -165,26 +168,26 @@ 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          显示本帮助信息
 `);
             }
             else {
@@ -272,7 +275,15 @@ else {
     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({
+            status: 'ok',
+            service: 'gateway',
+            version: '2.0.0',
+            wsOnline: WebSocketService_js_1.webSocketService.getOnlineCount(),
+            // 能力位：Desktop 据此决定是否展示中继入口、是否提示升级网关
+            features: (0, capabilities_js_1.getFeatures)(),
+            relay: (0, capabilities_js_1.getRelayStatus)(),
+        });
     });
     // 写请求成功后向该用户的其他终端广播数据变更（多终端同步）。
     // 必须注册在业务路由之前：它通过包装 res.json 生效。
@@ -291,6 +302,7 @@ else {
     app.use('/api/v1/upload', upload_js_1.default);
     app.use('/api/v1/version', version_js_1.default);
     app.use('/api/v1/quota', quota_js_1.default);
+    app.use('/api/v1/relay', relay_js_1.default);
     // Load auth from persistent storage on startup
     index_js_2.authStore.load();
     // Error handler
@@ -301,9 +313,17 @@ else {
     const configuredPort = index_js_1.appConfig.port;
     let schedulerStarted = false;
     let webSocketInitialized = false;
+    let relayStarted = false;
     const startServer = (port) => {
         const handleListenError = (err) => {
             server.removeListener('error', handleListenError);
+            // 关键：listen(port, cb) 以 once('listening') 注册 cb，而端口占用走的是 error
+            // 事件，cb 并不会被移除、会一直挂在同一个 server 上。不在这里摘掉的话，
+            // 下一个端口监听成功时**上一次的 cb 也会触发**，且其闭包里的 port 是旧值。
+            // 实测症状：先打印「running on port 3001」再打印「3001 被占用，回退 3002」，
+            // 并把 3001 当作实际端口交给中继回环，请求于是被转发到同机的另一个网关进程
+            // （隧道在线、/health 正常，但所有 /api/v1/* 返回 404）。
+            server.removeListener('listening', handleListening);
             if (err.code === 'EADDRINUSE') {
                 const nextPort = port + 1;
                 if (nextPort <= (configuredPort + 10)) {
@@ -319,14 +339,17 @@ else {
             logger.error(`Server error: ${err.message}`);
             process.exit(1);
         };
-        server.once('error', handleListenError);
-        server.listen(port, () => {
+        const handleListening = () => {
             server.removeListener('error', handleListenError);
-            if (port !== configuredPort) {
-                logger.info(`Port ${configuredPort} is in use, fallback to port ${port}`);
+            // 实际端口只认 server.address()：闭包里的 port 只是「这次尝试的端口」，不等于
+            // 「最终监听的端口」。回环转发与 WS 广播都依赖它，取错就会打到别的进程上。
+            const address = server.address();
+            const actualPort = typeof address === 'object' && address ? address.port : port;
+            if (actualPort !== configuredPort) {
+                logger.info(`Port ${configuredPort} is in use, fallback to port ${actualPort}`);
             }
             // 动态更新 appConfig.port（供 WebSocket 广播实际端口）
-            index_js_1.appConfig.port = port;
+            index_js_1.appConfig.port = actualPort;
             // HTTP Server 监听成功后再初始化 WebSocket，避免端口冲突时 WebSocketServer 误报 EADDRINUSE
             if (!webSocketInitialized) {
                 WebSocketService_js_1.webSocketService.initialize(server);
@@ -337,16 +360,27 @@ else {
                 TaskSchedulerService_js_1.taskSchedulerService.start();
                 schedulerStarted = true;
             }
-            logger.info(`我的助手 Gateway Service running on port ${port}`);
+            // 中继客户端必须在此启动而非模块顶层：回环转发需要**实际**监听端口，
+            // 而端口存在被占用后自动顺延的逻辑（3001 → 3002…），配置值不可信。
+            if (!relayStarted) {
+                RelayClient_js_1.relayClient.start(actualPort);
+                relayStarted = true;
+            }
+            logger.info(`我的助手 Gateway Service running on port ${actualPort}`);
             // 启动自愈：检查开机自启 Run key 是否健康，不健康则自动 rewrite。
             // 异步执行，失败不影响主流程。
             (0, ServiceManager_js_1.ensureAutoStartHealthy)().catch(() => { });
-        });
+        };
+        server.once('error', handleListenError);
+        server.once('listening', handleListening);
+        server.listen(port);
     };
     startServer(configuredPort);
     // 优雅关闭
     process.on('SIGTERM', () => {
         logger.info('收到 SIGTERM，正在关闭...');
+        // 先停中继：让远端客户端立刻收到明确的流中止，而不是等隧道超时
+        RelayClient_js_1.relayClient.stop('网关正在关闭');
         WebSocketService_js_1.webSocketService.shutdown();
         TaskSchedulerService_js_1.taskSchedulerService.stop();
         server.close(() => {
@@ -356,6 +390,8 @@ else {
     });
     process.on('SIGINT', () => {
         logger.info('收到 SIGINT，正在关闭...');
+        // 先停中继：让远端客户端立刻收到明确的流中止，而不是等隧道超时
+        RelayClient_js_1.relayClient.stop('网关正在关闭');
         WebSocketService_js_1.webSocketService.shutdown();
         TaskSchedulerService_js_1.taskSchedulerService.stop();
         server.close(() => {

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

package/dist/routes/auth.js

@@ -7,6 +7,7 @@ const auth_js_1 = require("../middleware/auth.js");
 const index_js_3 = require("../api/index.js");
 const shared_1 = require("@myassis/shared");
 const system_js_1 = require("@myassis/shared/dist/utils/system.js");
+const relayConfig_js_1 = require("../services/relay/relayConfig.js");
 const logger = (0, shared_1.getLogger)('auth');
 const router = (0, express_1.Router)();
 // Get publish token - 获取发布技能库所需的 token
@@ -201,4 +202,81 @@ router.post('/account/delete', auth_js_1.requireAuth, async (req, res) => {
         });
     }
 });
+/**
+ * POST /api/v1/auth/adopt-token
+ *
+ * 让网关「采信」一个由 Server 签发的 accessToken。
+ *
+ * 为什么需要它：中继模式下 Desktop 无法向网关登录 —— 网关的 /auth/login 会把
+ * 凭据转发给 Server 换 token，但走中继访问网关本身就要求先有 Server 的 JWT，
+ * 形成死锁。同时网关的 requireAuth 只认自己 authStore 里的 token，
+ * 因此即便 Desktop 直接向 Server 登录成功，后续中继请求在网关侧仍是 401。
+ *
+ * 解法：Desktop 在中继模式下直连 Server 登录（Server 本就是签发方），
+ * 再用拿到的 token 调本接口，由网关向 Server 验签并确认属主后写入 authStore。
+ *
+ * 三道防线（缺一不可）：
+ * 1. 本接口不能用 requireAuth（此时 token 尚未被采信），改为向 Server 的
+ *    /auth/me 验签 —— 网关不持有 JWT_SECRET，无法自行验签，这与既有设计一致；
+ * 2. 校验 token 属主必须等于配对时记录的 userId。否则任何知道 gatewayId 的人
+ *    都能用自己的账号让别人的网关采信自己的 token，等于远程登录别人的电脑；
+ * 3. 走中继到达这里的请求，已先被 Server 的 hasGatewayAccess 拦过一层授权。
+ */
+router.post('/adopt-token', async (req, res) => {
+    try {
+        const { accessToken, refreshToken, expiresIn } = req.body ?? {};
+        if (typeof accessToken !== 'string' || !accessToken) {
+            res.status(400).json({ success: false, error: 'Missing accessToken' });
+            return;
+        }
+        const credential = (0, relayConfig_js_1.getRelayCredential)();
+        if (!credential) {
+            // 未配对的网关不应接受任何令牌注入：此时没有「属主」可供比对
+            res.status(403).json({ success: false, error: 'Gateway is not paired' });
+            return;
+        }
+        // 向 Server 验签并取得该 token 的真实属主
+        let user;
+        try {
+            const me = await (0, index_js_3.runWithToken)(accessToken, () => index_js_1.authApi.me(accessToken));
+            user = me?.data ?? me?.user;
+        }
+        catch (error) {
+            logger.warn('adopt-token 验签失败:', error?.message);
+            res.status(401).json({ success: false, error: 'Invalid token' });
+            return;
+        }
+        if (!user?.id) {
+            res.status(401).json({ success: false, error: 'Invalid token' });
+            return;
+        }
+        // 属主校验：只有配对该网关的用户能让它采信自己的令牌。
+        // 注意这里必须对「userId 缺失」也拒绝，而不是用 `credential.userId &&` 短路 ——
+        // 否则一条没有属主的旧凭据（早期版本遗留，或 persistStore 被手工改过）
+        // 会让本接口退化成「任何人都能注入令牌」，属于典型的 fail-open。
+        if (!credential.userId || String(user.id) !== String(credential.userId)) {
+            logger.warn(`adopt-token 属主校验失败: token=${user.id} paired=${credential.userId ?? '(缺失)'}`);
+            // 与越权访问返回同样笼统的 403，不透出属主信息
+            res.status(403).json({ success: false, error: 'Forbidden' });
+            return;
+        }
+        index_js_2.authStore.save({
+            accessToken,
+            refreshToken: typeof refreshToken === 'string' ? refreshToken : undefined,
+            expiresIn: typeof expiresIn === 'number' ? expiresIn : undefined,
+            expiresAt: typeof expiresIn === 'number' ? Date.now() + expiresIn * 1000 : undefined,
+            user: {
+                id: String(user.id),
+                nickname: String(user.nickname ?? user.account ?? ''),
+                account: String(user.account ?? ''),
+            },
+        });
+        logger.info(`已采信中继登录令牌 user=${user.id}`);
+        res.json({ success: true, data: { user } });
+    }
+    catch (error) {
+        logger.error('adopt-token error:', error);
+        res.status(500).json({ success: false, error: error.message || 'adopt-token failed' });
+    }
+});
 exports.default = router;

package/dist/routes/relay.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * 中继管理路由
+ *
+ * 供 Desktop 在**直连模式下**管理中继：查看状态、开关、与 Server 完成配对。
+ * 注意配对必须先直连一次网关来完成（需要用户在本机确认），
+ * 这是「知道 gatewayId 就能远程敲别人电脑」的核心防线。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumePairCode = void 0;
+const express_1 = require("express");
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+const shared_1 = require("@myassis/shared");
+const auth_js_1 = require("../middleware/auth.js");
+const RelayClient_js_1 = require("../services/relay/RelayClient.js");
+const relayConfig_js_1 = require("../services/relay/relayConfig.js");
+const protocol_js_1 = require("../services/relay/protocol.js");
+const logger = (0, shared_1.getLogger)('routes/relay');
+const router = (0, express_1.Router)();
+/** 配对码有效期：足够用户在另一台设备上输入，又不至于长期可用 */
+const PAIR_CODE_TTL_MS = 5 * 60 * 1000;
+/**
+ * 一次性配对码（仅存内存）。
+ * 不落盘是有意的：网关重启后旧码即失效，减少泄露窗口。
+ */
+let pairCode = null;
+/** 生成 6 位数字配对码，用 crypto 而非 Math.random 避免可预测 */
+function generatePairCode() {
+    return String(crypto_1.default.randomInt(0, 1000000)).padStart(6, '0');
+}
+/**
+ * GET /api/v1/relay/status
+ * 中继状态。不需要鉴权：Desktop 在登录前也要据此决定展示哪些入口。
+ */
+router.get('/status', (req, res) => {
+    const status = RelayClient_js_1.relayClient.getStatus();
+    res.json({
+        success: true,
+        data: {
+            enabled: (0, relayConfig_js_1.isRelayEnabled)(),
+            paired: (0, relayConfig_js_1.getRelayCredential)() !== null,
+            relayUrl: (0, relayConfig_js_1.getRelayBaseUrl)(),
+            protocolVersion: protocol_js_1.RELAY_PROTOCOL_VERSION,
+            ...status,
+        },
+    });
+});
+/**
+ * POST /api/v1/relay/pair
+ * 与 Server 完成配对：用当前登录用户的 token 注册本网关，换回 gatewayId 与 secret。
+ */
+router.post('/pair', auth_js_1.requireAuth, async (req, res) => {
+    try {
+        const relayUrl = (0, relayConfig_js_1.getRelayBaseUrl)();
+        if (!relayUrl) {
+            res.status(500).json({ success: false, error: '未配置中继入口地址（RELAY_URL / SERVER_BASE_URL）' });
+            return;
+        }
+        const name = typeof req.body?.name === 'string' && req.body.name.trim()
+            ? req.body.name.trim()
+            : `${process.platform}-gateway`;
+        const response = await axios_1.default.post(`${relayUrl}/api/v1/gateways/register`, { name, platform: process.platform, version: getLocalVersion() }, {
+            timeout: 15000,
+            headers: { Authorization: `Bearer ${req.token}`, 'Content-Type': 'application/json' },
+        });
+        const data = response.data?.data;
+        if (!data?.gatewayId || !data?.secret) {
+            res.status(502).json({ success: false, error: 'Server 未返回有效的配对凭据' });
+            return;
+        }
+        // 属主必须记下来：它是 adopt-token 判断「谁有权让本网关采信令牌」的唯一依据。
+        // requireAuth 正常情况下一定填了 req.userId，但这里不做乐观假设 —— 一条缺属主的
+        // 凭据会让后续属主校验失去依据，宁可当场失败。
+        if (!req.userId) {
+            res.status(500).json({ success: false, error: '无法确定配对用户，请重新登录后再试' });
+            return;
+        }
+        (0, relayConfig_js_1.setRelayCredential)({
+            gatewayId: data.gatewayId,
+            secret: data.secret,
+            pairedAt: Date.now(),
+            userId: String(req.userId),
+        });
+        logger.info(`配对成功 gatewayId=${data.gatewayId}`);
+        // 配对不隐含开启：是否启用外网可达仍交由用户显式决定
+        res.json({ success: true, data: { gatewayId: data.gatewayId, enabled: (0, relayConfig_js_1.isRelayEnabled)() } });
+    }
+    catch (error) {
+        logger.error('配对失败:', error);
+        res.status(error.response?.status || 500).json({
+            success: false,
+            error: error.response?.data?.error || error.message || '配对失败',
+        });
+    }
+});
+/**
+ * POST /api/v1/relay/enable
+ * 开启中继并立即建连。
+ */
+router.post('/enable', auth_js_1.requireAuth, (req, res) => {
+    if (!(0, relayConfig_js_1.getRelayCredential)()) {
+        res.status(400).json({ success: false, error: '尚未配对，请先调用 /relay/pair' });
+        return;
+    }
+    (0, relayConfig_js_1.setRelayEnabled)(true);
+    RelayClient_js_1.relayClient.enable();
+    res.json({ success: true, data: RelayClient_js_1.relayClient.getStatus() });
+});
+/**
+ * POST /api/v1/relay/disable
+ * 关闭中继并断开隧道。
+ */
+router.post('/disable', auth_js_1.requireAuth, (req, res) => {
+    (0, relayConfig_js_1.setRelayEnabled)(false);
+    RelayClient_js_1.relayClient.stop('用户关闭中继');
+    res.json({ success: true, data: RelayClient_js_1.relayClient.getStatus() });
+});
+/**
+ * POST /api/v1/relay/unpair
+ * 解绑：清除本地凭据并断开。Server 侧吊销由 Desktop 另行调用，
+ * 此处不代劳——网关可能已无法访问 Server，不能因此阻塞本地清理。
+ */
+router.post('/unpair', auth_js_1.requireAuth, (req, res) => {
+    (0, relayConfig_js_1.setRelayEnabled)(false);
+    RelayClient_js_1.relayClient.stop('已解绑');
+    (0, relayConfig_js_1.clearRelayCredential)();
+    res.json({ success: true });
+});
+/**
+ * POST /api/v1/relay/pair-code
+ * 生成一次性配对码，供用户在新设备（尤其是网页版）上确认接入。
+ */
+router.post('/pair-code', auth_js_1.requireAuth, (req, res) => {
+    pairCode = { code: generatePairCode(), expiresAt: Date.now() + PAIR_CODE_TTL_MS };
+    res.json({ success: true, data: { code: pairCode.code, expiresAt: pairCode.expiresAt } });
+});
+/**
+ * 校验配对码（供中继链路上的接入确认使用）。
+ * 一次性：校验通过即失效，避免被重复利用。
+ */
+function consumePairCode(code) {
+    if (!pairCode)
+        return false;
+    if (Date.now() > pairCode.expiresAt) {
+        pairCode = null;
+        return false;
+    }
+    // 定长比较，避免通过响应时间侧信道逐位猜测
+    const ok = code.length === pairCode.code.length &&
+        crypto_1.default.timingSafeEqual(Buffer.from(code), Buffer.from(pairCode.code));
+    if (ok)
+        pairCode = null;
+    return ok;
+}
+exports.consumePairCode = consumePairCode;
+/** 读取网关自身版本 */
+function getLocalVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { readFileSync } = require('fs');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { resolve } = require('path');
+        return JSON.parse(readFileSync(resolve(__dirname, '../../package.json'), 'utf-8')).version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+exports.default = router;

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);