@evandu/super-pi 0.1.137 → 0.1.139

package/dist/server/ws-server.js

@@ -1,6 +1,48 @@
 import { WebSocket, WebSocketServer } from "ws";
 import { isAuthorized } from "./http-server.js";
 import { describeThrown, describeThrownWithStack } from "./failure-text.js";
+/**
+ * A WebSocket is a live transport, not an unbounded queue.  `ws.send()` only
+ * copies bytes into the socket's userland buffer; a browser that is frozen or
+ * a network peer that has disappeared can therefore make the buffer grow
+ * without throwing.  Once this threshold is crossed we drop that connection
+ * and let the normal close path clean up its resources.
+ */
+export const MAX_WS_BUFFERED_BYTES = 8 * 1024 * 1024;
+/** Maximum size of one inbound WebSocket message. Attachments are uploaded
+ * over HTTP and commands contain references, so multi-megabyte WS frames are
+ * almost certainly malformed or abusive. */
+export const MAX_WS_PAYLOAD_BYTES = 4 * 1024 * 1024;
+/**
+ * Send one frame without allowing a race with close/error to escape as an
+ * uncaught exception.  The `ws` package can throw synchronously after the
+ * readyState check (for example when a close happens between the two calls),
+ * and an unhandled `error` event can otherwise terminate the Node process.
+ */
+export function safeSend(socket, payload) {
+    if (socket.readyState !== WebSocket.OPEN)
+        return false;
+    const bufferedAmount = Number(socket.bufferedAmount ?? 0);
+    if (Number.isFinite(bufferedAmount) && bufferedAmount > MAX_WS_BUFFERED_BYTES) {
+        try {
+            socket.terminate();
+        }
+        catch { /* close races are already being cleaned up */ }
+        return false;
+    }
+    try {
+        socket.send(payload);
+        return true;
+    }
+    catch (error) {
+        console.warn(`Super Pi: WebSocket send failed: ${error instanceof Error ? error.message : String(error)}`);
+        try {
+            socket.terminate();
+        }
+        catch { /* close races are already being cleaned up */ }
+        return false;
+    }
+}
 /**
  * Concrete implementation of EventBroadcaster delivering server events
  * across active WebSocket connections.
@@ -8,16 +50,19 @@ import { describeThrown, describeThrownWithStack } from "./failure-text.js";
 export class WsBroadcaster {
     getState;
     sockets = new Set();
+    // Undefined preserves the original full-state protocol. An object, including {}, opts into
+    // conversation-focused snapshots from the very first frame of the connection.
+    scopes = new Map();
+    fileIndexScopes = new Map();
     coalescedSockets = new Set();
     pendingStreams = new Map();
-    cachedState;
-    cachedStatePayload;
     stateFlushScheduled = false;
     constructor(getState) {
         this.getState = getState;
     }
-    register(socket) {
+    register(socket, scope) {
         this.sockets.add(socket);
+        this.scopes.set(socket, scope);
     }
     unregister(socket) {
         this.coalescedSockets.delete(socket);
@@ -25,8 +70,49 @@ export class WsBroadcaster {
         if (pending)
             clearTimeout(pending.timer);
         this.pendingStreams.delete(socket);
+        this.scopes.delete(socket);
+        this.fileIndexScopes.delete(socket);
         this.sockets.delete(socket);
     }
+    subscribe(socket, conversationId) {
+        // Finish the old transcript before replacing it. A later delta then belongs to the new scope,
+        // and the authoritative snapshot reconstructs anything not streamed while it was unselected.
+        this.flushStreaming(socket);
+        this.scopes.set(socket, conversationId ? { conversationId } : {});
+        this.sendState(socket);
+    }
+    sendState(socket) {
+        if (socket.readyState !== WebSocket.OPEN)
+            return;
+        this.flushStreaming(socket);
+        safeSend(socket, JSON.stringify({ type: "state", state: this.getState(this.scopes.get(socket)) }));
+    }
+    subscribeFileIndex(socket, workspaceId) {
+        if (workspaceId)
+            this.fileIndexScopes.set(socket, workspaceId);
+        else
+            this.fileIndexScopes.delete(socket);
+    }
+    receives(socket, event) {
+        const scope = this.scopes.get(socket);
+        if (!scope)
+            return true;
+        switch (event.type) {
+            case "files.index":
+                return this.fileIndexScopes.get(socket) === event.workspaceId;
+            case "message.delta":
+            case "message.thinking":
+            case "message.tools":
+                return event.conversationId === scope.conversationId;
+            case "subagent.event":
+                return event.run.conversationId === scope.conversationId;
+            case "workflow.event":
+                return event.workflow.conversationId === scope.conversationId;
+            default:
+                // Lifecycle and summary changes still reach the sidebar for every conversation.
+                return true;
+        }
+    }
     configureStreaming(socket, coalesce) {
         if (coalesce)
             this.coalescedSockets.add(socket);
@@ -42,8 +128,7 @@ export class WsBroadcaster {
         clearTimeout(pending.timer);
         this.pendingStreams.delete(socket);
         for (const event of pending.events.values())
-            if (socket.readyState === WebSocket.OPEN)
-                socket.send(JSON.stringify(event));
+            safeSend(socket, JSON.stringify(event));
     }
     enqueueStreaming(socket, event) {
         let pending = this.pendingStreams.get(socket);
@@ -67,29 +152,24 @@ export class WsBroadcaster {
         return this.sockets;
     }
     broadcast(event) {
+        if (event.type === "state") {
+            this.broadcastState();
+            return;
+        }
         const streaming = event.type === "message.delta" || event.type === "message.thinking";
-        /**
-         * SERIALIZED ONCE, NOT ONCE PER SOCKET. A `state` frame carries the whole application state, so
-         * `JSON.stringify` on it is the most expensive thing this method does - and every open tab used
-         * to pay for its own copy of the same string. The bytes are identical (no socket-specific field),
-         * so the string is built once and handed to every socket.
-         *
-         * Stream deltas stay per-event: they are coalesced per socket, so there is no single payload to
-         * share, and their cost is one small string.
-         */
-        const startedAt = performance.now();
-        const payload = streaming ? undefined : JSON.stringify(event);
-        if (!streaming && event.type === "state" && process.env.SUPER_PI_TRACE_LATENCY === "1")
-            console.warn(`[super-pi latency] phase=state.broadcast bytes=${payload?.length ?? 0} sockets=${this.sockets.size} serializeMs=${Math.round(performance.now() - startedAt)}`);
+        // Serialize common events once, after finding a recipient. Coalesced text stays per socket;
+        // conversation snapshots are projected and serialized once per scope in broadcastState().
+        let payload;
         for (const socket of this.sockets) {
-            if (socket.readyState !== WebSocket.OPEN)
+            if (socket.readyState !== WebSocket.OPEN || !this.receives(socket, event))
                 continue;
             if (streaming && this.coalescedSockets.has(socket))
                 this.enqueueStreaming(socket, event);
             else {
                 // A state/tool/lifecycle event is a transcript boundary. Flush its preceding text first.
                 this.flushStreaming(socket);
-                socket.send(payload ?? JSON.stringify(event));
+                payload ??= JSON.stringify(event);
+                safeSend(socket, payload);
             }
         }
     }
