@evandu/super-pi 0.1.32 → 0.1.34

package/dist/server/upload.js

@@ -109,8 +109,8 @@ export async function findUploadFile(uploadsDir, conversationId, filenameOrId) {
             return null;
         const directPath = join(uploadsDir, conversationId, filenameOrId);
         if (existsSync(directPath)) {
-            const s = await stat(directPath);
-            if (s.isFile()) {
+            const s = await stat(directPath).catch(() => null);
+            if (s?.isFile()) {
                 const mime = mimeForExt(extname(directPath));
                 return { filePath: directPath, mimeType: mime, size: s.size };
             }
@@ -121,29 +121,18 @@ export async function findUploadFile(uploadsDir, conversationId, filenameOrId) {
             for (const entry of entries) {
                 if (!entry.endsWith(".meta.json") && (entry === filenameOrId || entry.startsWith(`${filenameOrId}.`))) {
                     const fp = join(dir, entry);
-                    const s = await stat(fp);
-                    if (s.isFile()) {
+                    // A file listed by readdir can be gone by the time stat runs; that is a miss, not a failure.
+                    const s = await stat(fp).catch(() => null);
+                    if (s?.isFile()) {
                         return { filePath: fp, mimeType: mimeForExt(extname(fp)), size: s.size };
                     }
                 }
             }
         }
     }
-    // Fallback: search across all conversation upload directories
-    const convDirs = await readdir(uploadsDir).catch(() => []);
-    for (const conv of convDirs) {
-        const dir = join(uploadsDir, conv);
-        const entries = await readdir(dir).catch(() => []);
-        for (const entry of entries) {
-            if (!entry.endsWith(".meta.json") && (entry === filenameOrId || entry.startsWith(`${filenameOrId}.`))) {
-                const fp = join(dir, entry);
-                const s = await stat(fp);
-                if (s.isFile()) {
-                    return { filePath: fp, mimeType: mimeForExt(extname(fp)), size: s.size };
-                }
-            }
-        }
-    }
+    // Deliberately NO cross-conversation fallback here: an upload URL carries its own conversation id, and
+    // serving one conversation's request from another conversation's directory would leak images across
+    // conversations. A miss is the caller's 404, not a wider search.
     return null;
 }
 export async function deleteConversationUploads(uploadsDir, conversationId) {

package/dist/server/ws-server.js

@@ -116,14 +116,28 @@ export class WsServer {
                     socket.send(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"}`));
+            /**
+             * Liveness follows the standard ws pattern: every pong marks the peer alive, each heartbeat
+             * marks it unanswered and pings, and a peer that is STILL unanswered on the next heartbeat is
+             * terminated. Without this, a half-open connection (frozen tab, gone NAT entry, pulled cable)
+             * stays OPEN forever and every broadcast serializes full state to it.
+             */
+            let isAlive = true;
+            socket.on("pong", () => { isAlive = true; });
             const heartbeat = setInterval(() => {
-                if (socket.readyState === WebSocket.OPEN) {
-                    socket.ping();
-                    if (this.rootDir) {
-                        const v = checkDiskVersion(this.rootDir);
-                        if (v.needsRestart) {
-                            socket.send(JSON.stringify({ type: "server.version", version: v }));
-                        }
+                if (socket.readyState !== WebSocket.OPEN)
+                    return;
+                if (!isAlive) {
+                    // Fires 'close', which runs the per-socket cleanup below.
+                    socket.terminate();
+                    return;
+                }
+                isAlive = false;
+                socket.ping();
+                if (this.rootDir) {
+                    const v = checkDiskVersion(this.rootDir);
+                    if (v.needsRestart) {
+                        socket.send(JSON.stringify({ type: "server.version", version: v }));
                     }
                 }
             }, 30_000);
@@ -136,30 +150,77 @@ export class WsServer {
                     this.onSocketClose?.([...terminalSessionIds]);
                 terminalSessionIds.clear();
             });
-            socket.on("message", async (raw) => {
-                let command;
+            /**
+             * Commands from ONE socket are SERIALIZED through a promise chain. `handleCommand` is async, so
+             * a bare `async` listener lets command N+1 start while command N is still awaiting inside the
+             * services, interleaving that defeats their check-then-act guards. Chaining each command off the
+             * previous one makes same-socket execution strictly in-order while different sockets keep their
+             * own independent chains. Error handling is unchanged: each command catches its own errors and
+             * reports them on the socket, and the chain-level catch only stops an unexpected rejection from
+             * poisoning every later command on the same socket.
+             */
+            let commandQueue = Promise.resolve();
+            socket.on("message", (raw) => {
+                let parsed;
                 try {
-                    command = JSON.parse(raw.toString());
-                    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));
-                        }
-                    }, remoteAddress);
-                    if (command.operationRequestId)
-                        socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
+                    parsed = JSON.parse(raw.toString());
                 }
-                catch (error) {
-                    if (command?.operationRequestId) {
-                        socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: error instanceof Error ? error.message : String(error) }));
-                        return;
-                    }
-                    socket.send(JSON.stringify({
-                        type: "error",
-                        message: error instanceof Error ? error.message : "command failed",
-                    }));
+                catch {
+                    socket.send(JSON.stringify({ type: "error", message: "command failed" }));
+                    return;
                 }
+                // A send represents a streaming operation. It must be admitted immediately so a second send
+                // can observe the active run and enter the durable follow-up queue; waiting for the first model
+                // turn here makes every follow-up test time out and defeats the queue semantics.
+                const runIndependently = parsed.type === "message.send" || parsed.type === "run.stop";
+                // ...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
+                // be admitted onto a transcript the cut has not reached yet. Claiming here closes that gap: this
+                // is the arrival edge, and the only one early enough to be of use to a command that does not wait.
+                if (parsed.type === "message.revert")
+                    this.commandHandler.claimRevert(parsed.conversationId);
+                const execute = async () => {
+                    let command;
+                    try {
+                        command = parsed;
+                        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));
+                            }
+                        }, remoteAddress);
+                        if (command.operationRequestId)
+                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
+                    }
+                    catch (error) {
+                        if (command?.operationRequestId) {
+                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: error instanceof Error ? error.message : String(error) }));
+                            return;
+                        }
+                        socket.send(JSON.stringify({
+                            type: "error",
+                            message: error instanceof Error ? error.message : "command failed",
+                        }));
+                    }
+                    finally {
+                        // Hand the claim back whatever happened - including a revert that threw before it ever
+                        // reached the service. Without this a refused or malformed revert would leave the
+                        // conversation permanently unable to send, which is a worse failure than the one the claim
+                        // was added to prevent.
+                        if (parsed.type === "message.revert")
+                            this.commandHandler.releaseRevert(parsed.conversationId);
+                    }
+                };
+                if (runIndependently)
+                    void execute().catch((error) => {
+                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                    });
+                else
+                    commandQueue = commandQueue.then(execute).catch((error) => {
+                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                    });
             });
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,8 @@
     "prepack": "npm run build",
     "dev": "concurrently --kill-others-on-fail \"npm:dev:server\" \"npm:dev:client\"",
     "dev:client": "vite --host 0.0.0.0",
-    "dev:server": "tsx watch src/server/index.ts",
+    "dev:server": "cross-env SUPER_PI_PORT=3081 tsx watch src/server/index.ts",
+    "dev:installed": "npm run build && cross-env SUPER_PI_PORT=3080 node bin/super-pi.js",
     "build": "tsc -b && vite build",
     "start": "node dist/server/index.js",
     "restart:server": "node scripts/restart-server.mjs",
@@ -135,6 +136,7 @@
     "react-dom": "latest",
     "tsx": "latest",
     "typescript": "latest",
-    "vite": "latest"
+    "vite": "latest",
+    "cross-env": "latest"
   }
 }