@evandu/super-pi 0.1.31 → 0.1.33

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-Bv8kBXop.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BVsQMo7-.css">
+    <script type="module" crossorigin src="/assets/index-dU9RhbHX.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D6bdUvG_.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/run-service.js

@@ -165,9 +165,23 @@ export class RunService {
         // an order that never happened. The runtime calls `onToolCall` synchronously between yields, so a
         // counter advanced once per yielded delta is the real position of the call in the answer.
         let spoken = 0;
+        /**
+         * ONE COUNTER FOR EVERY ROW, AND THE ONLY WAY A ROW NUMBER IS EVER MADE.
+         *
+         * Both maps below are addressed by POSITION in the message's `toolCalls` array, so both have to count
+         * in the same space. They did not: each kept its own `map.size`, and those two numbers stop agreeing
+         * the moment a turn makes two tool calls - the first call's placeholder is consumed and the map is
+         * cleared, so the SECOND placeholder is handed the row number `0` while `appendToolCall` actually put
+         * it at `1`. From there every later write lands on the wrong row: the second call's arguments overwrote
+         * the first call's finished block, and the second call's own row was never settled, so it kept
+         * 「正在生成参数…」 for the rest of the turn. A finished tool that still claims to be generating its
+         * arguments is worse than a missing one - it says the agent is stuck on work it already did.
+         */
+        let rows = 0;
         const rowByToolCallId = new Map();
         /**
-         * Rows for calls the model is STILL WRITING, keyed by the contentIndex its toolcall_start named.
+         * Rows for calls the model is STILL WRITING, keyed by the contentIndex its toolcall_start named, and
+         * carrying the name that index announced when it had one.
          *
          * The index is the only handle that exists before the arguments are parsed: the tool's id arrives
          * with toolcall_end, and the host is told nothing until tool_execution_start. Keeping the index → row
@@ -175,34 +189,63 @@ export class RunService {
          * already looking at, instead of appending a second block for the same call and making one call look
          * like two.
          */
-        const preparingRowByIndex = new Map();
+        const preparingRows = new Map();
         const onToolPreparing = (call) => {
-            const existing = preparingRowByIndex.get(call.contentIndex);
+            const existing = preparingRows.get(call.contentIndex);
             if (existing !== undefined) {
+                // The line naming the call IMPROVES as the arguments arrive - a `read` learns its path from the
+                // first fragment - so it is patched rather than frozen at whatever the first frame could say. The
+                // fragment is stored as well, because that is what the reader watches grow.
                 if (call.delta)
-                    enqueueTools("a tool call argument", () => this.store.updateToolCall(conversation.id, assistant.id, existing, { live: call.delta }));
+                    enqueueTools("a tool call argument", () => this.store.updateToolCall(conversation.id, assistant.id, existing.row, { live: call.delta, ...(call.detail ? { detail: call.detail } : {}) }));
                 return;
             }
             // No name yet is the normal first token, and it is NOT a reason to wait: the block appearing with an
             // empty name the instant the model starts writing is what tells the reader anything is happening at
             // all, and it fills in on the next delta.
             const at = spoken;
-            enqueueTools("a tool call being prepared", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name || "工具", detail: "正在生成参数…", preparing: true, at }));
-            preparingRowByIndex.set(call.contentIndex, preparingRowByIndex.size);
+            const row = rows++;
+            // The block says WHICH TOOL and WHAT IT IS AIMED AT as soon as either is known. 「工具」 as the name
+            // and 「正在生成参数…」 as the only line below it told a reader nothing for the seconds a large `edit`
+            // spends writing its replacement text - and by the time the file path was on screen, the block looked
+            // broken rather than early. The placeholder word is now only the FALLBACK for the first fragment, when
+            // Pi has not yet said what the call is or what it opens.
+            enqueueTools("a tool call being prepared", () => this.store.appendToolCall(conversation.id, assistant.id, {
+                label: call.name || "工具",
+                ...(call.detail ? { detail: call.detail } : { detail: "正在生成参数…" }),
+                preparing: true,
+                at,
+            }));
+            preparingRows.set(call.contentIndex, { row, name: call.name });
         };
         const onToolCall = (call) => {
-            if (call.id)
-                rowByToolCallId.set(call.id, rowByToolCallId.size);
             const at = spoken;
-            const prepared = [...preparingRowByIndex.values()].at(-1);
+            // THE PLACEHOLDER THAT BELONGS TO THIS CALL, IF ONE IS ON SCREEN.
+            //
+            // A model writing two tool calls writes their arguments in one unbroken stream, so more than one
+            // placeholder can be waiting when the first execution starts, and the newest is not necessarily the
+            // one being run. The NAME is the only thing that can tell them apart - `toolcall_start` carries it
+            // when Pi has parsed it - so a name match wins over recency, and recency is only the fallback for a
+            // placeholder that never got a name.
+            const pending = [...preparingRows];
+            const prepared = pending.find(([, entry]) => entry.name === call.name) ?? pending.at(-1);
             // THE CALL THAT IS ALREADY ON SCREEN GETS FILLED IN. Appending here instead would show one call
             // twice - once as a placeholder, once as the real thing - which reads as the agent calling a tool
             // it never called.
             if (prepared !== undefined) {
-                preparingRowByIndex.clear();
-                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, prepared, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false }));
+                const row = prepared[1].row;
+                preparingRows.delete(prepared[0]);
+                // The id is bound to the row it was FILLED IN, not to a row of the caller's own counting. Every
+                // later update and the outcome resolve through this binding, so a wrong number here is a block
+                // that never settles and one that belongs to a different call.
+                if (call.id)
+                    rowByToolCallId.set(call.id, row);
+                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, row, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false }));
                 return;
             }
