@dev-anywhere/relay 0.5.46 → 0.5.47

package/dist/{chunk-7KWO37WD.js → chunk-4Q4EAZP6.js}

@@ -1045,7 +1045,7 @@ var relayControlDefinitions = [
     }))
   }),
   // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
-  control("session_subscribe", { sessionId: IdSchema, requestId: IdSchema.optional() }, "client_to_proxy"),
+  control("session_subscribe", { sessionId: IdSchema, requestId: IdSchema }, "client_to_proxy"),
   // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
   control("session_snapshot", {
     sessionId: IdSchema,
@@ -1053,7 +1053,7 @@ var relayControlDefinitions = [
     rows: z9.number().int().positive(),
     data: z9.string(),
     outputSeq: z9.number().int().nonnegative(),
-    requestId: IdSchema.optional()
+    requestId: IdSchema
   }, "proxy_to_client")
 ];
 var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
@@ -1776,7 +1776,7 @@ function rejectNotRegistered(ws) {
     })
   );
 }
-function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
+function handleProxyConnection(ws, registry, logger, ptySnapshotRoutes, chaos, remoteFileBridge) {
   const proxyWs = ws;
   proxyWs.isAlive = true;
   proxyWs.on("pong", () => {
@@ -1806,7 +1806,7 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
       const clients = registry.getClientsForProxy(proxyWs.proxyId);
       for (const clientWs of clients) {
         if (clientWs.readyState === WebSocket4.OPEN) {
-          clientWs.send(data);
+          clientWs.send(data, { binary: true, compress: false });
         }
       }
       return;
@@ -1824,6 +1824,7 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
       const { proxyId, name } = result.message;
       const status = registry.registerProxy(proxyId, proxyWs, name);
       proxyWs.proxyId = proxyId;
+      if (status === "reconnected") ptySnapshotRoutes.clearProxy(proxyId);
       logger.info({ proxyId, status }, "Proxy registered");
       proxyWs.send(
         serializeControl({
@@ -1839,6 +1840,7 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
     }
     if (result.kind === "control" && result.message.type === "proxy_disconnect") {
       if (proxyWs.proxyId) {
+        ptySnapshotRoutes.clearProxy(proxyWs.proxyId);
         notifyClientsProxyOffline(proxyWs.proxyId, registry, logger, chaos);
         registry.unregisterProxy(proxyWs.proxyId);
         logger.info(
@@ -1895,6 +1897,35 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
         remoteFileBridge?.handleProxyControl(proxyWs.proxyId, result.message);
         return;
       }
+      if (proxyWs.proxyId && result.message.type === "session_snapshot") {
+        const route = ptySnapshotRoutes.resolve(
+          proxyWs.proxyId,
+          result.message.sessionId,
+          result.message.requestId,
+          proxyWs
+        );
+        if (route.kind === "matched" && route.clientWs.readyState === WebSocket4.OPEN) {
+          if (chaos) {
+            chaos.send(route.clientWs, raw, {
+              direction: "proxy_to_client",
+              type: result.message.type
+            });
+          } else {
+            route.clientWs.send(raw);
+          }
+          return;
+        }
+        logger.debug(
+          {
+            proxyId: proxyWs.proxyId,
+            sessionId: result.message.sessionId,
+            requestId: result.message.requestId,
+            route: route.kind
+          },
+          "Unmatched PTY snapshot dropped"
+        );
+        return;
+      }
       if (isProxyToClientRelayControlType(result.message.type)) {
         if (!proxyWs.proxyId) {
           rejectNotRegistered(proxyWs);
@@ -1953,6 +1984,7 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
       );
       return;
     }
+    ptySnapshotRoutes.clearProxy(proxyWs.proxyId);
     notifyClientsProxyOffline(proxyWs.proxyId, registry, logger, chaos);
     try {
       registry.transitionProxy(proxyWs.proxyId, "online", "offline");
@@ -2873,7 +2905,7 @@ function sendRemoteFileUploadUrlFailure(ws, requestId, sessionId, error, errorCo
     })
   );
 }
-function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, voiceProviders, remoteFileBridge, connectionInfo = {}) {
+function handleClientConnection(ws, registry, logger, ptySnapshotRoutes, chaos, voiceConfigStore, voiceProviders, remoteFileBridge, connectionInfo = {}) {
   const clientWs = ws;
   clientWs.isAlive = true;
   registry.addClientWs(clientWs, connectionInfo);
@@ -3113,6 +3145,48 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
         }
         const proxyWs = registry.getProxy(targetProxyId);
         if (proxyWs && proxyWs.readyState === WebSocket7.OPEN) {
+          if (msg.type === "session_subscribe") {
+            const registration = ptySnapshotRoutes.register(
+              targetProxyId,
+              msg.sessionId,
+              msg.requestId,
+              clientWs,
+              proxyWs
+            );
+            if (registration === "duplicate") {
+              logger.debug(
+                { proxyId: targetProxyId, sessionId: msg.sessionId, requestId: msg.requestId },
+                "Duplicate PTY snapshot subscribe suppressed"
+              );
+              return;
+            }
+            if (registration !== "registered" && registration !== "retry_due") {
+              logger.warn(
+                {
+                  proxyId: targetProxyId,
+                  sessionId: msg.sessionId,
+                  requestId: msg.requestId,
+                  registration
+                },
+                "PTY snapshot subscribe route rejected"
+              );
+              clientWs.send(
+                JSON.stringify({
+                  type: "relay_error",
+                  requestId: msg.requestId,
+                  code: RelayErrorCode.INVALID_MESSAGE,
+                  message: registration === "collision" ? "PTY snapshot requestId is already in use" : "Too many pending PTY snapshot requests"
+                })
+              );
+              return;
+            }
+            if (registration === "retry_due") {
+              logger.debug(
+                { proxyId: targetProxyId, sessionId: msg.sessionId, requestId: msg.requestId },
+                "Retrying unanswered PTY snapshot subscribe"
+              );
+            }
+          }
           if (chaos) chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: msg.type });
           else proxyWs.send(raw);
         } else {
@@ -3189,6 +3263,7 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
     }
   });
   clientWs.on("close", (code, reason) => {
+    ptySnapshotRoutes.abandonSocket(clientWs);
     registry.removeClientWs(clientWs);
     if (clientWs.clientId) {
       registry.unbindClientSocket(clientWs.clientId, clientWs);
@@ -4095,7 +4170,7 @@ var RemoteFileBridge = class {
       req.pause();
       const frame = encodeFileStreamFrame(uploadId, pending.chunkSeq, Buffer.from(chunk));
       pending.chunkSeq += 1;
-      proxyWs.send(frame, { binary: true }, (err) => {
+      proxyWs.send(frame, { binary: true, compress: false }, (err) => {
         if (err) {
           this.failUpload(uploadId, 502, err.message);
           return;
@@ -4411,10 +4486,138 @@ function mountWebApp(app, options) {
   return true;
 }
 
+// src/pty-snapshot-route-registry.ts
+var DEFAULT_MAX_ENTRIES = 4096;
+var DEFAULT_MAX_PENDING_PER_CLIENT = 64;
+var DEFAULT_RETRY_FORWARD_INTERVAL_MS = 25e3;
+var DEFAULT_PENDING_TTL_MS = 5 * 6e4;
+var DEFAULT_TOMBSTONE_TTL_MS = 12e4;
+function routeKey(proxyId, sessionId, requestId) {
+  return JSON.stringify([proxyId, sessionId, requestId]);
+}
+var PtySnapshotRouteRegistry = class {
+  routes = /* @__PURE__ */ new Map();
+  maxEntries;
+  maxPendingPerClient;
+  retryForwardIntervalMs;
+  pendingTtlMs;
+  tombstoneTtlMs;
+  now;
+  constructor(options = {}) {
+    this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_ENTRIES);
+    this.maxPendingPerClient = Math.max(
+      1,
+      options.maxPendingPerClient ?? DEFAULT_MAX_PENDING_PER_CLIENT
+    );
+    this.retryForwardIntervalMs = Math.max(
+      1,
+      options.retryForwardIntervalMs ?? DEFAULT_RETRY_FORWARD_INTERVAL_MS
+    );
+    this.pendingTtlMs = Math.max(1, options.pendingTtlMs ?? DEFAULT_PENDING_TTL_MS);
+    this.tombstoneTtlMs = Math.max(1, options.tombstoneTtlMs ?? DEFAULT_TOMBSTONE_TTL_MS);
+    this.now = options.now ?? Date.now;
+  }
+  register(proxyId, sessionId, requestId, clientWs, proxyWs) {
+    const now = this.now();
+    this.pruneExpired(now);
+    const key = routeKey(proxyId, sessionId, requestId);
+    const existing = this.routes.get(key);
+    if (existing) {
+      if (existing.state === "pending" && existing.clientWs === clientWs && existing.proxyWs === proxyWs) {
+        if (now - existing.lastForwardedAt >= this.retryForwardIntervalMs) {
+          existing.lastForwardedAt = now;
+          return "retry_due";
+        }
+        return "duplicate";
+      }
+      return "collision";
+    }
+    let clientPendingCount = 0;
+    for (const route of this.routes.values()) {
+      if (route.state === "pending" && route.clientWs === clientWs) {
+        clientPendingCount += 1;
+        if (clientPendingCount >= this.maxPendingPerClient) {
+          return "client_capacity_exceeded";
+        }
+      }
+    }
+    if (this.routes.size >= this.maxEntries) {
+      let oldestTombstoneKey;
+      let oldestTombstoneExpiry = Number.POSITIVE_INFINITY;
+      for (const [candidateKey, route] of this.routes) {
+        if (route.state === "tombstone" && route.expiresAt < oldestTombstoneExpiry) {
+          oldestTombstoneKey = candidateKey;
+          oldestTombstoneExpiry = route.expiresAt;
+        }
+      }
+      if (oldestTombstoneKey) this.routes.delete(oldestTombstoneKey);
+      else return "capacity_exceeded";
+    }
+    this.routes.set(key, {
+      state: "pending",
+      proxyId,
+      proxyWs,
+      clientWs,
+      lastForwardedAt: now,
+      expiresAt: now + this.pendingTtlMs
+    });
+    return "registered";
+  }
+  resolve(proxyId, sessionId, requestId, proxyWs) {
+    const now = this.now();
+    this.pruneExpired(now);
+    const key = routeKey(proxyId, sessionId, requestId);
+    const route = this.routes.get(key);
+    if (!route) return { kind: "unmatched" };
+    if (route.state === "tombstone") return { kind: "tombstone" };
+    if (route.proxyWs !== proxyWs) return { kind: "stale_proxy" };
+    this.routes.set(key, {
+      state: "tombstone",
+      proxyId,
+      expiresAt: now + this.tombstoneTtlMs
+    });
+    return { kind: "matched", clientWs: route.clientWs };
+  }
+  abandonSocket(clientWs) {
+    const now = this.now();
+    this.pruneExpired(now);
+    for (const [key, route] of this.routes) {
+      if (route.state === "pending" && route.clientWs === clientWs) {
+        this.routes.set(key, {
+          state: "tombstone",
+          proxyId: route.proxyId,
+          expiresAt: now + this.tombstoneTtlMs
+        });
+      }
+    }
+  }
+  clearProxy(proxyId) {
+    for (const [key, route] of this.routes) {
+      if (route.proxyId === proxyId) this.routes.delete(key);
+    }
+  }
+  pruneExpired(now) {
+    for (const [key, route] of this.routes) {
+      if (route.expiresAt <= now) this.routes.delete(key);
+    }
+  }
+};
+
 // src/server.ts
 var MODULE_DIR = dirname3(fileURLToPath2(import.meta.url));
 var PACKAGED_FONTS_DIR = resolve(MODULE_DIR, "../assets/fonts");
 var PACKAGED_WEB_DIR = resolve(MODULE_DIR, "../assets/web");
+var DATA_CHANNEL_MAX_PAYLOAD_BYTES = 10 * 1024 * 1024;
+var DATA_CHANNEL_COMPRESSION = {
+  clientNoContextTakeover: true,
+  serverNoContextTakeover: true,
+  threshold: 32 * 1024,
+  concurrencyLimit: 4,
+  zlibDeflateOptions: {
+    level: 3,
+    memLevel: 7
+  }
+};
 function firstHeaderValue(value) {
   if (Array.isArray(value)) return value[0];
   return value;
@@ -4444,6 +4647,7 @@ function createRelayServer(options) {
     );
   }
   const registry = new RelayRegistry();
+  const ptySnapshotRoutes = new PtySnapshotRouteRegistry();
   const remoteFileBridge = new RemoteFileBridge({ registry, logger });
   const voiceConfigStore = createVoiceConfigStore({
     dataDir,
@@ -4513,8 +4717,16 @@ function createRelayServer(options) {
     mountWebApp(app, { webAssetDir, logger });
   }
   const httpServer = createServer(app);
-  const proxyWss = new WebSocketServer({ noServer: true });
-  const clientWss = new WebSocketServer({ noServer: true });
+  const proxyWss = new WebSocketServer({
+    noServer: true,
+    maxPayload: DATA_CHANNEL_MAX_PAYLOAD_BYTES,
+    perMessageDeflate: DATA_CHANNEL_COMPRESSION
+  });
+  const clientWss = new WebSocketServer({
+    noServer: true,
+    maxPayload: DATA_CHANNEL_MAX_PAYLOAD_BYTES,
+    perMessageDeflate: DATA_CHANNEL_COMPRESSION
+  });
   const voiceAsrWss = new WebSocketServer({ noServer: true });
   const voiceTtsWss = new WebSocketServer({ noServer: true });
   httpServer.on("upgrade", (request, socket, head) => {
@@ -4579,13 +4791,14 @@ function createRelayServer(options) {
     socket.destroy();
   });
   proxyWss.on("connection", (ws) => {
-    handleProxyConnection(ws, registry, logger, relayChaos, remoteFileBridge);
+    handleProxyConnection(ws, registry, logger, ptySnapshotRoutes, relayChaos, remoteFileBridge);
   });
   clientWss.on("connection", (ws, request) => {
     handleClientConnection(
       ws,
       registry,
       logger,
+      ptySnapshotRoutes,
       relayChaos,
       voiceConfigStore,
       voiceProviders,
@@ -4681,4 +4894,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-7KWO37WD.js.map
+//# sourceMappingURL=chunk-4Q4EAZP6.js.map