@evandu/super-pi 0.1.163 → 0.1.165

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

@@ -176,8 +176,15 @@ export class RunService {
     runCompletions = new Map();
     /** A selected interrupt owns the next free run slot, even while the old child exits. */
     interruptTargets = new Map();
+    shuttingDown = false;
+    /** Preserve incoming background results as waiting messages while the server drains its producers. */
+    beginShutdown() {
+        this.shuttingDown = true;
+    }
     /** Claims the run slot and arms its completion promise. Call sites release with `releaseRunSlot`. */
     claimRunSlot(conversationId, controller) {
+        if (this.shuttingDown)
+            throw new Error("服务正在关闭，请重启后再发送消息。");
         let resolve;
         const promise = new Promise((resolvePromise) => { resolve = resolvePromise; });
         this.runCompletions.set(conversationId, { promise, resolve });
@@ -322,7 +329,7 @@ export class RunService {
                 //
                 // BUSY: steer the result into the running turn so Pi drains it at the very next tool batch
                 // boundary instead of waiting for the whole turn to complete.
-                void this.dispatchBackgroundResult(task.conversationId, queued.id).catch(async (error) => {
+                void this.trackDetached(this.dispatchBackgroundResult(task.conversationId, queued.id)).catch(async (error) => {
                     console.warn(`Super Pi: dispatch background exec result failed: ${error instanceof Error ? error.message : "unknown error"}`);
                     await this.settleBackgroundStatus(task.conversationId);
                 });
@@ -378,7 +385,7 @@ export class RunService {
             });
             if (!queued)
                 return;
-            void this.dispatchBackgroundResult(parentId, queued.id).catch((error) => {
+            void this.trackDetached(this.dispatchBackgroundResult(parentId, queued.id)).catch((error) => {
                 console.warn(`Super Pi: dispatch child session result failed: ${error instanceof Error ? error.message : "unknown error"}`);
             });
         })());
@@ -392,6 +399,8 @@ export class RunService {
      * INTERRUPTING: quietly leaves the message waiting; the interrupted or next turn will pick it up.
      */
     async dispatchBackgroundResult(conversationId, messageId) {
+        if (this.shuttingDown)
+            return;
         if (this.interruptTargets.has(conversationId))
             return;
         if (!this.activeRuns.has(conversationId)) {
@@ -404,7 +413,7 @@ export class RunService {
             // so calling it from inside the serialized callback re-enters the lane and deadlocks: the
             // outer work waits for the inner one, and the inner one waits for the outer one.
             const startWaiting = await this.serializeConversation(conversationId, async () => {
-                if (this.interruptTargets.has(conversationId))
+                if (this.shuttingDown || this.interruptTargets.has(conversationId))
                     return false;
                 // `processWaitingMessage` acquires this lane, so the fallback must run after serialization exits.
                 if (!this.activeRuns.has(conversationId))
@@ -421,6 +430,11 @@ export class RunService {
                 this.broadcaster.broadcastState();
                 const claimed = await this.store.claimWaitingMessage(conversationId, messageId);
                 this.broadcaster.broadcastState();
+                if (this.shuttingDown) {
+                    await this.store.releaseWaitingMessage(conversationId, claimed.id);
+                    this.broadcaster.broadcastState();
+                    return false;
+                }
                 try {
                     await this.runtime.steer(conversationId, composePrompt(claimed), claimed.images);
                 }
@@ -1788,14 +1802,15 @@ export class RunService {
             await this.awaitRunSlotReleased(conversation.id, false);
         this.assertHistoryAvailable(conversationId);
         const busy = this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id);
-        const reservedController = busy ? undefined : new AbortController();
+        const queueOnly = busy || this.shuttingDown;
+        const reservedController = queueOnly ? undefined : new AbortController();
         if (reservedController) {
             this.cancelledQuestionConversations.delete(conversation.id);
             this.claimRunSlot(conversation.id, reservedController);
         }
         let message;
         try {
-            message = await this.store.addAgentMessage(conversationId, trimmed, { ...(busy ? { delivery: "waiting" } : {}) });
+            message = await this.store.addAgentMessage(conversationId, trimmed, { ...(queueOnly ? { delivery: "waiting" } : {}) });
         }
         catch (error) {
             if (reservedController)
@@ -1896,16 +1911,17 @@ export class RunService {
         }
         this.assertHistoryAvailable(conversationId);
         const busy = this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id);
+        const queueOnly = busy || this.shuttingDown;
         // Reserve BEFORE the first persistence await. Revert/stop must see this admitted send even while
         // its message write is pending; otherwise a cut can start while this send goes on to launch Pi.
-        const reservedController = busy ? undefined : new AbortController();
+        const reservedController = queueOnly ? undefined : new AbortController();
         if (reservedController) {
             this.cancelledQuestionConversations.delete(conversation.id);
             this.claimRunSlot(conversation.id, reservedController);
         }
         let message;
         try {
-            message = await this.store.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(busy ? { delivery: "waiting" } : {}) });
+            message = await this.store.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(queueOnly ? { delivery: "waiting" } : {}) });
         }
         catch (error) {
             if (reservedController)
@@ -2140,6 +2156,8 @@ export class RunService {
         // steer/reorder/cancel wait until that turn ends, which is especially visible after a background
         // result auto-starts a long follow-up. The activeRuns slot protects the turn after this lane exits.
         const controller = await this.serializeConversation(conversationId, async () => {
+            if (this.shuttingDown)
+                return undefined;
             this.assertHistoryAvailable(conversationId);
             const reserved = this.interruptTargets.get(conversationId);
             if (reserved && reserved !== messageId)
@@ -2154,6 +2172,8 @@ export class RunService {
             this.claimRunSlot(conversationId, controller);
             return controller;
         });
+        if (!controller)
+            return;
         try {
             const { conversation, workspace } = this.turnContext(conversationId);
             const message = conversation.messages.find((item) => item.id === messageId);

package/dist/server/application/session-watchdog.d.ts

@@ -83,6 +83,12 @@ export declare class SessionWatchdog {
     private readonly timers;
     /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
     private readonly writes;
+    /** A shutdown is a fence: no timer may start another reminder after it is raised. */
+    private disposed;
+    /** Reminders already accepted by a timer before shutdown still own their state and disk writes. */
+    private readonly inFlight;
+    /** Every caller must observe the same drain, including callers that arrive while it is running. */
+    private disposal;
     constructor(host: WatchdogHost);
     /**
      * Declares (or re-declares) the watchdog for a child.
@@ -121,8 +127,14 @@ export declare class SessionWatchdog {
      * remaining time is measured from the last sign of life, not from the restart.
      */
     restore(): Promise<void>;
-    /** Stops every timer. The process is going away; the state stays on disk. */
-    dispose(): void;
+    /**
+     * Stops reminder production and drains work the timers had already accepted.
+     *
+     * `disposed` is set before the first await so a timer cannot sneak a second reminder into the
+     * shutdown window. A reminder that was already in `onTimeout` remains owned by this instance:
+     * its parent delivery and the state write must finish before its workspace can be removed.
+     */
+    dispose(): Promise<void>;
     /**
      * Arms the timer for one entry.
      *

package/dist/server/application/session-watchdog.js

@@ -19,6 +19,12 @@ export class SessionWatchdog {
     timers = new Map();
     /** One write chain per workspace, so two watchdogs in one workspace cannot interleave a write. */
     writes = new Map();
+    /** A shutdown is a fence: no timer may start another reminder after it is raised. */
+    disposed = false;
+    /** Reminders already accepted by a timer before shutdown still own their state and disk writes. */
+    inFlight = new Set();
+    /** Every caller must observe the same drain, including callers that arrive while it is running. */
+    disposal;
     constructor(host) {
         this.host = host;
     }
@@ -30,6 +36,8 @@ export class SessionWatchdog {
      * watchdog that quietly switched itself off would leave the parent believing it was still watched.
      */
     async arm(input) {
+        if (this.disposed)
+            return;
         const { childConversationId } = input;
         if (!childConversationId.trim())
             return;
@@ -64,6 +72,8 @@ export class SessionWatchdog {
      * the child is out of sight.
      */
     async noteSignal(childConversationId) {
+        if (this.disposed)
+            return;
         const entry = this.entries.get(childConversationId);
         if (!entry)
             return;
@@ -99,6 +109,8 @@ export class SessionWatchdog {
      * remaining time is measured from the last sign of life, not from the restart.
      */
     async restore() {
+        if (this.disposed)
+            return;
         for (const workspaceId of this.host.workspaceIds()) {
             const path = this.statePath(workspaceId);
             if (!path)
@@ -117,6 +129,8 @@ export class SessionWatchdog {
             if (!records || typeof records !== "object")
                 continue;
             for (const [childConversationId, record] of Object.entries(records)) {
+                if (this.disposed)
+                    return;
                 if (!record || typeof record.timeoutSeconds !== "number" || !record.parentConversationId)
                     continue;
                 const entry = {
@@ -132,11 +146,27 @@ export class SessionWatchdog {
             }
         }
     }
-    /** Stops every timer. The process is going away; the state stays on disk. */
+    /**
+     * Stops reminder production and drains work the timers had already accepted.
+     *
+     * `disposed` is set before the first await so a timer cannot sneak a second reminder into the
+     * shutdown window. A reminder that was already in `onTimeout` remains owned by this instance:
+     * its parent delivery and the state write must finish before its workspace can be removed.
+     */
     dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
         for (const timer of this.timers.values())
             clearTimeout(timer);
         this.timers.clear();
+        this.disposal = (async () => {
+            await Promise.allSettled([...this.inFlight]);
+            // In-flight reminders can append state writes after the first drain starts, so take this
+            // snapshot only after they have settled.
+            await Promise.allSettled([...this.writes.values()]);
+        })();
+        return this.disposal;
     }
     /**
      * Arms the timer for one entry.
@@ -145,11 +175,17 @@ export class SessionWatchdog {
      * allowed to shut down with a watchdog in flight, and the state is on disk anyway.
      */
     schedule(entry) {
+        if (this.disposed || this.entries.get(entry.childConversationId) !== entry)
+            return;
         this.clearTimer(entry.childConversationId);
         const elapsed = Date.now() - entry.lastSignalAt;
         const remaining = Math.max(0, entry.timeoutSeconds * 1000 - elapsed);
         const timer = setTimeout(() => {
-            void this.fire(entry.childConversationId);
+            if (this.disposed)
+                return;
+            const firing = this.fire(entry.childConversationId);
+            this.inFlight.add(firing);
+            void firing.then(() => this.inFlight.delete(firing), () => this.inFlight.delete(firing));
         }, remaining);
         timer.unref?.();
         this.timers.set(entry.childConversationId, timer);
@@ -174,6 +210,8 @@ export class SessionWatchdog {
      * cannot speak any more is noise, not information.
      */
     async fire(childConversationId) {
+        if (this.disposed)
+            return;
         const entry = this.entries.get(childConversationId);
         if (!entry)
             return;
@@ -195,6 +233,8 @@ export class SessionWatchdog {
         catch (error) {
             this.host.warn?.(`Super Pi: watchdog reminder for ${childConversationId} failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+        // Shutdown must preserve a reminder that was already accepted, but it must not schedule its
+        // successor after that reminder has drained.
         entry.endedReminded = !childWorking;
         entry.lastSignalAt = Date.now();
         await this.persist(entry.workspaceId);

package/dist/server/http-server.js

@@ -2099,6 +2099,13 @@ export function createHttpServer(options) {
                         response.writeHead(403, { "content-type": "application/json" }).end(JSON.stringify({ error: verdict.message }));
                         return;
                     }
+                    if (context.projectService) {
+                        const check = context.projectService.canAskQuestion(body.conversationId);
+                        if (!check.ok) {
+                            response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: check.reason }));
+                            return;
+                        }
+                    }
                     const result = await runService.askQuestion(body.conversationId);
                     response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
                 }

package/dist/server/index.js

@@ -108,7 +108,12 @@ const agentPromptDir = join(dataDir, "agent-prompts");
 const clientDir = join(rootDir, "dist", "client");
 const accessToken = process.env.SUPER_PI_ACCESS_TOKEN;
 const uploadsDir = join(dataDir, "uploads");
-await mkdir(uploadsDir, { recursive: true }).catch(() => { });
+try {
+    await mkdir(uploadsDir, { recursive: true });
+}
+catch (error) {
+    logging.write("warn", `uploads directory unavailable: ${error instanceof Error ? error.message : String(error)}`);
+}
 const taskEndpoint = `http://${internalHost}:${port}/api/subagent/dispatch`;
 const execEndpoint = `http://${internalHost}:${port}/api/exec`;
 const todoEndpoint = `http://${internalHost}:${port}/api/todos`;
@@ -339,6 +344,7 @@ async function shutdown(reason) {
         return shutdownPromise;
     shutdownPromise = (async () => {
         console.log(`Super Pi is shutting down (${reason}).`);
+        runService.beginShutdown();
         // Stop accepting new connections first. Existing clients stay connected until
         // their cancelled work has recorded its terminal state.
         const httpClosed = closeHttpServer();
@@ -354,6 +360,7 @@ async function shutdown(reason) {
         for (const c of store.snapshot().conversations) {
             extensionUiService.cancelPendingUi(c.id, "aborted");
         }
+        await sessionOrchestratorService.watchdog.dispose();
         await Promise.all([runService.waitForIdle(), workflows.waitForIdle()]);
         // THE LIVE SESSIONS GO NEXT, AND THEY HAVE TO GO EXPLICITLY. `runService.abortAll()` stops the
         // TURNS, and a stopped turn is not a stopped session: a session with nothing running on it is idle,

package/dist/server/tool-runner.js

@@ -8,6 +8,15 @@ const MAX_TIMEOUT_MS = 10 * 60_000;
 /** The environment build gets its OWN budget: a cold `pip install` must not eat the tool's timeout. */
 const MAX_ENV_TIMEOUT_MS = 10 * 60_000;
 const isWindows = process.platform === "win32";
+/** Keep OS architecture fallback data without exposing unrelated host configuration to Python. */
+function pythonEnvironment() {
+    return {
+        PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP,
+        PROCESSOR_ARCHITECTURE: process.env.PROCESSOR_ARCHITECTURE,
+        PROCESSOR_ARCHITEW6432: process.env.PROCESSOR_ARCHITEW6432,
+        PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1",
+    };
+}
 /** Runs a registered Python entrypoint without a shell. It intentionally accepts no command string. */
 export class ToolRunner {
     dataDir;
@@ -154,7 +163,7 @@ export class ToolRunner {
     }
     launch(id, active, python, input) {
         // -I ignores user Python configuration and user site packages. No shell means params never become code.
-        const child = spawn(python.path, ["-I", "-u", input.script], { cwd: input.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP, PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1", SUPER_PI_TOOL_ID: input.toolId } });
+        const child = spawn(python.path, ["-I", "-u", input.script], { cwd: input.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { ...pythonEnvironment(), SUPER_PI_TOOL_ID: input.toolId } });
         active.child = child;
         // A PIPE CARRIES BYTES, AND A READ BOUNDARY CAN LAND INSIDE A CHARACTER. A Chinese character is
         // three bytes, so decoding one chunk at a time turns every character that straddles a boundary
@@ -210,7 +219,7 @@ export class ToolRunner {
 function runCapture(python, args, timeoutMs, onOutput) {
     return new Promise((resolve) => {
         let stdout = "", stderr = "", settled = false;
-        const child = spawn(python, args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP, PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1" } });
+        const child = spawn(python, args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env: pythonEnvironment() });
         const timer = setTimeout(() => { if (settled)
             return; settled = true; try {
             child.kill();

package/dist/server/types.d.ts

@@ -949,6 +949,7 @@ export type ProjectTask = {
     priority: "low" | "medium" | "high" | "urgent";
     dueAt?: string;
     blockedReason?: string;
+    blockedReportedByConversationId?: string;
     output?: string;
     evidenceRefs?: string[];
     /** The acceptance of this task. `lightweight: true` means the executor accepted its own
@@ -989,6 +990,9 @@ export type ProjectEscalation = {
     decision?: string;
     createdAt: string;
     resolvedAt?: string;
+    audience?: "supervisor" | "boss";
+    targetConversationId?: string;
+    resolvedByConversationId?: string;
 };
 export type ProjectEvent = {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.163",
+  "version": "0.1.165",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -85,6 +85,7 @@
     "scripts/session-orchestrator-tools.test.mjs",
     "scripts/project-service.test.mjs",
     "scripts/project-api-scope.test.mjs",
+    "scripts/project-report-chain.test.mjs",
     "scripts/session-tree-collapse.test.mjs",
     "scripts/archive-cascade.test.mjs",
     "scripts/workspace-cwd.test.mjs",
@@ -128,6 +129,7 @@
     "scripts/git-write-endpoint-guard.test.mjs",
     "scripts/question-stop.test.mjs",
     "scripts/background-result-body.test.mjs",
+    "scripts/browser-click.test.mjs",
     "scripts/question-request-size.test.mjs",
     "scripts/md-render.test.mjs",
     "scripts/revert-session-format.test.mjs",