+            const row = rows++;
+            if (call.id)
+                rowByToolCallId.set(call.id, row);
             enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at }));
         };
         const onToolUpdate = (call) => {

package/dist/server/http-server.js

@@ -1,4 +1,5 @@
 import { createReadStream, existsSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { readdir, stat } from "node:fs/promises";
 import { createServer } from "node:http";
 import { homedir, networkInterfaces } from "node:os";
@@ -191,6 +192,24 @@ export function createHttpServer(options) {
             setTimeout(() => { void onShutdown("api-shutdown"); }, 50);
             return;
         }
+        if (url.pathname === "/api/update" && request.method === "POST") {
+            if (!isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403).end("Update requires a loopback or private network POST");
+                return;
+            }
+            response.writeHead(202, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ status: "updating" }));
+            const command = process.platform === "win32" ? "pi.cmd" : "pi";
+            const child = spawn(command, ["update", "npm:@evandu/super-pi"], { cwd: rootDir, detached: true, stdio: "ignore", shell: process.platform === "win32", env: process.env });
+            child.on("close", (code) => {
+                if (code !== 0)
+                    return;
+                const restart = spawn(process.execPath, [join(rootDir, "scripts", "restart-server.mjs")], { cwd: rootDir, detached: true, stdio: "ignore", env: process.env });
+                restart.unref();
+            });
+            child.on("error", () => { });
+            child.unref();
+            return;
+        }
         if (url.pathname === "/api/health") {
             const version = checkDiskVersion(rootDir);
             response.writeHead(200, { "content-type": "application/json; charset=utf-8" })

package/dist/server/model-filter.js

@@ -1,4 +1,4 @@
-// Workspace names match case-insensitively. A model is allowed when either its label
+// Workspace paths match case-insensitively. A model is allowed when either its label
 // or provider/modelId matches. All matching rules must allow it (intersection).
 // Invalid regexes are skipped with a diagnostic, never interpreted as deny-all.
 export function applicableRules(rules, workspace) {
@@ -6,7 +6,8 @@ export function applicableRules(rules, workspace) {
         try {
             const workspaceRegex = new RegExp(rule.workspacePattern, "i");
             const modelRegex = new RegExp(rule.modelPattern, "i");
-            return workspaceRegex.test(workspace.name) ? [{ rule, modelRegex }] : [];
+            const workspacePath = workspace.path.replace(/[\\/]+/g, "/");
+            return workspaceRegex.test(workspacePath) ? [{ rule, modelRegex }] : [];
         }
         catch (error) {
             console.warn(`模型过滤规则 ${rule.id} 无效，已跳过：${rule.workspacePattern} → ${rule.modelPattern}：${String(error)}`);

package/dist/server/runtime.js

@@ -8,7 +8,7 @@ import { resolvePiCommand, shellQuote } from "./pi-command.js";
 import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
-import { describeToolCall, describeToolCallArgs, extractToolResultText } from "./tool-calls.js";
+import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractToolResultText } from "./tool-calls.js";
 /** Deterministic offline runtime used by tests and local UI development. */
 export class WelcomeRuntime {
     async *answer({ prompt, signal }) {
@@ -827,6 +827,18 @@ export class PiRpcRuntime {
             // record is announced once per distinct type and then tallied instead of logging per event.
             const announced = new Set();
             const repeats = new Map();
+            /**
+             * THE ARGUMENT TEXT EACH CALL HAS PRODUCED SO FAR, keyed by the contentIndex `toolcall_start` named.
+             *
+             * Held per TURN and cleared with it, so a second turn writing a different call to the same index
+             * starts from an empty string rather than from the previous call's file path. The fragments are
+             * still handed on one at a time as `delta`; this is only what a line naming the call is read out of,
+             * and a block that could show 「正在生成参数…」 instead of the file it is about to open was telling
+             * the reader less than the record already knew.
+             */
+            const argumentText = new Map();
+            /** The tool name `toolcall_start` announced for each index, so a later fragment can still name it. */
+            const toolNames = new Map();
             const noteUnhandled = (key) => {
                 if (announced.has(key))
                     repeats.set(key, (repeats.get(key) ?? 0) + 1);
@@ -977,10 +989,23 @@ export class PiRpcRuntime {
                         // would mean guessing at a document that is not finished. It is handed on as it comes.
                         if (event?.type === "text_delta")
                             yield event.delta ?? "";
-                        else if (event?.type === "toolcall_start" && typeof event.contentIndex === "number")
+                        else if (event?.type === "toolcall_start" && typeof event.contentIndex === "number") {
+                            // A fresh index means a fresh call, so anything the PREVIOUS call at this index wrote is
+                            // dropped here rather than carried into this one's first fragment.
+                            argumentText.delete(event.contentIndex);
+                            toolNames.set(event.contentIndex, toolNameOf(event.partial));
                             onToolPreparing?.({ contentIndex: event.contentIndex, name: toolNameOf(event.partial) });
-                        else if (event?.type === "toolcall_delta" && typeof event.contentIndex === "number")
-                            onToolPreparing?.({ contentIndex: event.contentIndex, name: "", ...(typeof event.delta === "string" ? { delta: event.delta } : {}) });
+                        }
+                        else if (event?.type === "toolcall_delta" && typeof event.contentIndex === "number") {
+                            const delta = typeof event.delta === "string" ? event.delta : "";
+                            // The NAME IS CARRIED FORWARD because the line naming the call needs it: `toolcall_start`
+                            // is the only event that carries one, and by the second fragment the mapping has to choose
+                            // between a `read`'s path and a `bash`'s command.
+                            const name = toolNames.get(event.contentIndex) ?? "";
+                            argumentText.set(event.contentIndex, `${argumentText.get(event.contentIndex) ?? ""}${delta}`);
+                            const detail = describeToolCallInProgress(name, argumentText.get(event.contentIndex) ?? "");
+                            onToolPreparing?.({ contentIndex: event.contentIndex, name, ...(delta ? { delta } : {}), ...(detail ? { detail } : {}) });
+                        }
                         else
                             noteUnhandled(`message_update:${JSON.stringify(event?.type ?? "(missing)")}`);
                         continue;

package/dist/server/terminal.d.ts

@@ -99,8 +99,7 @@ export type TerminalEvent = {
     reason?: string;
 };
 /**
- * Reads the opt-in flag. Anything other than an explicit truthy string leaves the terminal OFF, so a
- * typo in a deployment config fails closed rather than silently exposing a shell.
+ * Reads the opt-in flag. Anything other than an explicit truthy string leaves the terminal OFF.
  */
 export declare function isTerminalEnabled(env?: NodeJS.ProcessEnv): boolean;
 /** The sentence a browser shows when the terminal is missing. Says WHICH of the three gates closed. */

package/dist/server/terminal.js

@@ -164,8 +164,7 @@ const MAX_CHUNK_BYTES = 64 * 1024;
 /** Hard per-session backlog. Beyond this the session is considered runaway and is killed. */
 const MAX_BACKLOG_BYTES = 4 * 1024 * 1024;
 /**
- * Reads the opt-in flag. Anything other than an explicit truthy string leaves the terminal OFF, so a
- * typo in a deployment config fails closed rather than silently exposing a shell.
+ * Reads the opt-in flag. Anything other than an explicit truthy string leaves the terminal OFF.
  */
 export function isTerminalEnabled(env = process.env) {
     const raw = env.SUPER_PI_TERMINAL?.trim().toLowerCase();
@@ -174,7 +173,7 @@ export function isTerminalEnabled(env = process.env) {
 /** The sentence a browser shows when the terminal is missing. Says WHICH of the three gates closed. */
 export function terminalDisabledReason(env = process.env) {
     if (!isTerminalEnabled(env))
-        return "终端未启用。设置 SUPER_PI_TERMINAL=1 后重启 Super Pi 即可使用。";
+        return "终端未启用。设置 SUPER_PI_TERMINAL=1 后重启即可使用。";
     if (ptyLoadFailure)
         return `node-pty 未能加载（${ptyLoadFailure}）。请重新安装依赖，或确认 node-pty 版本不低于 ${MINIMUM_PTY_VERSION}。`;
     return "";

package/dist/server/tool-calls.d.ts

@@ -62,6 +62,27 @@ export declare function extractToolResultText(result: unknown): ToolResultSummar
  * shape can be regression-tested at all.
  */
 export declare function describeToolCall(name: string, args: unknown): string | undefined;
+/**
+ * THE SAME LINE, READ OUT OF A CALL THAT IS STILL BEING WRITTEN.
+ *
+ * The block for a call appears the instant the model starts writing it, and for an `edit` that is several
+ * seconds before the arguments are complete. Showing 「工具 · 正在生成参数…」 through all of it says the
+ * reader nothing they can act on - not WHICH tool, and not what it is aimed at, which are the two things
+ * the finished block is going to say. So the same `describeToolCall` mapping runs against the fragments
+ * that have arrived so far.
+ *
+ * TWO STEPS, because a partial JSON document almost never parses. The fragments are tried whole first -
+ * that is the case where the last one closed the object. Failing that, the FIRST `"key": "value"` pair in
+ * the text is read out on its own, and its value does not have to be CLOSED - a fragment usually stops
+ * mid-string, and a path that has arrived half-written still says more than a placeholder does. A fragment
+ * that has produced neither yet yields `undefined`, and the caller decides what an unknown call says
+ * rather than this module inventing a word for it.
+ *
+ * The pair is read with a pattern rather than by parsing a repaired document: repairing JSON is a parser's
+ * job, and a half-repaired document here would risk naming the wrong file - the one thing this line must
+ * never do.
+ */
+export declare function describeToolCallInProgress(name: string, argumentsSoFar: string): string | undefined;
 /**
  * Every parameter of one call, as a bounded list of `key`/`value` pairs a block can show when expanded.
  *

package/dist/server/tool-calls.js

@@ -152,6 +152,46 @@ export function describeToolCall(name, args) {
     }
     return undefined;
 }
+/**
+ * THE SAME LINE, READ OUT OF A CALL THAT IS STILL BEING WRITTEN.
+ *
+ * The block for a call appears the instant the model starts writing it, and for an `edit` that is several
+ * seconds before the arguments are complete. Showing 「工具 · 正在生成参数…」 through all of it says the
+ * reader nothing they can act on - not WHICH tool, and not what it is aimed at, which are the two things
+ * the finished block is going to say. So the same `describeToolCall` mapping runs against the fragments
+ * that have arrived so far.
+ *
+ * TWO STEPS, because a partial JSON document almost never parses. The fragments are tried whole first -
+ * that is the case where the last one closed the object. Failing that, the FIRST `"key": "value"` pair in
+ * the text is read out on its own, and its value does not have to be CLOSED - a fragment usually stops
+ * mid-string, and a path that has arrived half-written still says more than a placeholder does. A fragment
+ * that has produced neither yet yields `undefined`, and the caller decides what an unknown call says
+ * rather than this module inventing a word for it.
+ *
+ * The pair is read with a pattern rather than by parsing a repaired document: repairing JSON is a parser's
+ * job, and a half-repaired document here would risk naming the wrong file - the one thing this line must
+ * never do.
+ */
+export function describeToolCallInProgress(name, argumentsSoFar) {
+    const text = argumentsSoFar.trim();
+    if (!text)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        const described = describeToolCall(name, parsed);
+        if (described)
+            return described;
+    }
+    catch { /* the document is still being written, which is the normal case here */ }
+    const pair = /"([A-Za-z_][A-Za-z0-9_-]*)"\s*:\s*"((?:[^"\\]|\\.)*)/.exec(text);
+    if (!pair)
+        return undefined;
+    // The closing quote is OPTIONAL in the pattern because a fragment almost always stops mid-string, and a
+    // path that has arrived half-written is still worth more than the placeholder word. What is captured is
+    // unescaped because an escaped quote is part of the VALUE, not the end of it - without this, a file
+    // named with a quote in it would be displayed with a backslash the reader never typed.
+    return describeToolCall(name, { [pair[1]]: pair[2].replace(/\\(["\\])/g, "$1") });
+}
 /**
  * How one non-string argument value is NAMED without being read.
  *

package/dist/server/types.d.ts

@@ -170,11 +170,18 @@ export type ToolCallNotice = {
     live?: string;
     preparing?: boolean;
 };
-/** WHAT THE RUNTIME HANDS A CALLER WHEN THE MODEL STARTS, OR CONTINUES, BUILDING A TOOL CALL. */
+/** WHAT THE RUNTIME HANDS A CALLER WHEN THE MODEL STARTS, OR CONTINUES, BUILDING A TOOL CALL. *
+ *
+ * `detail` is the line naming what the call is aimed at - the file for a `read`, the command for a `bash`
+ * - read out of the arguments as far as they have arrived. It is `undefined` when nothing identifying has
+ * been written yet, which is a different fact from an empty one: the caller has a placeholder word for the
+ * second case and must not invent one for the first.
+ */
 export interface ToolCallPreparing {
     contentIndex: number;
     name: string;
     delta?: string;
+    detail?: string;
 }
 /**
  * `archivedAt` is the whole archive mechanism: a state MARKER, not a move. The conversation object never

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -96,7 +96,8 @@
     "scripts/queue-dock.test.mjs",
     "scripts/md-render-browser.test.mjs",
     "scripts/right-sidebar-browser.test.mjs",
-    "scripts/sidebar-tools-browser.test.mjs", "scripts/session-context-menu-browser.test.mjs",
+    "scripts/sidebar-tools-browser.test.mjs",
+    "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
     "scripts/msg-tabs-browser.test.mjs",