@evandu/super-pi 0.1.128 → 0.1.130

package/dist/server/http-server.js

@@ -7,7 +7,7 @@ import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
-import { gitDiff, gitLog, gitStatus } from "./git.js";
+import { gitBlame, gitDiff, gitLog, gitMutate, gitStatus } from "./git.js";
 import { computeFileDiff } from "./file-diff.js";
 import { MAX_KNOWLEDGE_REQUEST_BYTES } from "./knowledge.js";
 import { MAX_TOOL_BODY_BYTES } from "./tool-registry.js";
@@ -797,10 +797,6 @@ export function createHttpServer(options) {
         if (url.pathname === "/api/git") {
             const json = (status, body) => response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             try {
-                if (request.method !== "GET") {
-                    json(405, { error: "Git 视图需要 GET", code: "method" });
-                    return;
-                }
                 const workspaceId = url.searchParams.get("workspaceId");
                 const workspace = context.store.snapshot().workspaces.find((item) => item.id === workspaceId);
                 if (!workspace) {
@@ -808,6 +804,24 @@ export function createHttpServer(options) {
                     return;
                 }
                 const op = url.searchParams.get("op") ?? "status";
+                // Blame is a read with a GET shape: every other verb is refused HERE, before the POST branch
+                // could ever route the op into gitMutate and before any body is read.
+                if (op === "blame" && request.method !== "GET") {
+                    json(405, { error: "Git 请求方法不支持", code: "method" });
+                    return;
+                }
+                if (request.method === "POST") {
+                    let raw = "";
+                    for await (const chunk of request)
+                        raw += chunk;
+                    const body = raw ? JSON.parse(raw) : {};
+                    json(200, await gitMutate(workspace.path, op, body.path, body.message));
+                    return;
+                }
+                if (request.method !== "GET") {
+                    json(405, { error: "Git 请求方法不支持", code: "method" });
+                    return;
+                }
                 if (op === "status")
                     json(200, await gitStatus(workspace.path));
                 else if (op === "log")
@@ -820,6 +834,20 @@ export function createHttpServer(options) {
                     }
                     json(200, await gitDiff(workspace.path, path, url.searchParams.get("staged") === "1"));
                 }
+                else if (op === "blame") {
+                    const path = url.searchParams.get("path");
+                    if (!path) {
+                        json(400, { error: "blame 需要 path", code: "bad_path" });
+                        return;
+                    }
+                    const startLine = url.searchParams.get("startLine");
+                    const endLine = url.searchParams.get("endLine");
+                    json(200, await gitBlame(workspace.path, path, {
+                        revision: url.searchParams.get("revision") ?? undefined,
+                        startLine: startLine === null ? undefined : Number(startLine),
+                        endLine: endLine === null ? undefined : Number(endLine),
+                    }));
+                }
                 else
                     json(400, { error: "未知 Git 操作", code: "bad_op" });
             }
@@ -830,6 +858,10 @@ export function createHttpServer(options) {
                     json(404, { error: "此工作区不是 git 仓库", code: "not_a_repo" });
                 else if (code === "path")
                     json(400, { error: message, code: "bad_path" });
+                else if (code === "not_found")
+                    json(404, { error: message, code: "not_found" });
+                else if (code === "bad_range" || code === "bad_revision")
+                    json(400, { error: message, code });
                 else
                     json(400, { error: message, code: "git_error" });
             }
@@ -900,7 +932,7 @@ export function createHttpServer(options) {
                 json(400, { error: "请求体不是合法的 JSON。" });
                 return;
             }
-            const { cmd, cwd, conversationId, capability, toolCallId } = body;
+            const { cmd, description, cwd, conversationId, capability, toolCallId } = body;
             if (!cmd || !cwd || !conversationId) {
                 json(400, { error: "需要 cmd、cwd 和 conversationId。" });
                 return;
@@ -929,7 +961,7 @@ export function createHttpServer(options) {
             await store.setBackgroundTask({
                 id: sessionId,
                 conversationId,
-                title: cmd.length > 60 ? cmd.slice(0, 60) + "…" : cmd,
+                title: description?.trim() || (cmd.length > 60 ? cmd.slice(0, 60) + "…" : cmd),
                 agentId: "exec",
                 status: "running",
                 startedAt: new Date().toISOString(),

package/dist/server/pi-session.d.ts

@@ -184,6 +184,13 @@ export interface ExtensionEnvironment {
  * concurrent session's environment would otherwise land in the middle of this one.
  */
 export declare function withEnvironment<T>(values: Record<string, string>, work: () => Promise<T>): Promise<T>;
+/**
+ * `withEnvironment` for one session's extension load, serialized across all session creations.
+ *
+ * The extension factories run inside `work` and capture the values into their closures; after the
+ * window closes they never read `process.env` again, so only the WINDOW needs to be exclusive.
+ */
+export declare function withIsolatedSessionEnv<T>(values: Record<string, string>, work: () => Promise<T>): Promise<T>;
 /**
  * The live session for one conversation.
  *
@@ -210,6 +217,15 @@ export interface PiSessionLike {
      * message for later", and the caller falls back to answering it as a turn of its own.
      */
     followUp?(message: string, images?: unknown[]): Promise<"queued" | "handled">;
+    sendCustomMessage?(message: {
+        customType: string;
+        content: unknown;
+        display?: string;
+        details?: unknown;
+    }, options?: {
+        triggerTurn?: boolean;
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+    }): Promise<void>;
     /**
      * Removes every message Pi is holding in its steering and follow-up queues, and returns what was
      * removed.
@@ -354,14 +370,17 @@ export interface SessionCreation {
  *
  * The order of operations here IS the isolation mechanism, and each step is load-bearing:
  *
- * 1. The environment is applied, so the extension factories that run during the reload read this
- *    session's values rather than another session's.
- * 2. The loader is created and reloaded, which is when Pi calls the extension factories. The factories
- *    CAPTURE the values; they do not read them later.
+ * 1. The loader is created with Super Pi's extension paths, for PI to load - through its jiti
+ *    transpiler and virtual modules, the same machinery the spawned CLI used. Nothing here imports a
+ *    Super Pi extension file directly; see the comment at the loader below for why that must never
+ *    come back.
+ * 2. The reload runs inside this session's env window (`withIsolatedSessionEnv`), which is when Pi
+ *    calls the extension factories. The factories CAPTURE the values; they do not read them later.
  * 3. The session is created with that loader.
  *
- * Step 2 happening outside step 1 would give every session the same configuration, and step 1 happening
- * after step 2 would give every session no configuration at all. The window is the whole of the reload.
+ * Step 2 happening outside its env window would give every session the same configuration, and the
+ * window would give every session no configuration at all if two creations could interleave - which
+ * the serialization in `withIsolatedSessionEnv` prevents.
  *
  * THE FACTORY IS INJECTABLE. A test needs to drive a session without a real Pi behind it - to check what
  * a session was BUILT with (its working directory, its allowlist) rather than what it eventually

package/dist/server/pi-session.js

@@ -225,13 +225,40 @@ export async function withEnvironment(values, work) {
         }
     }
 }
+/**
+ * The env window of the session currently being built, so the next one queues behind it.
+ *
+ * `withEnvironment` alone is not safe here: its window is process-global, and two sessions created
+ * concurrently would interleave - A applies its capability, B applies its own, and A's extension
+ * factory captures B's credential. Chaining the windows means a concurrent creation waits for the
+ * other's `reload()` - milliseconds - instead of silently wearing its capability.
+ */
+let extensionEnvWindow = Promise.resolve();
+/**
+ * `withEnvironment` for one session's extension load, serialized across all session creations.
+ *
+ * The extension factories run inside `work` and capture the values into their closures; after the
+ * window closes they never read `process.env` again, so only the WINDOW needs to be exclusive.
+ */
+export function withIsolatedSessionEnv(values, work) {
+    const run = extensionEnvWindow.then(() => withEnvironment(values, work));
+    extensionEnvWindow = run.then(() => undefined, () => undefined);
+    return run;
+}
 export async function createPiSession(creation) {
     const startedAt = performance.now();
     traceSession(creation.sessionId, "sdk.load.begin", startedAt);
     const sdk = await loadSdk();
     traceSession(creation.sessionId, "sdk.load.end", startedAt);
     const agentDir = creation.agentDir ?? defaultAgentDir();
-    return withEnvironment(creation.extensionEnv, async () => {
+    // THE EXTENSIONS ARE PI'S TO LOAD. Every path goes to Pi's own resource loader, which imports them
+    // through its jiti transpiler with its virtual modules - and both of those are load-bearing:
+    // `@sinclair/typebox` is a Pi virtual module that NO node_modules anywhere can resolve, and Node's
+    // type stripping refuses .ts under any `node_modules` segment (which is where a published package
+    // lives). A native `import()` here survived neither - it broke every installed layout the moment it
+    // shipped, invisibly, because nothing in `npm run check` runs from an installed layout.
+    // `scripts/installed-layout.test.mjs` exists to keep that class of breakage visible.
+    return (async () => {
         // THE AGENT'S PROMPT. Pi's loader takes the same two shapes the command line took: a `systemPrompt`
         // that REPLACES Pi's own, and an `appendSystemPrompt` list of files that are ADDED to it. An agent
         // that says `promptMode: replace` gets the first, and one that says nothing gets the second - the
@@ -248,7 +275,10 @@ export async function createPiSession(creation) {
                     ? { appendSystemPrompt: [creation.systemPromptFile] }
                     : {}),
         });
-        await loader.reload();
+        // The extension factories run inside `reload()` and capture this session's env values into their
+        // closures; the window is serialized (`withIsolatedSessionEnv`) so a concurrent creation cannot
+        // land its own capability in the middle.
+        await withIsolatedSessionEnv(creation.extensionEnv, () => loader.reload());
         traceSession(creation.sessionId, "sdk.loader.reload", startedAt, `extensions=${creation.extensionPaths.length}`);
         const sessionManager = creation.persist === false
             ? sdk.SessionManager.inMemory(creation.cwd, { id: creation.sessionId })
@@ -298,7 +328,7 @@ export async function createPiSession(creation) {
             return found;
         };
         return live;
-    });
+    })();
 }
 function transcriptBytes(sessionManager) {
     const file = sessionManager.getSessionFile?.();

package/dist/server/runtime.d.ts

@@ -272,6 +272,12 @@ export interface AgentRuntime {
      * own waiting list - Pi is holding a copy, not the only copy.
      */
     followUp?(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    sendCustomMessage?(conversationId: string, message: {
+        customType: string;
+        content: string;
+        display?: string;
+        details: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Empties Pi's steering and follow-up queues, and returns what was in them.
      *
@@ -1067,6 +1073,12 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * was busy means).
      */
     followUp(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    sendCustomMessage(conversationId: string, message: {
+        customType: string;
+        content: string;
+        display?: string;
+        details: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Empties Pi's steering and follow-up queues and returns what was in them.
      *

package/dist/server/runtime.js

@@ -2184,6 +2184,12 @@ export class PiRpcRuntime {
         // do anyway.
         throw new SteerUnavailableError(`会话 ${conversationId} 当前没有可以接手的 Pi 会话，无法排队`);
     }
+    async sendCustomMessage(conversationId, message) {
+        const session = await this.sessionFor(conversationId);
+        if (!session.sendCustomMessage)
+            throw new SteerUnavailableError(`会话 ${conversationId} 的 Pi 不支持 custom message`);
+        await session.sendCustomMessage(message, { triggerTurn: true, deliverAs: "followUp" });
+    }
     /**
      * Empties Pi's steering and follow-up queues and returns what was in them.
      *

package/dist/server/store.js

@@ -636,13 +636,17 @@ export class Store {
                     console.warn(`Super Pi: state file ${repository.filePath} could not be loaded (${reason}) and could not be moved aside either (${moveError instanceof Error ? moveError.message : String(moveError)}) - the server starts with a fresh state; the unreadable file is still at ${repository.filePath}.`);
                 }
             }
-            const createdAt = now();
             // NO WRITE HERE, AND THAT IS AN INVARIANT RATHER THAN AN OMISSION: a store with no file behind it
             // stays lazy, so opening one never creates a file and never has to un-create one. `persistence-
             // repository.test.mjs` asserts it by reading the path and expecting ENOENT. Repairing an EXISTING
             // file is the other case and is handled above; this branch invented its contents and says nothing
             // until something actually happens.
-            return new Store(repository, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], backgroundTasks: [] });
+            //
+            // A fresh state starts with NO workspace, and that is a constraint rather than a gap: this branch
+            // used to seed one named after process.cwd(), so whatever directory the server happened to be
+            // launched from silently became a workspace. The first workspace is always an explicit decision -
+            // the client's zero-workspace empty state (App.tsx) asks for one instead.
+            return new Store(repository, { workspaces: [], conversations: [], subagentRuns: [], backgroundTasks: [] });
         }
     }
     async setModelFilterRules(rules) {
@@ -697,7 +701,13 @@ export class Store {
             throw error;
         }
     }
-    snapshot() { return structuredClone(this.state); }
+    snapshot() {
+        const startedAt = process.env.SUPER_PI_TRACE_LATENCY === "1" ? performance.now() : 0;
+        const value = structuredClone(this.state);
+        if (startedAt)
+            console.warn(`[super-pi latency] phase=state.snapshot bytes=${JSON.stringify(value).length} cloneMs=${Math.round(performance.now() - startedAt)}`);
+        return value;
+    }
     /**
      * Whether a conversation already holds a message with this id.
      *
@@ -796,8 +806,9 @@ export class Store {
     async deleteWorkspace(workspaceId) {
         if (!this.state.workspaces.some((item) => item.id === workspaceId))
             throw new Error("找不到这个工作区。");
-        if (this.state.workspaces.length <= 1)
-            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

package/dist/server/ws-server.js

@@ -73,7 +73,10 @@ export class WsBroadcaster {
          * 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)}`);
         for (const socket of this.sockets) {
             if (socket.readyState !== WebSocket.OPEN)
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.128",
+  "version": "0.1.130",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -43,6 +43,8 @@
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
     "scripts/pi-session.test.mjs",
+    "scripts/pi-session-isolation.test.mjs",
+    "scripts/installed-layout.test.mjs",
     "scripts/pi-model-switch.test.mjs",
     "scripts/pi-thinking-levels.test.mjs",
     "scripts/diagnose-cli.test.mjs",
@@ -101,6 +103,7 @@
     "scripts/send-retry.test.mjs",
     "scripts/error-messages.test.mjs",
     "scripts/git-diff-view.test.mjs",
+    "scripts/git-blame.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",

package/scripts/diagnose.mjs

@@ -229,8 +229,13 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       throw new Error(`timed out waiting for ${label}`);
     };
 
+    // A fresh store starts with no workspace, so the diagnosis creates the one it measures against -
+    // before any measured span, so workspace setup never lands inside a number.
+    send({ type: "workspace.create", name: "diagnose", path: process.cwd() });
+    const workspaceId = (await waitFor((e) => e.type === "state" && e.state.workspaces.some((w) => w.name === "diagnose"), "the diagnose workspace")).state.workspaces.find((w) => w.name === "diagnose").id;
+
     onProgress("creating a conversation...");
-    send({ type: "conversation.create", workspaceId: "workspace_default" });
+    send({ type: "conversation.create", workspaceId });
     await waitFor((e) => e.type === "state" && e.state.conversations.length > 0, "a conversation");
     const conversation = events.filter((e) => e.type === "state").at(-1).state.conversations[0];
 
@@ -258,13 +263,13 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       onProgress("setting a workspace default model, then creating a conversation...");
       send({
         type: "workspace.settings",
-        workspaceId: "workspace_default",
+        workspaceId,
         model: { provider: defaultModel.provider, modelId: defaultModel.modelId },
         thinkingLevel: null,
       });
       await sleep(400);
       const withDefaultStart = Date.now();
-      send({ type: "conversation.create", workspaceId: "workspace_default" });
+      send({ type: "conversation.create", workspaceId });
       const withDefault = await waitFor((e) => e.type === "state"
         && e.state.conversations.length >= 2, "a conversation with the workspace default");
       result.conversationWithDefaultMs = Date.now() - withDefaultStart;