@@ -99,21 +179,38 @@ export class WsBroadcaster {
         this.stateFlushScheduled = true;
         queueMicrotask(() => {
             this.stateFlushScheduled = false;
-            this.cachedState = this.getState();
-            this.cachedStatePayload = JSON.stringify({ type: "state", state: this.cachedState });
-            const payload = this.cachedStatePayload;
+            const groups = new Map();
             for (const socket of this.sockets) {
                 if (socket.readyState !== WebSocket.OPEN)
                     continue;
-                this.flushStreaming(socket);
-                socket.send(payload);
+                const scope = this.scopes.get(socket);
+                const key = scope ? `focused:${JSON.stringify(scope.conversationId ?? null)}` : "legacy";
+                let group = groups.get(key);
+                if (!group) {
+                    group = { scope, sockets: [] };
+                    groups.set(key, group);
+                }
+                group.sockets.push(socket);
+            }
+            for (const { scope, sockets } of groups.values()) {
+                const snapshotStartedAt = performance.now();
+                const state = this.getState(scope);
+                const snapshotMs = performance.now() - snapshotStartedAt;
+                const serializeStartedAt = performance.now();
+                const cachedStatePayload = JSON.stringify({ type: "state", state });
+                const serializeMs = performance.now() - serializeStartedAt;
+                if (process.env.SUPER_PI_TRACE_LATENCY === "1") {
+                    console.warn(`[super-pi latency] phase=state.snapshot.ready bytes=${Buffer.byteLength(cachedStatePayload, "utf8")} snapshotMs=${Math.round(snapshotMs)} serializeMs=${Math.round(serializeMs)} sockets=${sockets.length} scope=${scope ? "focused" : "legacy"}`);
+                }
+                for (const socket of sockets) {
+                    this.flushStreaming(socket);
+                    safeSend(socket, cachedStatePayload);
+                }
             }
-            this.cachedState = undefined;
-            this.cachedStatePayload = undefined;
         });
     }
-    getStateSnapshot() {
-        return this.getState();
+    getStateSnapshot(scope) {
+        return this.getState(scope);
     }
 }
 import { checkDiskVersion } from "./version.js";
