@evandu/super-pi 0.1.20 → 0.1.22

package/dist/server/store.js

@@ -1,5 +1,4 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { JsonStateRepository, defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import { normalizeTodos } from "./task-tool.js";
 function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
@@ -427,15 +426,19 @@ function reconcileTodos(state) {
     return { changed: before !== fingerprint(state.todos) };
 }
 export class Store {
-    filePath;
+    repository;
     state;
-    constructor(filePath, state) {
-        this.filePath = filePath;
+    constructor(repository, state) {
+        this.repository = repository;
         this.state = state;
     }
     static async open(filePath) {
+        return this.openRepository(new JsonStateRepository(filePath));
+    }
+    /** Opens an injected repository, retaining domain reconciliation here. */
+    static async openRepository(repository) {
         try {
-            const state = JSON.parse(await readFile(filePath, "utf8"));
+            const state = await repository.load();
             if (!Array.isArray(state.backgroundTasks))
                 state.backgroundTasks = [];
             // Every sweep runs before the store is constructed, so a single persist below publishes them together.
@@ -446,7 +449,7 @@ export class Store {
             const interrupted = reconcileConversations(state);
             const requeued = reconcileQueuedMessages(state);
             const todos = reconcileTodos(state);
-            const store = new Store(filePath, normalizeMessageTimestamps(state));
+            const store = new Store(repository, normalizeMessageTimestamps(state));
             // Persisted here, in `open`, rather than left for the first unrelated write: a reconciled record that
             // is only rewritten by a later mutation would still read `running` to anything that opened the file
             // in the meantime, and would be reconciled a SECOND time on the next restart.
@@ -470,7 +473,7 @@ export class Store {
             if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
                 throw error;
             const createdAt = now();
-            return new Store(filePath, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], queuedMessages: [], backgroundTasks: [] });
+            return new Store(repository, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], queuedMessages: [], backgroundTasks: [] });
         }
     }
     async setModelFilterRules(rules) {
@@ -678,7 +681,7 @@ export class Store {
         if (conversation.status === "running")
             throw new Error("运行中的会话无法归档，请先停止运行");
         conversation.archivedAt = now();
-        await this.persist();
+        await this.persistMetadata(conversationId);
     }
     /** Restoring deletes the key rather than setting it to null, so a fully restored conversation serializes
      *  byte-identically to one that was never archived. `delete` is legal here because the field is optional. */
@@ -687,7 +690,7 @@ export class Store {
         if (!conversation.archivedAt)
             return;
         delete conversation.archivedAt;
-        await this.persist();
+        await this.persistMetadata(conversationId);
     }
     /**
      * Rename edits the title and NOTHING else. In particular `updatedAt` is deliberately not touched,
@@ -709,7 +712,7 @@ export class Store {
             throw new Error("Conversation name must be 1-80 characters");
         const conversation = this.requireConversation(conversationId);
         conversation.title = cleanName;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     async addUserMessage(conversationId, content, images) {
@@ -767,7 +770,7 @@ export class Store {
         // which is the exact failure this whole note is about, one level up. scripts/session-picker.test.mjs
         // pins the real key set instead, and re-breaks whenever a field is added.
         conversation.model = { provider: model.provider, modelId: model.modelId, label: model.label };
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     /** Restoring Pi's own default deletes the key rather than storing Pi's default as this app's state. */
@@ -777,7 +780,7 @@ export class Store {
             delete conversation.thinkingLevel;
         else
             conversation.thinkingLevel = level;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     /**
@@ -792,7 +795,7 @@ export class Store {
             delete conversation.agentId;
         else
             conversation.agentId = agentId;
-        await this.persist();
+        await this.persistMetadata(conversationId);
         return structuredClone(conversation);
     }
     async setConversationConfiguration(conversationId, settings) {
@@ -823,8 +826,15 @@ export class Store {
         return structuredClone(conversation);
     }
     async beginAssistantMessage(conversationId, agentIdentity) { const conversation = this.requireConversation(conversationId); const message = { id: id("message"), role: "assistant", content: "", createdAt: now(), ...(agentIdentity ? { agentIdentity: structuredClone(agentIdentity) } : {}) }; conversation.messages.push(message); await this.persist(); return structuredClone(message); }
-    async appendAssistantDelta(conversationId, messageId, delta) { const conversation = this.requireConversation(conversationId); const message = conversation.messages.find((item) => item.id === messageId); if (!message)
-        throw new Error("Assistant message not found"); message.content += delta; conversation.updatedAt = now(); await this.persist(); }
+    async appendAssistantDelta(conversationId, messageId, delta) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message)
+            throw new Error("Assistant message not found");
+        message.content += delta;
+        conversation.updatedAt = now();
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: conversation.updatedAt });
+    }
     /**
      * Appends one tool call to the message it belongs to, and returns the message's whole `toolCalls`
      * array so the caller can broadcast it as one snapshot.
@@ -894,7 +904,7 @@ export class Store {
         await this.persist();
         return structuredClone(calls);
     }
-    async setStatus(conversationId, status) { const conversation = this.requireConversation(conversationId); conversation.status = status; conversation.updatedAt = now(); await this.persist(); }
+    async setStatus(conversationId, status) { const conversation = this.requireConversation(conversationId); conversation.status = status; conversation.updatedAt = now(); await this.persistMetadata(conversationId); }
     /** The plan a revert would carry out, without carrying it out. The server reads this to stop children first. */
     planRevert(conversationId, messageId, withdraw = false) { return planRevert(this.state, conversationId, messageId, withdraw); }
     /**
@@ -977,7 +987,7 @@ export class Store {
         if (images && images.length > 0)
             message.images = structuredClone(images);
         this.state.queuedMessages.push(message);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(message);
     }
     /**
@@ -1001,7 +1011,7 @@ export class Store {
         if (this.state.queuedMessages[index].state === "sending")
             throw new Error("这条消息已经交给 Agent 了，取消不掉（Pi 没有撤回单条队列消息的能力）");
         const [removed] = this.state.queuedMessages.splice(index, 1);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(removed);
     }
     /**
@@ -1025,7 +1035,7 @@ export class Store {
         if (message.state === "sending")
             throw new Error(`排队消息已经交给 Agent 了：${queueId}`);
         message.state = "sending";
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(message);
     }
     /**
@@ -1044,7 +1054,7 @@ export class Store {
         if (!message || message.state !== "sending")
             return;
         message.state = "queued";
-        await this.persist();
+        await this.persistCollections("queuedMessages");
     }
     /**
      * Removes the OLDEST `count` messages this conversation has in `sending`, and returns them.
@@ -1067,7 +1077,7 @@ export class Store {
         if (!doomed.length)
             return [];
         this.state.queuedMessages = this.state.queuedMessages.filter((item) => !doomed.includes(item.id));
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(sending.slice(0, doomed.length));
     }
     /**
@@ -1085,7 +1095,7 @@ export class Store {
         if (index < 0)
             return undefined;
         const [taken] = this.state.queuedMessages.splice(index, 1);
-        await this.persist();
+        await this.persistCollections("queuedMessages");
         return structuredClone(taken);
     }
     /**
@@ -1106,7 +1116,7 @@ export class Store {
             changed = true;
         }
         if (changed)
-            await this.persist();
+            await this.persistCollections("queuedMessages");
     }
     // ------------------------------------------------------------- Sub-agent runs
     // Records, not transcripts: what lands here is the dispatch, the last assistant message and the
@@ -1157,7 +1167,7 @@ export class Store {
             throw new Error(`Workflow already recorded: ${plan.id}`);
         this.state.workflows.unshift(plan);
         trimWorkflows(this.state.workflows);
-        await this.persist();
+        await this.persistCollections("workflows");
         return structuredClone(plan);
     }
     /**
@@ -1182,7 +1192,7 @@ export class Store {
             throw new Error(`Workflow not found: ${stored.id}`);
         this.state.workflows[index] = stored;
         trimWorkflows(this.state.workflows);
-        await this.persist();
+        await this.persistCollections("workflows");
         return structuredClone(stored);
     }
     async setBackgroundTask(summary) {
@@ -1191,11 +1201,11 @@ export class Store {
             Object.assign(existing, summary);
         else
             this.state.backgroundTasks.unshift(summary);
-        await this.persist();
+        await this.persistCollections("backgroundTasks");
     }
     async removeBackgroundTask(id) {
         this.state.backgroundTasks = this.state.backgroundTasks.filter((item) => item.id !== id);
-        await this.persist();
+        await this.persistCollections("backgroundTasks");
     }
     /**
      * Applies the fields a run's life can change, and nothing else.
@@ -1215,7 +1225,7 @@ export class Store {
         if (!run)
             throw new Error(`Sub-agent run not found: ${runId}`);
         Object.assign(run, changes);
-        await this.persist();
+        await this.persistTransaction({ kind: "subagent.replace", run: structuredClone(run) });
         return structuredClone(run);
     }
     /**
@@ -1276,59 +1286,22 @@ export class Store {
      *
      * A rejected write must not poison the queue, or one failure would reject every later persist as well.
      */
-    persistQueue = Promise.resolve();
-    async persist() {
-        const write = this.persistQueue.then(async () => {
-            await mkdir(dirname(this.filePath), { recursive: true });
-            const temporaryPath = `${this.filePath}.tmp`;
-            await writeFile(temporaryPath, `${JSON.stringify(this.state, null, 2)}\n`, "utf8");
-            await replaceFile(temporaryPath, this.filePath);
-        });
-        this.persistQueue = write.catch(() => { });
-        await write;
+    async flush() { await this.repository.flush(); }
+    /** Releases persistence resources after all accepted writes settle. */
+    async close() { await this.flush(); this.repository.close?.(); }
+    async persistTransaction(transaction) {
+        if (this.repository.commit)
+            await this.repository.commit(transaction);
+        else
+            await this.persist();
     }
-}
-/**
- * How long `replaceFile` keeps retrying a rename that lost a race with a reader. Two seconds is two
- * orders of magnitude past the measured sub-50ms release, so it exists to absorb a loaded machine and a
- * virus scanner mid-scan, not to wait out a lock that will never clear.
- */
-const RENAME_RETRY_MS = 2_000;
-const RENAME_RETRY_STEP_MS = 5;
-/**
- * Renames `from` over `to`, retrying the WINDOWS SHARING VIOLATION.
- *
- * WHY THIS EXISTS, because the failure it fixes was a real defect and not a test artefact. On Windows a
- * rename onto a file that ANY handle has open fails with EPERM/EACCES: the destination must be held with
- * FILE_SHARE_DELETE, and a plain reader does not do that. Node's own `readFile` is such a reader, and so
- * is every indexer, virus scanner and sync client on the machine. So `persist()` threw EPERM, the caller's
- * mutation stayed only in memory, and the save was LOST - the settings dialog had already closed on send,
- * so the person who pressed 保存 was told nothing and kept a default that had never been saved.
- * scripts/workspace-settings-browser.test.mjs reproduced it at roughly 1 save in 5, and every occurrence
- * read as "the save never arrived" because the refusal travelled to the browser as an error event the
- * suite did not read, so a refused write and a slow write were indistinguishable for a whole day.
- *
- * MEASURED, so the bound is honest rather than hopeful: renaming onto a held-open `state.json` fails on
- * the first attempt 40 times out of 40 and clears within one 5ms tick of the reader letting go (worst
- * case 11 attempts). The lock lasts exactly as long as somebody is READING, which is why a bounded
- * retry is the fix and not a longer sleep: the transient case is short, and a genuinely stuck file is
- * not a sharing violation. A file that stays contended past the bound still throws, which is the honest
- * outcome - the store reports a failed write instead of pretending it saved.
- */
-async function replaceFile(from, to) {
-    const deadline = Date.now() + RENAME_RETRY_MS;
-    for (;;) {
-        try {
-            await rename(from, to);
-            return;
-        }
-        catch (error) {
-            const code = error.code;
-            const contended = code === "EPERM" || code === "EACCES" || code === "EBUSY";
-            if (!contended || Date.now() >= deadline)
-                throw error;
-            await new Promise((resolve) => setTimeout(resolve, RENAME_RETRY_STEP_MS));
-        }
+    async persistCollections(key) {
+        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(this.state[key]) } });
+    }
+    async persistMetadata(conversationId) {
+        const { messages: _messages, ...metadata } = this.requireConversation(conversationId);
+        await this.persistTransaction({ kind: "conversation.metadata", conversationId, metadata: structuredClone(metadata) });
     }
+    async persist() { await this.repository.save(this.state); }
 }
-export function defaultStorePath(dataDir) { return join(dataDir, "state.json"); }
+export const defaultStorePath = defaultJsonStatePath;

package/dist/server/subagent-runs.d.ts

@@ -127,6 +127,8 @@ export declare class SubagentRunRecorder {
      * reconciliation cleans up the RECORD of such a run; this stops the PROCESS from being one.
      */
     abortAll(): void;
+    /** Waits for every child that was live at shutdown to settle and record its outcome. */
+    waitForIdle(): Promise<void>;
     /**
      * Runs one sub-agent, recording it from before the spawn to after the settle, and returns the record
      * as it ended.

package/dist/server/subagent-runs.js

@@ -99,6 +99,12 @@ export class SubagentRunRecorder {
         for (const entry of this.controllers.values())
             entry.controller.abort();
     }
+    /** Waits for every child that was live at shutdown to settle and record its outcome. */
+    async waitForIdle() {
+        while (this.controllers.size > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
     /**
      * Runs one sub-agent, recording it from before the spawn to after the settle, and returns the record
      * as it ended.

package/dist/server/subagents.d.ts

@@ -137,6 +137,8 @@ export declare class SubagentCancelled extends Error {
 export declare class SubagentSupervisor {
     private readonly sessionDir;
     private agents;
+    private memory?;
+    setMemory(memory: import("./active-memory.js").ActiveMemory): void;
     private readonly pi;
     /** Live children by run id, so a caller can name the process it means. Cleared in the run's `finally`. */
     private readonly children;

package/dist/server/subagents.js

@@ -168,6 +168,8 @@ const addUsage = (total, usage) => {
 export class SubagentSupervisor {
     sessionDir;
     agents;
+    memory;
+    setMemory(memory) { this.memory = memory; }
     pi;
     /** Live children by run id, so a caller can name the process it means. Cleared in the run's `finally`. */
     children = new Map();
@@ -244,10 +246,12 @@ export class SubagentSupervisor {
         const agent = await this.subagentDefinition(agentId);
         // The child's own `tools:` map, minus whatever the dispatching agent denied. Never the parent's
         // ALLOWLIST - see `SubagentRunInput.denyTools` for why that asymmetry is the reference's too.
-        const agentArgs = await agentSpawnArgs(this.agents.promptDir, agent, { denyTools: input.denyTools ?? [] });
+        const memoryEnabled = this.memory ? (await this.memory.configuration()).enabled : false;
+        const agentArgs = await agentSpawnArgs(this.agents.promptDir, agent, { denyTools: input.denyTools ?? [], extraAllowedTools: memoryEnabled ? ["memory", "skill_manage", "session_search"] : [] });
         const sessionDirectory = join(this.sessionDir, "subagents");
         await mkdir(sessionDirectory, { recursive: true });
-        const args = ["--mode", "rpc", "--session-dir", sessionDirectory, "--session-id", id, ...agentArgs];
+        const memoryToken = memoryEnabled ? this.memory.issue(conversationId, { readOnly: true }) : undefined;
+        const args = ["--mode", "rpc", "--session-dir", sessionDirectory, "--session-id", id, ...(memoryToken ? ["--extension", resolve(import.meta.dirname, "../../agents/super-pi-memory/index.ts")] : []), ...agentArgs];
         // Model inheritance: the definition wins, otherwise the parent's current model, otherwise Pi's own
         // default. "Omit the model and get what the parent is running on" is the default worth having, and it
         // is a spawn-time flag because there is no RPC command to change it later.
@@ -260,7 +264,9 @@ export class SubagentSupervisor {
         if (agent.thinkingLevel)
             args.push("--thinking", agent.thinkingLevel);
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
-        const child = spawn(shellQuote(this.pi.command), args, { cwd: childCwd, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32" });
+        const child = spawn(shellQuote(this.pi.command), args, { cwd: childCwd, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32", ...(memoryToken ? { env: { ...process.env, SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT, SUPER_PI_MEMORY_TOKEN: memoryToken, SUPER_PI_MEMORY_READ_ONLY: "1" } } : {}) });
+        if (memoryToken)
+            child.once("close", () => this.memory?.release(memoryToken));
         this.children.set(id, { conversationId, child });
         const channel = new RpcChannel(child);
         // Pi is asked to stop first and killed only if that is not enough, so a child that can unwind its own
@@ -508,6 +514,8 @@ export class SubagentSupervisor {
             return { id, sessionId: id, finalText: finalText || streamed, usage };
         }
         finally {
+            if (memoryToken)
+                this.memory?.release(memoryToken);
             signal?.removeEventListener("abort", abort);
             this.children.delete(id);
             // The run is not over until the child is actually gone: a process still tearing down still holds a

package/dist/server/workflow-engine.d.ts

@@ -77,6 +77,8 @@ export declare class WorkflowEngine {
     stopConversation(conversationId: string): number;
     /** Aborts every plan in flight. Called on shutdown, so no child outlives the server that owns it. */
     abortAll(): void;
+    /** Waits until aborted plans have committed their terminal state. */
+    waitForIdle(): Promise<void>;
     /** The conversation a plan belongs to, which only this map knows while the plan is running. */
     private conversationOf;
     /**

package/dist/server/workflow-engine.js

@@ -50,6 +50,12 @@ export class WorkflowEngine {
         for (const controller of this.controllers.values())
             controller.abort();
     }
+    /** Waits until aborted plans have committed their terminal state. */
+    async waitForIdle() {
+        while (this.controllers.size > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
     /** The conversation a plan belongs to, which only this map knows while the plan is running. */
     conversationOf(workflowId) {
         return this.owners.get(workflowId);
@@ -74,6 +80,8 @@ export class WorkflowEngine {
         const controller = new AbortController();
         const onCallerAbort = () => controller.abort();
         input.signal?.addEventListener("abort", onCallerAbort, { once: true });
+        if (input.signal?.aborted)
+            controller.abort();
         this.controllers.set(id, controller);
         this.owners.set(id, input.conversationId);
         // THE WHOLE PLAN, IN FULL, BEFORE STEP ONE RUNS. See `Store.beginWorkflow`: this is the write that
@@ -168,6 +176,12 @@ export class WorkflowEngine {
             // not acceptable, so handing the second attempt the same inputs would make the policy a no-op that
             // burns the same sub-agent's answer twice and reports it as progress.
             const composed = composeStepPrompt(step.prompt, plan.steps.slice(0, step.index));
+            // A retry receives the failed attempt's evidence, rather than repeating a blind prompt.
+            const previousAttempt = step.attempts.at(-1);
+            if (previousAttempt) {
+                const evidence = [previousAttempt.error, previousAttempt.output].filter(Boolean).join("\n").slice(-8000);
+                composed.prompt += `\n\n[Previous attempt ${previousAttempt.n} failed]\n${evidence}\nAddress the failure above before completing this step.`;
+            }
             await this.commit(plan);
             const run = await this.recorder.dispatch({
                 conversationId: input.conversationId,

package/dist/server/ws-server.js

@@ -61,6 +61,21 @@ export class WsServer {
                 socket.destroy();
                 return;
             }
+            const origin = request.headers.origin;
+            if (origin) {
+                try {
+                    const parsed = new URL(origin);
+                    const host = request.headers.host;
+                    if (!host || parsed.host !== host || !["http:", "https:"].includes(parsed.protocol)) {
+                        socket.destroy();
+                        return;
+                    }
+                }
+                catch {
+                    socket.destroy();
+                    return;
+                }
+            }
             this.websocketServer.handleUpgrade(request, socket, head, (ws) => {
                 this.websocketServer.emit("connection", ws, request);
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -33,6 +33,9 @@
     "check": "node scripts/run-check.mjs"
   },
   "check:logic": [
+    "scripts/lan-access.test.mjs",
+    "scripts/persistence-repository.test.mjs",
+    "scripts/sqlite-repository.test.mjs",
     "scripts/dispatch-ancestry.test.mjs",
     "scripts/dispatch-endpoint.test.mjs",
     "scripts/dispatched-by.test.mjs",
@@ -75,7 +78,8 @@
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",
     "scripts/agent-config-regression.test.mjs",
-    "scripts/model-filter.test.mjs"
+    "scripts/model-filter.test.mjs",
+    "scripts/active-memory.test.mjs"
   ],
   "check:browser": [
     "scripts/extension-ui-browser.test.mjs",
@@ -108,7 +112,8 @@
     "scripts/help-window.test.mjs",
     "scripts/composer-regression-browser.test.mjs",
     "scripts/workspace-picker-browser.test.mjs",
-    "scripts/optimistic-browser.test.mjs"
+    "scripts/optimistic-browser.test.mjs",
+    "scripts/active-memory-browser.test.mjs"
   ],
   "dependencies": {
     "ws": "latest"