@myassis/gateway 1.0.85 → 1.0.87

package/dist/services/memory/MemoryManager.js

@@ -64,12 +64,28 @@ class MemoryManager {
     config = DEFAULT_CONFIG;
     childAgent;
     res;
+    mirror;
     summaryModels = null;
-    constructor(session, signal, childAgent, res = null) {
+    constructor(session, signal, childAgent, res = null, mirror = null) {
         this.session = session;
         this.signal = signal;
         this.childAgent = childAgent;
         this.res = res;
+        this.mirror = mirror;
+    }
+    /**
+     * 发送 SSE 事件：先镜像给该用户的其他终端，再写回发起端。
+     *
+     * 旧实现只写 res，导致「上下文压缩中」等事件无法多终端同步。
+     */
+    emitSSE(data) {
+        try {
+            this.mirror?.(data);
+        }
+        catch {
+            // 镜像失败不影响发起端
+        }
+        sendSSE(this.res, data);
     }
     /**
      * 构造注入上下文的摘要消息。
@@ -421,7 +437,7 @@ ${conversation}
     async generateSummaryAsync(messages, lastSummary) {
         // 非 childAgent 会话通知 Desktop 显示"上下文压缩中"
         if (!this.childAgent) {
-            sendSSE(this.res, { type: 'context_compressing' });
+            this.emitSSE({ type: 'context_compressing' });
         }
         const MAX_INPUT_CHARS = 30000; // 单次摘要最大输入字符数
         // 格式化所有消息用于估算长度

package/dist/services/relay/LoopbackForwarder.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * 回环转发器
+ *
+ * 把中继帧还原成一次对本机 `127.0.0.1:{实际端口}` 的**真实 HTTP 请求**，
+ * 而不是在内存里伪造 req/res 直接喂给 express。
+ *
+ * 为什么坚持走真实回环：
+ * 1. 完整复用既有中间件链（helmet / cors / compression / broadcastDataChanges
+ *    / errorHandler）与路由，行为与直连模式逐字节一致，不需要为中继单独维护一套；
+ * 2. 内存伪造 req/res 必须模拟 IncomingMessage 与 ServerResponse 的全部行为
+ *    （流式写、背压、trailers、连接中断），任何遗漏都会在 SSE 或上传上出问题；
+ * 3. 回环没有真实网络开销，代价可以忽略。
+ *
+ * 关键约束：响应必须**逐块**回传，不得聚合。否则 SSE 首字延迟被拉长，
+ * 流式对话会退化成「等很久然后一次性出现」。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyLoopbackIdentity = exports.probeLoopback = exports.LoopbackWebSocket = exports.LoopbackRequest = void 0;
+const http_1 = __importDefault(require("http"));
+const shared_1 = require("@myassis/shared");
+const protocol_js_1 = require("./protocol.js");
+const logger = (0, shared_1.getLogger)('relay/Loopback');
+/** 回环请求的目标主机：固定本机，绝不接受外部指定 */
+const LOOPBACK_HOST = '127.0.0.1';
+/** 单个中继请求的上限（含等待网关处理），流式响应不受此限制约束首字之后的时长 */
+const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * 一次进行中的回环请求。
+ * RelayClient 持有它以便投递请求体、以及在对端中止时取消。
+ */
+class LoopbackRequest {
+    handlers;
+    req;
+    finished = false;
+    /** 发送窗口耗尽时暂停响应读取，避免上游写入速度超过隧道 */
+    paused = false;
+    res = null;
+    constructor(port, head, handlers) {
+        this.handlers = handlers;
+        // 逐跳头必须剥掉：对端声明的 transfer-encoding/connection 只对那一跳有效
+        const headers = (0, protocol_js_1.stripHopByHopHeaders)(head.headers);
+        // content-length 不可信：请求体经隧道分片后由 Node 自行按 chunked 发送
+        delete headers['content-length'];
+        // host 必须改写为回环地址，否则 express 的 host 相关逻辑会看到外部域名
+        headers['host'] = `${LOOPBACK_HOST}:${port}`;
+        // 保留真实来源，供网关侧审计与限流使用
+        if (head.remoteAddr) {
+            headers['x-forwarded-for'] = head.remoteAddr;
+        }
+        // 标记中继来源：便于日志区分，也让业务侧可按需拒绝高危操作
+        headers['x-myassis-relay'] = '1';
+        this.req = http_1.default.request({
+            host: LOOPBACK_HOST,
+            port,
+            method: head.method,
+            path: head.path,
+            headers,
+            // 回环不需要连接复用带来的复杂性，出错语义更简单
+            agent: false,
+            timeout: REQUEST_TIMEOUT_MS,
+        });
+        this.req.on('response', (res) => this.handleResponse(res));
+        this.req.on('timeout', () => {
+            this.fail(protocol_js_1.AbortReason.TIMEOUT, `回环请求超时（${REQUEST_TIMEOUT_MS}ms）`);
+        });
+        this.req.on('error', (err) => {
+            // ECONNREFUSED 意味着网关自身 HTTP 服务不可用（如正在重启）
+            this.fail(protocol_js_1.AbortReason.GATEWAY_ERROR, err.message);
+        });
+        if (!head.hasBody) {
+            this.req.end();
+        }
+    }
+    /** 写入一段请求体，返回 false 表示上游背压，调用方应暂缓 */
+    writeBody(chunk) {
+        if (this.finished)
+            return true;
+        return this.req.write(chunk);
+    }
+    /** 请求体结束 */
+    endBody() {
+        if (this.finished)
+            return;
+        this.req.end();
+    }
+    /** 对端中止：主动销毁回环请求，让网关侧尽快释放资源 */
+    abort(reason, message) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        logger.debug(`回环请求中止: reason=${reason} ${message}`);
+        this.req.destroy();
+        this.res?.destroy();
+    }
+    /** 发送窗口耗尽时暂停读取响应（流控的落点） */
+    pauseResponse() {
+        if (this.paused)
+            return;
+        this.paused = true;
+        this.res?.pause();
+    }
+    /** 收到 WINDOW_UPDATE 后恢复读取 */
+    resumeResponse() {
+        if (!this.paused)
+            return;
+        this.paused = false;
+        this.res?.resume();
+    }
+    handleResponse(res) {
+        this.res = res;
+        const headers = (0, protocol_js_1.stripHopByHopHeaders)(res.headers);
+        // content-length 在分帧后不再成立（且 SSE 本就没有），交由对端按流结束判断
+        delete headers['content-length'];
+        // 立刻发出响应头：SSE / 流式对话的首字延迟完全取决于这一步
+        this.handlers.onHead(res.statusCode || 502, headers);
+        if (this.paused) {
+            res.pause();
+        }
+        res.on('data', (chunk) => {
+            // 单帧上限由协议约定，这里就地切分，避免调用方再拼一次
+            for (let offset = 0; offset < chunk.length; offset += protocol_js_1.MAX_FRAME_PAYLOAD) {
+                this.handlers.onData(new Uint8Array(chunk.buffer, chunk.byteOffset + offset, Math.min(protocol_js_1.MAX_FRAME_PAYLOAD, chunk.length - offset)));
+            }
+        });
+        res.on('end', () => {
+            if (this.finished)
+                return;
+            this.finished = true;
+            this.handlers.onEnd();
+        });
+        res.on('error', (err) => {
+            this.fail(protocol_js_1.AbortReason.GATEWAY_ERROR, err.message);
+        });
+        // aborted 而非 end：上游异常断开时必须让对端知道响应不完整
+        res.on('aborted', () => {
+            this.fail(protocol_js_1.AbortReason.GATEWAY_ERROR, '本机响应被中断');
+        });
+    }
+    fail(reason, message) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        logger.warn(`回环请求失败: ${message}`);
+        this.req.destroy();
+        this.handlers.onError(reason, message);
+    }
+}
+exports.LoopbackRequest = LoopbackRequest;
+/**
+ * 回环 WebSocket 通道。
+ *
+ * 同样走真实回环：直接对 `ws://127.0.0.1:{port}/ws` 发起连接，
+ * 复用 WebSocketService 既有的鉴权（?token=）与多终端逻辑。
+ */
+class LoopbackWebSocket {
+    handlers;
+    ws = null;
+    closed = false;
+    constructor(port, path, headers, handlers) {
+        this.handlers = handlers;
+        // 延迟 require：ws 已是既有依赖，这里避免在未启用中继时也加载
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { WebSocket } = require('ws');
+        const forwarded = (0, protocol_js_1.stripHopByHopHeaders)(headers);
+        delete forwarded['host'];
+        delete forwarded['sec-websocket-key'];
+        delete forwarded['sec-websocket-version'];
+        delete forwarded['sec-websocket-extensions'];
+        delete forwarded['sec-websocket-accept'];
+        const ws = new WebSocket(`ws://${LOOPBACK_HOST}:${port}${path}`, {
+            headers: forwarded,
+        });
+        this.ws = ws;
+        ws.on('open', () => this.handlers.onOpen());
+        ws.on('message', (data, isBinary) => {
+            this.handlers.onMessage(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), isBinary);
+        });
+        ws.on('close', (code, reason) => {
+            if (this.closed)
+                return;
+            this.closed = true;
+            this.handlers.onClose(normalizeCloseCode(code), reason?.toString() || '');
+        });
+        ws.on('error', (err) => {
+            if (this.closed)
+                return;
+            this.closed = true;
+            logger.warn(`回环 WebSocket 失败: ${err.message}`);
+            // 1011 = internal error，让远端客户端按「服务异常」处理并自行重连
+            this.handlers.onClose(1011, err.message);
+        });
+    }
+    /** 转发一条客户端消息到本机 */
+    send(data, binary) {
+        const ws = this.ws;
+        if (!ws || ws.readyState !== 1 /* OPEN */)
+            return;
+        ws.send(data, { binary });
+    }
+    /** 关闭回环连接 */
+    close(code = 1000, reason = '') {
+        this.closed = true;
+        try {
+            this.ws?.close(normalizeCloseCode(code), reason);
+        }
+        catch {
+            this.ws?.terminate();
+        }
+    }
+}
+exports.LoopbackWebSocket = LoopbackWebSocket;
+/**
+ * 规整 WebSocket 关闭码。
+ *
+ * 1005（无状态码）与 1006（异常关闭）不允许出现在 close 帧里，
+ * 直接透传会让 ws 抛错，从而把一次正常的对端断开变成网关侧异常。
+ */
+function normalizeCloseCode(code) {
+    if (!Number.isInteger(code) || code < 1000 || code > 4999)
+        return 1011;
+    if (code === 1005 || code === 1006)
+        return 1011;
+    return code;
+}
+/** 供测试与诊断：探测本机 HTTP 端口是否可用 */
+function probeLoopback(port, timeoutMs = 2000) {
+    return new Promise((resolve) => {
+        const req = http_1.default.request({ host: LOOPBACK_HOST, port, path: '/health', method: 'GET', timeout: timeoutMs, agent: false }, (res) => {
+            res.resume();
+            resolve((res.statusCode || 0) < 500);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.end();
+    });
+}
+exports.probeLoopback = probeLoopback;
+/**
+ * 校验回环端口上的进程确实是**本进程**。
+ *
+ * 起因是一次真实故障：一台机器上同时跑着新旧两个网关，3001 被旧版占用后
+ * 新版顺延到 3002。隧道由新版建立（凭据在它手上），但如果回环端口取错，
+ * 请求就会被送进旧版进程，表现为隧道在线、/health 也 200，而所有 /api/v1/*
+ * 返回 404 —— 一个极难定位的症状。
+ *
+ * 判据用 /health 里的 gatewayId：它来自配对凭据，同一台机器上不会重复，
+ * 比单纯「端口是否可连」强得多（两个版本的 /health 都会返回 200）。
+ *
+ * @param expectedGatewayId 本进程持有的 gatewayId
+ * @returns 一致返回 null，不一致或探测失败返回可读原因
+ */
+function verifyLoopbackIdentity(port, expectedGatewayId, timeoutMs = 2000) {
+    return new Promise((resolve) => {
+        const req = http_1.default.request({ host: LOOPBACK_HOST, port, path: '/health', method: 'GET', timeout: timeoutMs, agent: false }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                try {
+                    const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    const actual = body?.relay?.gatewayId;
+                    if (!actual) {
+                        resolve(`回环端口 ${port} 上的网关未上报 gatewayId，可能是同机运行的旧版本网关占用了该端口`);
+                        return;
+                    }
+                    if (actual !== expectedGatewayId) {
+                        resolve(`回环端口 ${port} 上的网关身份不符（期望 ${expectedGatewayId}，实际 ${actual}），` +
+                            '同机可能运行着另一个网关实例');
+                        return;
+                    }
+                    resolve(null);
+                }
+                catch {
+                    resolve(`回环端口 ${port} 的 /health 响应无法解析`);
+                }
+            });
+        });
+        req.on('error', (err) => resolve(`回环端口 ${port} 探测失败: ${err.message}`));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(`回环端口 ${port} 探测超时`);
+        });
+        req.end();
+    });
+}
+exports.verifyLoopbackIdentity = verifyLoopbackIdentity;