@myassis/gateway 1.0.86 → 1.0.88

package/dist/api/index.js

@@ -16,6 +16,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.settingsApi = exports.tasksApi = exports.modelsApi = exports.skillHubApi = exports.skillsApi = exports.authApi = exports.ApiError = exports.getServerBaseUrl = exports.getRequestToken = exports.runWithToken = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const async_hooks_1 = require("async_hooks");
+const index_js_1 = require("../config/index.js");
 // 多用户模式请求上下文：存储当前请求的 token
 const requestContext = new async_hooks_1.AsyncLocalStorage();
 function runWithToken(token, fn) {
@@ -32,8 +33,10 @@ function getServerBaseUrl() {
     return SERVER_BASE_URL;
 }
 exports.getServerBaseUrl = getServerBaseUrl;
-// Server 服务地址（从环境变量读取）
-const SERVER_BASE_URL = process.env.SERVER_BASE_URL || 'http://localhost:3000';
+// Server 服务地址。必须走 appConfig：这里曾经自己又写了一个
+// `|| 'http://localhost:3000'` 的默认值，与 config 里的 9091 分裂成两个事实，
+// 结果是同一个网关进程里业务 API 和其他模块连到不同地址。
+const SERVER_BASE_URL = index_js_1.appConfig.serverBaseUrl;
 // 签名密钥（用于请求签名）
 const SIGN_KEY = process.env.API_SIGN_KEY || 'gateway-secret-key';
 // API 响应错误类

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/config/index.js

@@ -65,19 +65,31 @@ const envPath = getEnvPath();
 if (envPath) {
     (0, dotenv_1.config)({ path: envPath });
     logger.info(`已加载环境变量文件: ${envPath}`);
+    logger.info(`当前工作目录: ${process.cwd()}`);
 }
 else {
-    logger.info('未找到 .env 文件，使用系统环境变量');
+    logger.info(`未找到 .env 文件（工作目录: ${process.cwd()}），使用系统环境变量`);
 }
 // pkg 打包后自动设为 production
 const isPackaged = !!process.pkg;
 const defaultEnv = isPackaged ? 'production' : 'development';
+/**
+ * Server 地址的环境默认值。
+ *
+ * 生产一律连云端域名，开发连本机。之前无论哪种环境都写死回落
+ * localhost，于是安装版一旦没注入 SERVER_BASE_URL 就默默去连本机，
+ * 表现为登录 500 「网络请求失败」—— 一个没有任何提示的错配。
+ */
+const PROD_SERVER_BASE_URL = 'https://api.my-assis.com';
+const DEV_SERVER_BASE_URL = 'http://localhost:9091';
+const resolvedNodeEnv = process.env.NODE_ENV || defaultEnv;
+const defaultServerBaseUrl = resolvedNodeEnv === 'production' ? PROD_SERVER_BASE_URL : DEV_SERVER_BASE_URL;
 // 环境变量配置
 exports.appConfig = {
-    serverBaseUrl: process.env.SERVER_BASE_URL || 'http://localhost:9091',
+    serverBaseUrl: (process.env.SERVER_BASE_URL || defaultServerBaseUrl).replace(/\/+$/, ''),
     port: parseInt(process.env.PORT || '3001', 10),
     clientUrl: process.env.CLIENT_URL || 'http://localhost:3000',
-    nodeEnv: process.env.NODE_ENV || defaultEnv,
+    nodeEnv: resolvedNodeEnv,
     messageKeep: 4,
     /** 摘要后保留的原始历史消息条数 */
     historyKeep: parseInt(process.env.HISTORY_KEEP || '4', 10),
@@ -99,4 +111,17 @@ exports.appConfig = {
     summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '60000', 10),
     appName: '我的助手'
 };
+/**
+ * 启动时把实际生效的关键配置打出来。
+ *
+ * 之前只记了「已加载环境变量文件」，却不说最终跑的是哪个地址。
+ * 结果是生产服务误读开发 .env、连到局域网 IP 时，日志里毫无线索，
+ * 只能从一句登录 500「网络请求失败」倒推。
+ *
+ * 标注来源（env / 默认值）是故意的：「地址对不对」和
+ * 「地址是谁给的」是两个问题，后者才能区分「.env 没读到」与「.env 写错了」。
+ */
+logger.info(`生效配置: env=${exports.appConfig.nodeEnv}, port=${exports.appConfig.port}, ` +
+    `serverBaseUrl=${exports.appConfig.serverBaseUrl}` +
+    ` (${process.env.SERVER_BASE_URL ? '来自 SERVER_BASE_URL' : '环境默认值'})`);
 exports.default = exports.appConfig;

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/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

@@ -108,14 +108,20 @@ function getGatewayArgs() {
 /**
  * Gateway 运行的工作目录。
  *
- * 非打包模式下不能用 node.exe 所在目录（例如 C:\Program Files\nodejs），
- * 否则相对路径资源与数据目录定位都会错；应该用包目录。
+ * - 打包为 exe：exe 所在目录；
+ * - node 启动：入口脚本（dist/index.js）所在目录，即 dist。
+ *
+ * 两者都是「产物所在目录」，于是 getEnvPath() 的第一条规则
+ * `process.cwd()/.env` 恰好命中随产物发布的 dist/.env（生产配置）。
+ *
+ * 不能再向上退一层到「包根」：包根下躺着开发用的 .env，
+ * 生产服务会因此读到 SERVER_BASE_URL=局域网 IP，且毫无提示（见 f126be961）。
  */
 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);
+    return script ? path_1.default.dirname(script) : path_1.default.dirname(process.execPath);
 }
 /**
  * 检查 Gateway 进程是否在运行