@@ -135,7 +232,11 @@ export class WsServer {
         this.accessToken = options.accessToken;
         this.rootDir = options.rootDir;
         this.onSocketClose = options.onSocketClose;
-        this.websocketServer = new WebSocketServer({ noServer: true });
+        // Remote clients are commonly separated from the server by a high-latency link. State snapshots can
+        // contain a long transcript, so sending them uncompressed turns every lifecycle event into a multi-MB
+        // transfer. Per-message deflate keeps the protocol unchanged while making the wire cost proportional
+        // to the actual information in the snapshot. The threshold avoids spending CPU on token-sized events.
+        this.websocketServer = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD_BYTES, perMessageDeflate: { threshold: 1024, serverNoContextTakeover: true } });
         this.setupUpgrade(options.httpServer);
         this.setupConnectionHandling();
     }
@@ -167,7 +268,17 @@ export class WsServer {
     }
     setupConnectionHandling() {
         this.websocketServer.on("connection", (socket, request) => {
-            this.broadcaster.register(socket);
+            const url = new URL(request.url ?? "/ws", "http://localhost");
+            const scope = url.searchParams.get("state") === "focused"
+                ? { conversationId: url.searchParams.get("conversationId") || undefined } : undefined;
+            this.broadcaster.register(socket, scope);
+            socket.on("error", (error) => {
+                console.warn(`Super Pi: WebSocket error: ${error instanceof Error ? error.message : String(error)}`);
+                try {
+                    socket.terminate();
+                }
+                catch { /* already closed */ }
+            });
             /**
              * The peer address, captured ONCE per connection rather than read per message.
              *
@@ -184,18 +295,18 @@ export class WsServer {
              * only the shells belonging to the socket that went away.
              */
             const terminalSessionIds = new Set();
-            socket.send(JSON.stringify({ type: "state", state: this.broadcaster.getStateSnapshot() }));
+            this.broadcaster.sendState(socket);
             if (this.rootDir) {
-                socket.send(JSON.stringify({ type: "server.version", version: checkDiskVersion(this.rootDir) }));
+                safeSend(socket, JSON.stringify({ type: "server.version", version: checkDiskVersion(this.rootDir) }));
             }
             void this.catalogService.agentCatalog().then((catalog) => {
                 if (socket.readyState === WebSocket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent.catalog", catalog }));
+                    safeSend(socket, JSON.stringify({ type: "agent.catalog", catalog }));
                 }
             }).catch((error) => console.warn(`Super Pi: agent catalog for a new connection failed: ${error instanceof Error ? error.message : "unknown error"}`));
             void this.catalogService.subagentCatalog().then((catalog) => {
                 if (socket.readyState === WebSocket.OPEN) {
-                    socket.send(JSON.stringify({ type: "subagent.catalog", catalog }));
+                    safeSend(socket, JSON.stringify({ type: "subagent.catalog", catalog }));
                 }
             }).catch((error) => console.warn(`Super Pi: sub-agent catalog for a new connection failed: ${error instanceof Error ? error.message : "unknown error"}`));
             /**
@@ -219,7 +330,7 @@ export class WsServer {
                 if (this.rootDir) {
                     const v = checkDiskVersion(this.rootDir);
                     if (v.needsRestart) {
-                        socket.send(JSON.stringify({ type: "server.version", version: v }));
+                        safeSend(socket, JSON.stringify({ type: "server.version", version: v }));
                     }
                 }
             }, 30_000);
@@ -249,18 +360,34 @@ export class WsServer {
                 }
                 catch {
                     console.error("Super Pi command error: received a frame that is not valid JSON");
-                    socket.send(JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
+                    safeSend(socket, JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
+                    return;
+                }
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.type !== "string") {
+                    safeSend(socket, JSON.stringify({ type: "error", message: "收到一条格式无效的命令，已忽略。" }));
+                    return;
+                }
+                if (parsed.type === "files.index.subscribe") {
+                    this.broadcaster.subscribeFileIndex(socket, typeof parsed.workspaceId === "string" ? parsed.workspaceId : undefined);
                     return;
                 }
                 if (parsed.type === "stream.configure") {
                     this.broadcaster.configureStreaming(socket, parsed.coalesce);
                     return;
                 }
+                if (parsed.type === "state.subscribe") {
+                    if (parsed.conversationId !== undefined && typeof parsed.conversationId !== "string") {
+                        safeSend(socket, JSON.stringify({ type: "error", message: "会话订阅标识必须是字符串。" }));
+                        return;
+                    }
+                    this.broadcaster.subscribe(socket, parsed.conversationId);
+                    return;
+                }
                 // A send or selected queued turn is a streaming operation. It must leave the socket's command
                 // chain immediately: waiting for the model turn would block later priority/cancel commands and
                 // make a second send miss the durable queue. The service owns per-conversation run claims.
                 const runIndependently = parsed.type === "message.send" || parsed.type === "message.sendQueued"
-                    || parsed.type === "message.interrupt" || parsed.type === "run.stop";
+                    || parsed.type === "message.interrupt" || parsed.type === "run.stop" || parsed.type === "message.revert";
                 // ...WHICH MEANS A SEND CAN OVERTAKE A REVERT SENT JUST BEFORE IT, because the revert below is
                 // queued behind whatever this socket was already doing. The service only learns it is cutting
                 // when the command EXECUTES, so a send handled in between would find the conversation open and
@@ -275,14 +402,11 @@ export class WsServer {
                         if (command.type === "terminal.open")
                             terminalSessionIds.add(command.sessionId);
                         const entityId = await this.commandHandler.handleCommand(command, (event) => {
-                            if (socket.readyState === WebSocket.OPEN) {
-                                socket.send(JSON.stringify(event));
-                            }
+                            safeSend(socket, JSON.stringify(event));
                         }, remoteAddress);
                         // Void-returning configuration commands also need an ack to release optimistic UI state.
-                        if (command.operationRequestId && socket.readyState === WebSocket.OPEN) {
-                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
-                        }
+                        if (command.operationRequestId)
+                            safeSend(socket, JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
                     }
                     catch (error) {
                         // A FAILED COMMAND WRITES ITSELF DOWN BEFORE IT ANSWERS.
@@ -294,10 +418,10 @@ export class WsServer {
                         console.error("Super Pi command error:", describeThrownWithStack(error));
                         const reason = describeThrown(error);
                         if (command?.operationRequestId) {
-                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
+                            safeSend(socket, JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
                             return;
                         }
-                        socket.send(JSON.stringify({
+                        safeSend(socket, JSON.stringify({
                             type: "error",
                             message: reason || "服务端没有说明这次失败的原因。",
                         }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.137",
+  "version": "0.1.139",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,8 @@
     "scripts/test-runner.test.mjs",
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
+    "scripts/remote-transport.test.mjs",
+    "scripts/browser-safe-port.test.mjs",
     "scripts/inline-thinking.test.mjs",
     "scripts/inline-thinking-close-tag.test.mjs",
     "scripts/pi-session.test.mjs",
@@ -97,6 +99,13 @@
     "scripts/background-result-one-per-turn.test.mjs",
     "scripts/thinking-status-promotion.test.mjs",
     "scripts/thinking-delivery-once.test.mjs",
+    "scripts/thinking-tool-order.test.mjs",
+    "scripts/question-behind-body.test.mjs",
+    "scripts/workspace-default-model-rules.test.mjs",
+    "scripts/tool-call-persist-count.test.mjs",
+    "scripts/conversation-service-narrow-reads.test.mjs",
+    "scripts/revert-evicts-live-session.test.mjs",
+    "scripts/cdp-retry-bounded.test.mjs",
     "scripts/question-call-session-path.test.mjs",
     "scripts/withdrawn-message-persistence.test.mjs",
     "scripts/git-write-endpoint-guard.test.mjs",
@@ -116,6 +125,7 @@
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
     "scripts/file-index.test.mjs",
+    "scripts/file-index-write-refresh.test.mjs",
     "scripts/file-name-index.test.mjs",
     "scripts/file-content-search.test.mjs",
     "scripts/file-diff-client.test.mjs",
@@ -188,6 +198,7 @@
     "scripts/visual-defects-browser.test.mjs",
     "scripts/session-state-animation-browser.test.mjs",
     "scripts/session-state-delivery-browser.test.mjs",
+    "scripts/transcript-render-scaling-browser.test.mjs",
     "scripts/question-awaiting-signal-browser.test.mjs",
     "scripts/withdraw-then-send-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
@@ -198,15 +209,18 @@
     "scripts/rail-workspace-follows-session-browser.test.mjs",
     "scripts/git-tab-browser.test.mjs",
     "scripts/workspace-reopen-browser.test.mjs",
+    "scripts/workspace-identity-browser.test.mjs",
     "scripts/sidebar-tools-browser.test.mjs",
     "scripts/tool-runtime-browser.test.mjs",
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
+    "scripts/model-notice-browser.test.mjs",
     "scripts/assistant-working-indicator-browser.test.mjs",
     "scripts/thinking-first-delta-once-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
     "scripts/editor-blame-browser.test.mjs",
     "scripts/file-panel-external-poll-browser.test.mjs",
+    "scripts/editor-save-race-browser.test.mjs",
     "scripts/file-quickopen-browser.test.mjs",
     "scripts/file-content-search-browser.test.mjs",
     "scripts/file-changes-browser.test.mjs",