@evandu/super-pi 0.1.133 → 0.1.135

package/dist/server/store.js

@@ -11,6 +11,19 @@ function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
  *  disk, or a failed write would leave a conversation whose model context is silently empty. The runtime is
  *  therefore handed the id and the store is handed the same one back. See `ForkRequest.forkedConversationId`. */
 export function newConversationId() { return id("conversation"); }
+/**
+ * ONE FOLDER, ONE KEY.
+ *
+ * The same directory reaches the app spelled several ways - `F:\code\app` and `F:/code/app/` and
+ * `f:\code\app` are one folder - and two workspaces for one folder are one project split in half.
+ * The key folds the separators and the trailing slash away, and folds case away only where the
+ * filesystem folds it too: Windows and macOS treat `F:\Code` and `f:\code` as one directory, Linux
+ * does not, and pretending otherwise would merge two real projects into one.
+ */
+export function workspacePathKey(path) {
+    const folded = path.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    return process.platform === "linux" ? folded : folded.toLowerCase();
+}
 function now() { return new Date().toISOString(); }
 const DEFAULT_CONVERSATION_TITLE = "\u65b0\u4f1a\u8bdd";
 /** Whether a value survives a `new Date()` round-trip. `createdAt` is typed string, but state.json only
@@ -735,6 +748,35 @@ export class Store {
             console.warn(`[super-pi latency] phase=state.snapshot bytes=${JSON.stringify(value).length} cloneMs=${Math.round(performance.now() - startedAt)}`);
         return value;
     }
+    /** Cheap scalar/entity reads for hot paths. Never expose the live mutable state object. */
+    hasWorkspace(workspaceId) {
+        return this.state.workspaces.some((workspace) => workspace.id === workspaceId);
+    }
+    conversationStatus(conversationId) {
+        return this.state.conversations.find((conversation) => conversation.id === conversationId)?.status;
+    }
+    question(conversationId, messageId, index) {
+        const question = this.state.conversations.find((conversation) => conversation.id === conversationId)
+            ?.messages.find((message) => message.id === messageId)?.toolCalls?.[index]?.question;
+        return question ? structuredClone(question) : undefined;
+    }
+    pendingQuestion(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            return undefined;
+        for (let messageIndex = conversation.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+            const message = conversation.messages[messageIndex];
+            if (message.role !== "assistant")
+                continue;
+            for (let index = (message.toolCalls?.length ?? 0) - 1; index >= 0; index -= 1) {
+                const question = message.toolCalls?.[index]?.question;
+                if (message.toolCalls?.[index]?.label === "question" && question?.status === "pending") {
+                    return { messageId: message.id, index, question: structuredClone(question) };
+                }
+            }
+        }
+        return undefined;
+    }
     /**
      * Whether a conversation already holds a message with this id.
      *
@@ -767,6 +809,17 @@ export class Store {
             return undefined;
         return { conversation: structuredClone(conversation), workspace: structuredClone(workspace) };
     }
+    /**
+     * THE PHYSICAL DIRECTORY IS THE WORKSPACE'S IDENTITY.
+     *
+     * A workspace is a folder, not a row in a table: two workspaces pointing at the same directory are
+     * the same project, and the app used to mint a fresh UUID for each one. That is what broke
+     * re-adding a workspace - the new id matched none of the conversations that belonged to that
+     * directory, so the history was unreachable (and, before the soft unmount, actually deleted).
+     *
+     * So the same folder always means the same workspace id, and the id is what the conversations
+     * point at.
+     */
     async createWorkspace(name, path) {
         const cleanName = name.trim();
         if (!cleanName || cleanName.length > 80)
@@ -774,6 +827,19 @@ export class Store {
         const cleanPath = path?.trim() || process.cwd();
         if (cleanPath.length > 500)
             throw new Error("工作区路径太长了。");
+        // THE SAME FOLDER IS THE SAME WORKSPACE. Adding a directory that is already here re-opens it
+        // instead of forking a second one: the id stays, the conversations stay attached to it, and the
+        // name is left alone (renaming is an explicit action elsewhere, and silently renaming a
+        // workspace because someone typed a name into the add dialog would be its own surprise).
+        const existing = this.state.workspaces.find((item) => workspacePathKey(item.path) === workspacePathKey(cleanPath));
+        if (existing) {
+            if (existing.closedAt) {
+                delete existing.closedAt;
+                existing.updatedAt = now();
+                await this.persist();
+            }
+            return structuredClone(existing);
+        }
         const workspace = { id: id("workspace"), name: cleanName, path: cleanPath, updatedAt: now() };
         this.state.workspaces.push(workspace);
         await this.persist();
@@ -830,23 +896,55 @@ export class Store {
         await this.persist();
         return structuredClone(workspace);
     }
+    /**
+     * TAKES A WORKSPACE OUT OF THE SIDEBAR. IT DOES NOT DELETE ANYTHING.
+     *
+     * This used to cascade: the workspace row AND every conversation that pointed at it were erased
+     * from the state, in one persist. That made the most natural thing a user could do - remove a
+     * workspace to tidy the sidebar, then add the same folder back - silently destroy the history of
+     * that project, and there was no way to get it back.
+     *
+     * So the removal is a SOFT UNMOUNT, the same shape as a session's archive: the workspace row
+     * stays (with `closedAt` on it), the conversations stay, the uploads stay, and nothing is
+     * broadcast for either (see `clientState`). Adding the same folder again re-opens the very same
+     * workspace - same id, same conversations - which is the whole point of the physical path being
+     * the workspace's identity.
+     *
+     * The returned list is the conversations that were STOPPED, not deleted: a turn that was still
+     * running under a workspace that just left the sidebar cannot keep burning a model session
+     * behind the user's back, and a pending question would otherwise wait for an answer that the
+     * sidebar can no longer reach.
+     */
     async deleteWorkspace(workspaceId) {
-        if (!this.state.workspaces.some((item) => item.id === workspaceId))
+        const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
+        if (!workspace)
             throw new Error("找不到这个工作区。");
-        // Deleting the LAST workspace is allowed: a fresh store starts with zero (see `openRepository`), so
-        // "at least one" was an artifact of the old first-run seed, and the client's zero-workspace empty
-        // state is the onboarding path back in.
-        // Cascade: workspaces and conversations live in one state.json, so this single atomic persist removes
-        // both together. A waiting message needs no sweep of its own any more - it is a message inside one of
-        // the conversations being removed, so it goes with its container, which is the whole reason it is a
-        // better shape than an entry keyed by conversation id in a separate array: that array needed this
-        // cascade to avoid naming a conversation that no longer exists, and could not have been trusted to
-        // get it right on its own.
-        const doomed = new Set(this.state.conversations.filter((item) => item.workspaceId === workspaceId).map((item) => item.id));
-        this.state.workspaces = this.state.workspaces.filter((item) => item.id !== workspaceId);
-        this.state.conversations = this.state.conversations.filter((item) => item.workspaceId !== workspaceId);
+        if (workspace.closedAt)
+            return [];
+        workspace.closedAt = now();
+        workspace.updatedAt = workspace.closedAt;
         await this.persist();
-        return [...doomed];
+        return [];
+    }
+    /**
+     * THE STATE THE CLIENT IS ALLOWED TO SEE.
+     *
+     * `snapshot()` is the truth of what the store HOLDS; this is the truth of what is ON SCREEN. The
+     * difference is the closed workspaces: one that was removed from the sidebar is still in the store
+     * - that is exactly why re-adding the folder brings its history back - but it is not part of the
+     * app any more, so neither it nor its conversations are broadcast.
+     *
+     * Filtering HERE, in one place, rather than in every reader, is what keeps the client dumb: the
+     * sidebar renders `state.workspaces` and never has to know that a closed workspace exists.
+     */
+    clientState() {
+        const state = this.snapshot();
+        const closed = new Set(state.workspaces.filter((item) => item.closedAt).map((item) => item.id));
+        if (!closed.size)
+            return state;
+        state.workspaces = state.workspaces.filter((item) => !closed.has(item.id));
+        state.conversations = state.conversations.filter((item) => !closed.has(item.workspaceId));
+        return state;
     }
     async createConversation(workspaceId, configuration) {
         const workspace = this.state.workspaces.find((item) => item.id === workspaceId);

package/dist/server/types.d.ts

@@ -586,6 +586,12 @@ export type AgentCatalog = {
  * the conversation's own field, an existing conversation is therefore immune to later workspace
  * edits, and deleting the workspace default cannot reach back into sessions already born.
  */
+/**
+ * `closedAt` marks a workspace that was REMOVED FROM THE SIDEBAR but is not gone: its conversations
+ * are still on disk and still belong to it. The removal is a soft unmount, exactly like a session's
+ * `archivedAt` - a state marker, never a deletion - and the marker is what lets the same physical
+ * directory be added again later and come back with its history instead of with an empty list.
+ */
 export type Workspace = {
     id: string;
     name: string;
@@ -594,6 +600,7 @@ export type Workspace = {
     defaultModel?: ModelSelection;
     defaultThinkingLevel?: string;
     defaultAgentId?: string;
+    closedAt?: string;
 };
 /**
  * Usage accumulated across one sub-agent run. `turns` is the number of finished assistant messages,
@@ -1469,6 +1476,9 @@ export type ChangedFile = {
     at: number;
 };
 export type ServerEvent = {
+    type: "run.stopping";
+    conversationId: string;
+} | {
     type: "tools.updated";
     tools: MountedToolSummary[];
 }

package/dist/server/ws-server.d.ts

@@ -13,6 +13,9 @@ export declare class WsBroadcaster implements EventBroadcaster {
     private readonly sockets;
     private readonly coalescedSockets;
     private readonly pendingStreams;
+    private cachedState?;
+    private cachedStatePayload?;
+    private stateFlushScheduled;
     constructor(getState: () => AppState);
     register(socket: WebSocket): void;
     unregister(socket: WebSocket): void;

package/dist/server/ws-server.js

@@ -1,5 +1,6 @@
 import { WebSocket, WebSocketServer } from "ws";
 import { isAuthorized } from "./http-server.js";
+import { describeThrown, describeThrownWithStack } from "./failure-text.js";
 /**
  * Concrete implementation of EventBroadcaster delivering server events
  * across active WebSocket connections.
@@ -9,6 +10,9 @@ export class WsBroadcaster {
     sockets = new Set();
     coalescedSockets = new Set();
     pendingStreams = new Map();
+    cachedState;
+    cachedStatePayload;
+    stateFlushScheduled = false;
     constructor(getState) {
         this.getState = getState;
     }
@@ -90,7 +94,23 @@ export class WsBroadcaster {
         }
     }
     broadcastState() {
-        this.broadcast({ type: "state", state: this.getState() });
+        if (this.stateFlushScheduled)
+            return;
+        this.stateFlushScheduled = true;
+        queueMicrotask(() => {
+            this.stateFlushScheduled = false;
+            this.cachedState = this.getState();
+            this.cachedStatePayload = JSON.stringify({ type: "state", state: this.cachedState });
+            const payload = this.cachedStatePayload;
+            for (const socket of this.sockets) {
+                if (socket.readyState !== WebSocket.OPEN)
+                    continue;
+                this.flushStreaming(socket);
+                socket.send(payload);
+            }
+            this.cachedState = undefined;
+            this.cachedStatePayload = undefined;
+        });
     }
     getStateSnapshot() {
         return this.getState();
@@ -228,7 +248,8 @@ export class WsServer {
                     parsed = JSON.parse(raw.toString());
                 }
                 catch {
-                    socket.send(JSON.stringify({ type: "error", message: "command failed" }));
+                    console.error("Super Pi command error: received a frame that is not valid JSON");
+                    socket.send(JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
                     return;
                 }
                 if (parsed.type === "stream.configure") {
@@ -264,13 +285,21 @@ export class WsServer {
                         }
                     }
                     catch (error) {
+                        // A FAILED COMMAND WRITES ITSELF DOWN BEFORE IT ANSWERS.
+                        //
+                        // The server runs detached with its streams thrown away, so `console.error` here is not
+                        // decoration: the logger tees it into `<dataDir>/logs/server.log`, which is the only place
+                        // the stack survives. The browser gets the reason (never a stand-in phrase like
+                        // `command failed`), because the reader is the one who has to act on it.
+                        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: error instanceof Error ? error.message : String(error) }));
+                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
                             return;
                         }
                         socket.send(JSON.stringify({
                             type: "error",
-                            message: error instanceof Error ? error.message : "command failed",
+                            message: reason || "服务端没有说明这次失败的原因。",
                         }));
                     }
                     finally {
@@ -284,11 +313,11 @@ export class WsServer {
                 };
                 if (runIndependently)
                     void execute().catch((error) => {
-                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                        console.error("Super Pi command dispatch failed:", describeThrownWithStack(error));
                     });
                 else
                     commandQueue = commandQueue.then(execute).catch((error) => {
-                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                        console.error("Super Pi command dispatch failed:", describeThrownWithStack(error));
                     });
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.133",
+  "version": "0.1.135",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -85,10 +85,17 @@
     "scripts/workflow-ui.test.mjs",
     "scripts/agent-vis-records.test.mjs",
     "scripts/queue-store.test.mjs",
+    "scripts/git-api.test.mjs",
+    "scripts/turn-failure-marks-failed.test.mjs",
+    "scripts/update-ui-contract.test.mjs",
+    "scripts/temp-sweep.test.mjs",
+    "scripts/workspace-identity.test.mjs",
     "scripts/followup.test.mjs",
     "scripts/pi-followup-queue.test.mjs",
     "scripts/background-result-delivery.test.mjs",
+    "scripts/background-result-one-per-turn.test.mjs",
     "scripts/thinking-status-promotion.test.mjs",
+    "scripts/thinking-delivery-once.test.mjs",
     "scripts/question-call-session-path.test.mjs",
     "scripts/withdrawn-message-persistence.test.mjs",
     "scripts/git-write-endpoint-guard.test.mjs",
@@ -117,6 +124,7 @@
     "scripts/scoped-sidebar-tabs.test.mjs",
     "scripts/send-retry.test.mjs",
     "scripts/error-messages.test.mjs",
+    "scripts/stop-before-prompt.test.mjs",
     "scripts/git-diff-view.test.mjs",
     "scripts/git-blame.test.mjs",
     "scripts/fork-server.test.mjs",
@@ -157,7 +165,9 @@
     "scripts/feishu.test.mjs",
     "scripts/scheduled-tasks.test.mjs",
     "scripts/scheduled-task-scope.test.mjs",
-    "scripts/scheduled-task-tool.test.mjs"
+    "scripts/scheduled-task-tool.test.mjs",
+    "scripts/run-state-sync.test.mjs",
+    "scripts/performance-architecture.test.mjs"
   ],
   "check:browser": [
     "scripts/interrupt-browser.test.mjs",
@@ -178,10 +188,14 @@
     "scripts/md-render-browser.test.mjs",
     "scripts/right-sidebar-browser.test.mjs",
     "scripts/rail-workspace-follows-session-browser.test.mjs",
+    "scripts/git-tab-browser.test.mjs",
+    "scripts/workspace-reopen-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/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",