@myassis/gateway 1.0.82 → 1.0.84

package/dist/services/ServiceManager.js

@@ -112,65 +112,168 @@ function getStoredPid() {
  *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
  *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
  */
-async function stopGatewayProcess() {
-    const pid = getStoredPid();
-    if (!pid)
+/**
+ * 探测进程是否存活（signal 0 不会真的发信号）
+ */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 轮询等待指定进程退出，返回是否已退出
+ */
+async function waitForPidExit(pid, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!isPidAlive(pid))
+            return true;
+        await new Promise(r => setTimeout(r, 200));
+    }
+    return !isPidAlive(pid);
+}
+/**
+ * 读取守护进程 PID
+ */
+function getDaemonPid() {
+    try {
+        if (!fs_1.default.existsSync(GATEWAY_DAEMON_PID_FILE))
+            return null;
+        // 去除 PowerShell Out-File -Encoding UTF8 写入的 BOM，否则 parseInt 会得到 NaN
+        const raw = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 结束守护进程（运行 launcher.ps1 的那个 PowerShell）
+ *
+ * 必须在结束 gateway 之前调用：守护进程每 5s 轮询一次，若发现 gateway 已退出
+ * 且此刻停止标记不存在，就会立即重新拉起，表现为「stop 之后网关又活了」。
+ */
+async function stopDaemonProcess() {
+    if (process.platform !== 'win32')
         return;
-    // —— 场景 1：要停的就是自己 —— 走优雅退出
-    if (pid === process.pid) {
+    const daemonPid = getDaemonPid();
+    if (daemonPid && daemonPid !== process.pid && isPidAlive(daemonPid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+            process.kill(daemonPid, 'SIGTERM');
         }
         catch { /* ignore */ }
-        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
-        setTimeout(() => {
+        if (!(await waitForPidExit(daemonPid, 3000))) {
             try {
-                process.emit('SIGTERM');
+                process.kill(daemonPid, 'SIGKILL');
             }
             catch { /* ignore */ }
-            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
-            setTimeout(() => process.exit(0), 5000).unref();
-        }, 100).unref();
-        return;
-    }
-    // —— 场景 2：停的是别人（孤儿进程 / 旧实例）—— 才真正发信号
-    try {
-        process.kill(pid, 'SIGTERM');
-        await new Promise(r => setTimeout(r, 2000));
+            await waitForPidExit(daemonPid, 2000);
+        }
     }
-    catch { /* ignore */ }
-    // 强制终止（如果还没退出）
     try {
-        process.kill(pid, 'SIGKILL');
+        fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
     }
     catch { /* ignore */ }
+}
+/**
+ * PID 文件丢失/过期时的兜底：按 exe 路径匹配并结束 gateway 进程
+ *
+ * PID 文件位于 %TEMP%，可能被系统清理策略删除，此时仅靠 PID 会漏杀。
+ * 仅在打包为 exe 时启用：开发模式下 execPath 是 node.exe，按路径匹配会误杀其它 Node 进程。
+ */
+async function stopGatewayByExePath() {
+    if (process.platform !== 'win32' || !isPackagedExe())
+        return 0;
+    const exe = process.execPath;
+    const name = path_1.default.basename(exe, path_1.default.extname(exe));
+    const q = (v) => v.replace(/'/g, "''");
     try {
-        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
-    }
-    catch { /* ignore */ }
-    // 同时杀掉守护进程（防止它重新拉起 gateway）
-    if (process.platform === 'win32') {
-        try {
-            const daemonPidStr = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
-            const daemonPid = parseInt(daemonPidStr, 10);
-            if (daemonPid && !isNaN(daemonPid)) {
-                try {
-                    process.kill(daemonPid, 'SIGTERM');
-                }
-                catch { /* ignore */ }
-                await new Promise(r => setTimeout(r, 500));
+        const { stdout } = await execAsync(`powershell -NoProfile -Command "Get-Process -Name '${q(name)}' -ErrorAction SilentlyContinue | ` +
+            `Where-Object { $_.Id -ne ${process.pid} -and $_.Path -ieq '${q(exe)}' } | ` +
+            `ForEach-Object { $_.Id }"`, { timeout: 10000, windowsHide: true });
+        const pids = stdout.split(/\r?\n/)
+            .map(line => parseInt(line.trim(), 10))
+            .filter(n => !isNaN(n) && n !== process.pid);
+        for (const orphan of pids) {
+            try {
+                process.kill(orphan, 'SIGTERM');
+            }
+            catch { /* ignore */ }
+            if (!(await waitForPidExit(orphan, 3000))) {
                 try {
-                    process.kill(daemonPid, 'SIGKILL');
+                    process.kill(orphan, 'SIGKILL');
                 }
                 catch { /* ignore */ }
             }
         }
+        return pids.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 停止 Gateway 用户进程（优雅终止）
+ *
+ * 注意：当 pid 指向当前进程自己时，绝不能使用 process.kill(pid)。
+ *   - Windows 上 Node 的 process.kill 等同 TerminateProcess，无清理机会，
+ *     server.close() / WebSocket / 文件句柄都不会被释放，会导致后续 exe 解锁超时。
+ *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
+ *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
+ *
+ * 返回：self 表示停的是当前进程（无法在本进程内校验最终结果），
+ *       stopped 表示已确认目标进程退出。
+ */
+async function stopGatewayProcess() {
+    const pid = getStoredPid();
+    // 先断开守护进程，否则它会在 gateway 退出后立刻把它重新拉起
+    await stopDaemonProcess();
+    // —— 场景 1：要停的就是自己 —— 走优雅退出
+    if (pid && pid === process.pid) {
+        try {
+            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+        }
         catch { /* ignore */ }
+        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
+        setTimeout(() => {
+            try {
+                process.emit('SIGTERM');
+            }
+            catch { /* ignore */ }
+            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
+            setTimeout(() => process.exit(0), 5000).unref();
+        }, 100).unref();
+        return { stopped: true, self: true };
+    }
+    // —— 场景 2：停的是别人（CLI 停后台实例 / 孤儿进程）—— 才真正发信号
+    let stopped = true;
+    if (pid && isPidAlive(pid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+            process.kill(pid, 'SIGTERM');
         }
         catch { /* ignore */ }
+        stopped = await waitForPidExit(pid, 5000);
+        if (!stopped) {
+            // 优雅关闭超时，强制终止
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch { /* ignore */ }
+            stopped = await waitForPidExit(pid, 3000);
+        }
     }
+    try {
+        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+    }
+    catch { /* ignore */ }
+    // 兜底：清理没被 PID 文件记录到的残留进程
+    await stopGatewayByExePath();
+    return { stopped, self: false };
 }
 /**
  * 写入 Gateway 启动脚本（用户级，不弹出窗口）
@@ -226,8 +329,14 @@ function writeGatewayLauncherScript(exePath, scriptPath, workDir) {
         '# 守护循环：监控进程状态，异常退出则自动重启',
         'while ($true) {',
         '  try {',
-        '    # 每 5 秒检查一次进程是否仍在运行',
-        '    Start-Sleep -Seconds 5',
+        '    # 每 1 秒检查一次：轮询间隔过长会错过 stop 写入的停止标记，导致误重启',
+        '    Start-Sleep -Seconds 1',
+        '',
+        '    # 优先判定停止标记：无论 gateway 是否已退出，主动停止时守护都应该退出',
+        '    if (Test-Path $stopFlag) {',
+        "      Write-Log '检测到停止标记，守护进程退出'",
+        '      break',
+        '    }',
         '',
         '    # 进程已退出',
         '    if ($proc.HasExited) {',
@@ -364,6 +473,11 @@ async function startServiceWindows() {
         return { success: true, message: 'Gateway 已在运行' };
     }
     try {
+        // 清除上一次 stop 可能残留的停止标记，否则新守护会立即退出
+        try {
+            fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
+        }
+        catch { /* ignore */ }
         const exe = getGatewayExePath();
         const workDir = path_1.default.dirname(exe);
         if (!fs_1.default.existsSync(GATEWAY_LAUNCHER_FILE)) {
@@ -388,9 +502,15 @@ async function startServiceWindows() {
 }
 async function restartServiceWindows() {
     try {
-        await stopService();
+        const stopResult = await stopService();
+        if (!stopResult.success) {
+            return { success: false, message: `重启失败（停止阶段）: ${stopResult.message}` };
+        }
         await new Promise(r => setTimeout(r, 1000));
-        await startService();
+        const startResult = await startService();
+        if (!startResult.success) {
+            return { success: false, message: `重启失败（启动阶段）: ${startResult.message}` };
+        }
         return { success: true, message: 'Gateway 重启成功' };
     }
     catch (err) {
@@ -399,23 +519,33 @@ async function restartServiceWindows() {
 }
 async function stopServiceWindows() {
     try {
+        if (!isGatewayRunning() && !getDaemonPid()) {
+            return { success: true, message: 'Gateway 未在运行' };
+        }
         // 写入停止标记，告知守护进程这是主动停止，不要重启
         try {
+            fs_1.default.mkdirSync(path_1.default.dirname(GATEWAY_STOP_FLAG_FILE), { recursive: true });
             fs_1.default.writeFileSync(GATEWAY_STOP_FLAG_FILE, '1', 'utf8');
         }
         catch { /* ignore */ }
-        // 给守护进程一点时间检测到标记
-        await new Promise(r => setTimeout(r, 200));
-        await stopGatewayProcess();
-        // 清理停止标记和守护进程 PID 文件
+        const { stopped, self } = await stopGatewayProcess();
+        // 自停场景（HTTP 接口调用）退出发生在本函数返回之后，无法在此校验，
+        // 也不能删停止标记（它要留给守护进程判定主动停止）
+        if (self) {
+            return { success: true, message: 'Gateway 正在退出' };
+        }
+        // 确认退出后才能清理停止标记，否则残留守护会把 gateway 重新拉起
+        if (!stopped) {
+            return { success: false, message: 'Gateway 进程未能终止，请手动结束进程后重试' };
+        }
         try {
             fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
         }
         catch { /* ignore */ }
-        try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+        // 最终校验：避免在没真正停掉时还报成功
+        if (isGatewayRunning()) {
+            return { success: false, message: 'Gateway 仍在运行，停止失败' };
         }
-        catch { /* ignore */ }
         return { success: true, message: 'Gateway 已停止' };
     }
     catch (err) {
@@ -451,21 +581,21 @@ async function installLinux() {
         if (installed)
             await stopService();
         const execStart = isPkg ? exe : `${exe} ${script}`;
-        const unitContent = `[Unit]
-Description=${exports.SERVICE_DISPLAY_NAME}
-After=network.target
-
-[Service]
-Type=simple
-User=${process.env.USER || 'root'}
-WorkingDirectory=${workDir}
-ExecStart=${execStart}
-Restart=always
-RestartSec=5
-Environment=NODE_ENV=production
-
-[Install]
-WantedBy=multi-user.target
+        const unitContent = `[Unit]
+Description=${exports.SERVICE_DISPLAY_NAME}
+After=network.target
+
+[Service]
+Type=simple
+User=${process.env.USER || 'root'}
+WorkingDirectory=${workDir}
+ExecStart=${execStart}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
 `;
         await fs_1.default.promises.writeFile('/tmp/myassis-gateway.service', unitContent, 'utf8');
         await execAsync('cp /tmp/myassis-gateway.service /etc/systemd/system/myassis-gateway.service', { timeout: 10000 });

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;