@evandu/super-pi 0.1.52 → 0.1.54

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-PIHGU_8U.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DJD8mXiK.css">
+    <script type="module" crossorigin src="/assets/index-GghJcmHm.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Cb_uyk8r.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/run-service.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "../store.js";
-import type { AgentRuntime } from "../runtime.js";
+import { type AgentRuntime } from "../runtime.js";
 import type { SubagentRunRecorder } from "../subagent-runs.js";
 import type { Conversation, Message, MessageImage, PiQueueSnapshot, QuestionAnswer, Workspace } from "../types.js";
 import type { EventBroadcaster } from "../server-context.js";
@@ -155,6 +155,8 @@ export declare class RunService {
      * Steers a queued message into the in-flight turn.
      */
     steer(conversationId: string, queueId: string): Promise<void>;
+    /** Starts a chosen saved message only when the conversation is idle. */
+    sendQueued(conversationId: string, queueId: string): Promise<void>;
     private steerUnsafe;
     /**
      * Cancels a queued message.

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

@@ -1,3 +1,4 @@
+import { SteerUnavailableError } from "../runtime.js";
 import { checkSubagentDepth, parentDeniedTools, subagentRoster } from "../task-tool.js";
 import { newSubagentRunId } from "../subagents.js";
 import { readAgents } from "../agents.js";
@@ -553,10 +554,48 @@ export class RunService {
     async steer(conversationId, queueId) {
         return this.serializeConversation(conversationId, () => this.steerUnsafe(conversationId, queueId));
     }
+    /** Starts a chosen saved message only when the conversation is idle. */
+    async sendQueued(conversationId, queueId) {
+        const waitForStop = async () => {
+            // A stop broadcasts `stopped` before the previous run has finished its finally block. Allow that
+            // short cleanup window; a click on the newly visible button must not race the old run slot.
+            const deadline = Date.now() + 15_000;
+            while (this.activeRuns.has(conversationId) && this.store.snapshot().conversations.find((item) => item.id === conversationId)?.status === "stopped" && Date.now() < deadline) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+        };
+        await waitForStop();
+        return this.serializeConversation(conversationId, async () => {
+            if (this.activeRuns.has(conversationId))
+                throw new Error("当前轮仍在运行；停止或等待它结束后再发送这条消息");
+            const queued = await this.store.takeQueuedMessage(conversationId, queueId);
+            const userMessageCount = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.filter((item) => item.role === "user").length ?? 0;
+            // Claim the run immediately, then release the command lane. Waiting for the whole model turn here
+            // would block every later queue action from this socket until the answer completes.
+            void this.enqueueAndRun(conversationId, queued.content, queued.images).catch(async (error) => {
+                // Once the turn has a user message it is already in the transcript. Requeue only a preflight
+                // failure, or the same prompt would be shown as both sent and waiting to be sent again.
+                const sent = (this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.filter((item) => item.role === "user").length ?? 0) > userMessageCount;
+                if (!sent)
+                    await this.store.enqueueMessage(conversationId, queued.content, queued.images);
+                this.broadcaster.broadcastState();
+                console.warn(`Super Pi: explicit queued send failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            this.broadcaster.broadcastState();
+        });
+    }
     async steerUnsafe(conversationId, queueId) {
         if (!this.runtime.steer) {
             throw new Error("当前运行时没有插队能力，无法把排队消息插到正在运行的这轮里");
         }
+        // A running conversation may be in the tiny hand-off window after Pi ended but before this service
+        // opens the next queued turn. Priority delivery has the same user meaning in both cases, so reserve
+        // the message for the next turn instead of turning a successful click into an implementation error.
+        if (this.runtime.canSteer && !this.runtime.canSteer(conversationId)) {
+            await this.store.prioritizeQueuedMessage(conversationId, queueId);
+            this.broadcaster.broadcastState();
+            return;
+        }
         const claimed = await this.store.claimQueuedMessage(conversationId, queueId);
         this.broadcaster.broadcastState();
         try {
@@ -566,6 +605,12 @@ export class RunService {
             }
         }
         catch (error) {
+            if (error instanceof SteerUnavailableError) {
+                await this.store.releaseQueuedMessage(claimed.id);
+                await this.store.prioritizeQueuedMessage(conversationId, claimed.id);
+                this.broadcaster.broadcastState();
+                return;
+            }
             await this.store.releaseQueuedMessage(claimed.id);
             throw error;
         }

package/dist/server/command-handler.js

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 /**
  * Routes client commands to appropriate application services and converts results or errors.
  */
@@ -162,6 +163,10 @@ export class CommandHandler {
             await this.runService.steer(command.conversationId, command.queueId);
             return;
         }
+        if (command.type === "message.sendQueued") {
+            await this.runService.sendQueued(command.conversationId, command.queueId);
+            return;
+        }
         if (command.type === "message.cancel") {
             await this.runService.cancelQueued(command.conversationId, command.queueId);
             return;
@@ -232,6 +237,24 @@ export class CommandHandler {
             await this.catalogService.rescan();
             return;
         }
+        if (command.type === "super_pi.start") {
+            const port = Number(process.env.SUPER_PI_PORT ?? 3080);
+            const url = `http://127.0.0.1:${port}`;
+            const platform = process.platform;
+            if (platform === "darwin")
+                spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+            else if (platform === "win32")
+                spawn("cmd.exe", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+            else
+                spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+            return;
+        }
+        if (command.type === "super_pi.update") {
+            spawn("pi", ["update", "@evandu/super-pi"], { stdio: "inherit", shell: true }).on("error", () => {
+                console.error("Super Pi: `pi update @evandu/super-pi` failed — is the `pi` command in your PATH?");
+            });
+            return;
+        }
         throw new Error(`未知的命令类型：${JSON.stringify(command.type ?? null)}`);
     }
 }

package/dist/server/runtime.d.ts

@@ -112,6 +112,9 @@ export interface AnswerInput {
  * in the model's context and one that is not, and the UI must not claim either without knowing which.
  */
 export type SteerDisposition = "handled" | "queued";
+/** A steer that provably never reached Pi; the caller may safely use the next turn instead. */
+export declare class SteerUnavailableError extends Error {
+}
 /**
  * What a revert has to be told, and what it is told afterwards. Declared here rather than in `types.ts`
  * because neither travels to the browser: this is the runtime's own account of a file it changed.
@@ -185,6 +188,7 @@ export interface AgentRuntime {
      * Absent on a runtime with no Pi behind it (the welcome runtime), which has nothing to steer.
      */
     steer?(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    canSteer?(conversationId: string): boolean;
     /**
      * ONE-SHOT TITLE GENERATION. Spawns its own short-lived Pi child rather than borrowing a running one.
      *
@@ -630,6 +634,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * it was started.
      */
     private readonly pi;
+    canSteer(conversationId: string): boolean;
     constructor(sessionDir: string, command?: string, 
     /**
      * Where agent definitions are read from and where their prompt bodies are written. A THIRD positional

package/dist/server/runtime.js

@@ -10,6 +10,9 @@ import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_END
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
+/** A steer that provably never reached Pi; the caller may safely use the next turn instead. */
+export class SteerUnavailableError extends Error {
+}
 /** Deterministic offline runtime used by tests and local UI development. */
 export class WelcomeRuntime {
     async *answer({ prompt, signal }) {
@@ -602,6 +605,10 @@ export class PiRpcRuntime {
      * it was started.
      */
     pi;
+    canSteer(conversationId) {
+        const run = this.runs.get(conversationId);
+        return Boolean(run && run.child.exitCode === null && !run.child.killed && !run.child.stdin.destroyed);
+    }
     constructor(sessionDir, command, 
     /**
      * Where agent definitions are read from and where their prompt bodies are written. A THIRD positional
@@ -1234,14 +1241,15 @@ export class PiRpcRuntime {
         catch (error) {
             if (child.exitCode === null && child.pid !== undefined)
                 await killTree(child.pid);
-            await new Promise((resolve) => { child.once("exit", resolve); setTimeout(resolve, 5000); });
+            // taskkill has already terminated the process tree; do not add a five-second UI stall waiting for
+            // Node's exit event bookkeeping on Windows.
             throw error instanceof Error ? error : new Error(`无法向 Pi 询问会话文件：${String(error)}`);
         }
         // The lookup Pi is holding open is finished; it is killed BEFORE the file is touched, for the same
         // reason `answer()` kills before returning: a process still tearing down can still be appending.
         if (child.exitCode === null && child.pid !== undefined)
             await killTree(child.pid);
-        await new Promise((resolve) => { child.once("exit", resolve); setTimeout(resolve, 5000); });
+        // The process tree is dead after killTree; copying can proceed without waiting for a delayed exit event.
         if (!sessionFile)
             throw new Error("Pi 没有报告这个会话的记录文件，已放弃，没有改动任何文件。");
         const exists = await stat(sessionFile).catch(() => undefined);
@@ -1325,12 +1333,12 @@ export class PiRpcRuntime {
         catch (error) {
             if (child.exitCode === null && child.pid !== undefined)
                 await killTree(child.pid);
-            await new Promise((resolve) => { child.once("exit", resolve); setTimeout(resolve, 5000); });
+            // killTree waits for taskkill; waiting again for Node's exit event can miss the event and add 5s.
             throw error instanceof Error ? error : new Error(`无法向 Pi 询问会话文件：${String(error)}`);
         }
         if (child.exitCode === null && child.pid !== undefined)
             await killTree(child.pid);
-        await new Promise((resolve) => { child.once("exit", resolve); setTimeout(resolve, 5000); });
+        // killTree waits for taskkill; do not wait for a possibly already-delivered exit event.
         if (!sessionFile)
             throw new Error("Pi 没有报告这个会话的记录文件，已放弃，没有复制任何文件。");
         const exists = await stat(sessionFile).catch(() => undefined);
@@ -1516,10 +1524,8 @@ export class PiRpcRuntime {
     }
     async steer(conversationId, message, images) {
         const run = this.runs.get(conversationId);
-        if (!run)
-            throw new Error(`会话 ${conversationId} 现在没有正在运行的 Pi 进程，无法插队；这条消息仍在队列里，可以等下一轮或取消。`);
-        if (run.child.exitCode !== null || run.child.killed || run.child.stdin.destroyed)
-            throw new Error(`会话 ${conversationId} 的 Pi 进程已经结束，无法插队；这条消息仍在队列里。`);
+        if (!run || !this.canSteer(conversationId))
+            throw new SteerUnavailableError(`会话 ${conversationId} 的 Pi 进程已结束`);
         const id = `steer_${++this.steerSeq}`;
         const imagePayloads = this.options.uploadsDir && images?.length
             ? await loadConversationImages(this.options.uploadsDir, conversationId, images)

package/dist/server/store.d.ts

@@ -360,6 +360,8 @@ export declare class Store {
      * same message would put the text into Pi twice.
      */
     claimQueuedMessage(conversationId: string, queueId: string): Promise<QueuedMessage>;
+    /** Keep a priority request at the front even if the current Pi process has already exited. */
+    prioritizeQueuedMessage(conversationId: string, queueId: string): Promise<QueuedMessage>;
     /**
      * Puts a `sending` entry back into the queue.
      *
@@ -395,6 +397,8 @@ export declare class Store {
      * `open` does not put it back, because it may well have been delivered.
      */
     takeNextQueuedMessage(conversationId: string): Promise<QueuedMessage | undefined>;
+    /** Removes one still-cancellable row by id so an explicit user action can start it as a new turn. */
+    takeQueuedMessage(conversationId: string, queueId: string): Promise<QueuedMessage>;
     /**
      * Returns every `sending` message of this conversation to the queue, for the end of a turn.
      *

package/dist/server/store.js

@@ -1151,6 +1151,19 @@ export class Store {
         if (message.state === "sending")
             throw new Error(`排队消息已经交给 Agent 了：${queueId}`);
         message.state = "sending";
+        message.priority = true;
+        await this.persistCollections("queuedMessages");
+        return structuredClone(message);
+    }
+    /** Keep a priority request at the front even if the current Pi process has already exited. */
+    async prioritizeQueuedMessage(conversationId, queueId) {
+        const index = this.state.queuedMessages.findIndex((item) => item.id === queueId && item.conversationId === conversationId);
+        if (index < 0)
+            throw new Error(`排队消息不存在或已发出：${queueId}`);
+        const message = this.state.queuedMessages[index];
+        if (message.state === "sending")
+            return structuredClone(message);
+        message.priority = true;
         await this.persistCollections("queuedMessages");
         return structuredClone(message);
     }
@@ -1207,13 +1220,26 @@ export class Store {
      * `open` does not put it back, because it may well have been delivered.
      */
     async takeNextQueuedMessage(conversationId) {
-        const index = this.state.queuedMessages.findIndex((item) => item.conversationId === conversationId && item.state === "queued");
+        let index = this.state.queuedMessages.findIndex((item) => item.conversationId === conversationId && item.state === "queued" && item.priority);
+        if (index < 0)
+            index = this.state.queuedMessages.findIndex((item) => item.conversationId === conversationId && item.state === "queued");
         if (index < 0)
             return undefined;
         const [taken] = this.state.queuedMessages.splice(index, 1);
         await this.persistCollections("queuedMessages");
         return structuredClone(taken);
     }
+    /** Removes one still-cancellable row by id so an explicit user action can start it as a new turn. */
+    async takeQueuedMessage(conversationId, queueId) {
+        const index = this.state.queuedMessages.findIndex((item) => item.id === queueId && item.conversationId === conversationId);
+        if (index < 0)
+            throw new Error("这条排队消息已经发出或不存在");
+        if (this.state.queuedMessages[index].state !== "queued")
+            throw new Error("当前轮还没有结束；请先停止或等待它结束，再发送这条消息");
+        const [taken] = this.state.queuedMessages.splice(index, 1);
+        await this.persistCollections("queuedMessages");
+        return structuredClone(taken);
+    }
     /**
      * Returns every `sending` message of this conversation to the queue, for the end of a turn.
      *

package/dist/server/types.d.ts

@@ -670,6 +670,8 @@ export type QueuedMessage = {
     conversationId: string;
     content: string;
     state: "queued" | "sending";
+    /** Chosen for priority delivery. Survives a Pi turn boundary and a server restart. */
+    priority?: boolean;
     createdAt: string;
     images?: MessageImage[];
 };
@@ -961,6 +963,12 @@ export type ClientCommandBody =
     type: "message.steer";
     conversationId: string;
     queueId: string;
+}
+/** Starts this saved queued message as the next turn, only after the current turn has ended. */
+ | {
+    type: "message.sendQueued";
+    conversationId: string;
+    queueId: string;
 } | {
     type: "run.stop";
     conversationId: string;
@@ -1008,6 +1016,14 @@ export type ClientCommandBody =
     dirs: string[];
 } | {
     type: "agents.rescan";
+}
+/** Opens the browser at the Super Pi web UI, starting the server if it is not running. */
+ | {
+    type: "super_pi.start";
+}
+/** Runs `pi self-update` to update Super Pi. */
+ | {
+    type: "super_pi.update";
 } | ({
     type: "extension.ui.answer";
     conversationId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",