@evandu/super-pi 0.1.136 → 0.1.138

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-oDRgSKPX.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-r-L_XCYs.css">
+    <script type="module" crossorigin src="/assets/index-CNoiRdJC.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-FxTrUapG.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/active-memory.js

@@ -139,7 +139,11 @@ export class ActiveMemory {
         if (this.indexedWorkspaces.has(workspaceId))
             return;
         const index = new Map();
-        for (const conversation of this.store.snapshot().conversations.filter(c => c.workspaceId === workspaceId))
+        const store = this.store;
+        const conversations = store.conversationsForWorkspace
+            ? store.conversationsForWorkspace(workspaceId)
+            : store.snapshot().conversations.filter(c => c.workspaceId === workspaceId);
+        for (const conversation of conversations)
             for (const message of conversation.messages) {
                 if (message.role !== "user" && message.role !== "assistant")
                     continue;
@@ -362,7 +366,10 @@ export class ActiveMemory {
             const settings = await this.configuration();
             if (!settings.enabled || !settings.reviewInterval)
                 return;
-            const workspace = this.store.snapshot().workspaces.find(w => w.id === snapshot.workspaceId);
+            const store = this.store;
+            const workspace = store.workspace
+                ? store.workspace(snapshot.workspaceId)
+                : store.snapshot().workspaces.find(w => w.id === snapshot.workspaceId);
             if (!workspace)
                 return;
             const agent = await this.runtime.agentFor?.(snapshot);

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

@@ -1,4 +1,4 @@
-import { assertModelAllowed, conversationWorkspace } from "../model-filter.js";
+import { assertModelAllowed } from "../model-filter.js";
 import { readAgents, resolveAgentDirectories } from "../agents.js";
 import { loadPromptTemplateSummaries } from "../pi-session.js";
 function summarize(agent) {
@@ -75,10 +75,12 @@ export class CatalogService {
         const catalog = await this.runtime.catalog(selection);
         if (!conversationId || !this.store)
             return catalog;
-        const state = this.store.snapshot();
-        const workspace = conversationWorkspace(state, conversationId);
+        const workspace = this.store.workspaceForConversation(conversationId);
+        if (!workspace)
+            throw new Error("会话所属工作区不存在");
+        const rules = this.store.modelFilterRules();
         return { ...catalog, models: catalog.models.filter(model => { try {
-                assertModelAllowed(state.modelFilterRules, workspace, model);
+                assertModelAllowed(rules, workspace, model);
                 return true;
             }
             catch {
@@ -108,7 +110,7 @@ export class CatalogService {
             throw new Error("Store unavailable");
         await this.store.setModelFilterRules(rules);
         this.broadcaster.broadcastState();
-        for (const conversation of this.store.snapshot().conversations) {
+        for (const conversation of this.store.catalogConversationTargets()) {
             if (!conversation.archivedAt) {
                 try {
                     await this.broadcastCatalog(conversation.model, conversation.id);
@@ -182,7 +184,7 @@ export class CatalogService {
         const cached = this.promptCatalogs.get(workspaceId);
         if (cached && cached.expiresAt > Date.now())
             return cached.catalog;
-        const workspace = this.store?.snapshot().workspaces.find((item) => item.id === workspaceId);
+        const workspace = this.store?.workspace(workspaceId);
         if (!workspace)
             return { source: "unavailable", prompts: [], workspaceId, fetchedAt: new Date().toISOString(), error: "workspace not found" };
         try {

package/dist/server/http-server.d.ts

@@ -30,7 +30,4 @@ export interface HttpServerOptions {
     context: ServerContext;
     onShutdown: (reason: string) => Promise<void>;
 }
-/**
- * Creates the HTTP server providing static client assets and all `/api/*` endpoints.
- */
 export declare function createHttpServer(options: HttpServerOptions): NodeHttpServer;

package/dist/server/http-server.js

@@ -230,6 +230,47 @@ function abortedAs(request) {
 /**
  * Creates the HTTP server providing static client assets and all `/api/*` endpoints.
  */
+/**
+ * A REQUEST BODY BEING READ AS TEXT, decoded across chunk boundaries.
+ *
+ * The counterpart of `readRequestText` for the sites that need to inspect the body WHILE it streams
+ * (the file uploads, which refuse an oversized body without reading the rest of it).
+ */
+function textBodyReader() {
+    const decoder = new TextDecoder("utf-8");
+    let text = "";
+    return {
+        push: (chunk) => { text += decoder.decode(chunk, { stream: true }); return text; },
+        finish: () => text + decoder.decode(),
+    };
+}
+/**
+ * THE REQUEST BODY AS TEXT, DECODED ACROSS CHUNK BOUNDARIES.
+ *
+ * `raw += chunk` decodes EVERY CHUNK ON ITS OWN: the chunk is a Buffer, and concatenating it into a
+ * string calls `toString("utf8")` on it. A UTF-8 character that straddles two chunks is then two
+ * half-characters, and each half decodes to U+FFFD - the replacement character. So a Chinese
+ * sentence that happens to be split in the wrong place is silently corrupted, and the corrupted text
+ * is what the endpoint PERSISTS (a knowledge note, a memory, a scheduled task). The corruption is
+ * invisible - the JSON still parses - and permanent.
+ *
+ * A `TextDecoder` in streaming mode keeps the incomplete tail of a chunk and completes it with the
+ * next one, which is what "the body is one UTF-8 document" means. The size guards count BYTES, which
+ * is what a body limit is about anyway.
+ */
+async function readRequestText(request, limitBytes) {
+    const decoder = new TextDecoder("utf-8");
+    let text = "";
+    let bytes = 0;
+    for await (const chunk of request) {
+        const piece = chunk;
+        bytes += piece.length;
+        if (bytes > limitBytes)
+            return { text: "", tooLarge: true };
+        text += decoder.decode(piece, { stream: true });
+    }
+    return { text: text + decoder.decode(), tooLarge: false };
+}
 export function createHttpServer(options) {
     const { context, onShutdown } = options;
     const { store, paths, accessToken, broadcaster, runService, catalogService, execService, toolRegistry, toolRunner } = context;
@@ -320,16 +361,12 @@ export function createHttpServer(options) {
                 // BYTES, NOT CHARACTERS, AND FROM THE REGISTRY'S OWN CONSTANT. The old cap counted UTF-16 code
                 // units at 256,000, below the registry's own 512,000-byte asset limit, so JSON escaping decided
                 // where the real ceiling was and an exported bundle could be refused on the way back in.
-                let raw = "", bytes = 0;
-                for await (const chunk of request) {
-                    const piece = chunk;
-                    bytes += piece.length;
-                    if (bytes > MAX_TOOL_BODY_BYTES) {
-                        json(413, { error: "导入的内容太大，超过了大小上限。" });
-                        return;
-                    }
-                    raw += piece.toString("utf8");
+                const imported = await readRequestText(request, MAX_TOOL_BODY_BYTES);
+                if (imported.tooLarge) {
+                    json(413, { error: "导入的内容太大，超过了大小上限。" });
+                    return;
                 }
+                const raw = imported.text;
                 const body = JSON.parse(raw);
                 if (!isAuthorized(request, accessToken)) {
                     if (!body.conversationId) {
@@ -404,14 +441,12 @@ export function createHttpServer(options) {
                     toolApi(405, { error: "method" });
                     return;
                 }
-                let raw = "";
-                for await (const chunk of request) {
-                    raw += chunk;
-                    if (raw.length > 64_000) {
-                        toolApi(413, { error: "request too large" });
-                        return;
-                    }
+                const executed = await readRequestText(request, 64_000);
+                if (executed.tooLarge) {
+                    toolApi(413, { error: "request too large" });
+                    return;
                 }
+                const raw = executed.text;
                 try {
                     const body = JSON.parse(raw);
                     const resolved = await toolRegistry.resolve(id);
@@ -501,14 +536,12 @@ export function createHttpServer(options) {
                         toolApi(405, { error: "method" });
                         return;
                     }
-                    let raw = "";
-                    for await (const chunk of request) {
-                        raw += chunk;
-                        if (raw.length > 64_000) {
-                            toolApi(413, { error: "request too large" });
-                            return;
-                        }
+                    const asked = await readRequestText(request, 64_000);
+                    if (asked.tooLarge) {
+                        toolApi(413, { error: "request too large" });
+                        return;
                     }
+                    const raw = asked.text;
                     try {
                         const body = JSON.parse(raw);
                         toolApi(202, context.toolLlm.start({ toolId: id, prompt: body.prompt ?? "", system: body.system, timeoutMs: body.timeoutMs }));
@@ -598,14 +631,10 @@ export function createHttpServer(options) {
                 return;
             }
             try {
-                let raw = "";
-                let totalBytes = 0;
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > 512000)
-                        throw new Error("记忆请求过大");
-                    raw += chunk;
-                }
+                const remembered = await readRequestText(request, 512000);
+                if (remembered.tooLarge)
+                    throw new Error("记忆请求过大");
+                const raw = remembered.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const result = url.pathname.endsWith("/tool")
                     ? await context.memory.tool(String(request.headers["x-memory-capability"] ?? ""), body)
@@ -634,9 +663,10 @@ export function createHttpServer(options) {
             let name = url.searchParams.get("name") ?? url.searchParams.get("skillId") ?? "";
             if (request.method === "POST") {
                 try {
-                    let raw = "";
-                    for await (const chunk of request)
-                        raw += chunk;
+                    const asked = await readRequestText(request, 512000);
+                    if (asked.tooLarge)
+                        throw new Error("记忆请求过大");
+                    const raw = asked.text;
                     if (raw) {
                         const body = JSON.parse(raw);
                         if (body.workspaceId)
@@ -673,9 +703,12 @@ export function createHttpServer(options) {
                 return;
             }
             try {
-                let raw = "";
-                for await (const chunk of request)
-                    raw += chunk;
+                const asked = await readRequestText(request, 512000);
+                if (asked.tooLarge) {
+                    json(413, { error: "请求过大" });
+                    return;
+                }
+                const raw = asked.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const models = await context.providerService.fetchModels(body);
                 json(200, { ok: true, models });
@@ -704,14 +737,12 @@ export function createHttpServer(options) {
                 let totalBytes = 0;
                 // A pasted document rides in the body, so the cap is the document cap - past it the request is
                 // refused outright rather than truncated into a document that silently lost its tail.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_KNOWLEDGE_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "知识库请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const known = await readRequestText(request, MAX_KNOWLEDGE_REQUEST_BYTES);
+                if (known.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "知识库请求过大" }));
+                    return;
                 }
+                raw = known.text;
                 const body = raw ? JSON.parse(raw) : {};
                 const result = url.pathname.endsWith("/tool")
                     ? await context.knowledge.tool(String(request.headers["x-knowledge-capability"] ?? ""), body, abortedAs(request))
@@ -743,14 +774,12 @@ export function createHttpServer(options) {
                 // A DOCUMENT'S TEXT RIDES IN THE REQUEST BODY, so the cap is the document cap: a request
                 // past it is refused outright rather than truncated into a document that silently lost its
                 // tail.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_DOCUMENT_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "文档请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const documented = await readRequestText(request, MAX_DOCUMENT_REQUEST_BYTES);
+                if (documented.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "文档请求过大" }));
+                    return;
                 }
+                raw = documented.text;
                 const body = raw ? JSON.parse(raw) : {};
                 // The capability says WHICH CONVERSATION is asking, and the workspace is derived from it
                 // rather than taken from the request: a request that named its own workspace would be a
@@ -787,14 +816,12 @@ export function createHttpServer(options) {
             }
             try {
                 let raw = "", totalBytes = 0;
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_WEB_REQUEST_BYTES) {
-                        response.writeHead(413).end();
-                        return;
-                    }
-                    raw += chunk;
+                const asked = await readRequestText(request, MAX_WEB_REQUEST_BYTES);
+                if (asked.tooLarge) {
+                    response.writeHead(413).end();
+                    return;
                 }
+                raw = asked.text;
                 const conversationId = String(request.headers["x-web-conversation"] ?? "");
                 const verdict = verifyCapability(conversationId, request.headers["x-web-capability"], { running: context.runService.isRunning(conversationId) });
                 if (!verdict.ok) {
@@ -831,14 +858,12 @@ export function createHttpServer(options) {
             try {
                 let raw = "", totalBytes = 0;
                 // The Markdown of a document rides in the request body, so the cap is the document cap.
-                for await (const chunk of request) {
-                    totalBytes += chunk.length;
-                    if (totalBytes > MAX_FEISHU_REQUEST_BYTES) {
-                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "飞书请求过大" }));
-                        return;
-                    }
-                    raw += chunk;
+                const asked = await readRequestText(request, MAX_FEISHU_REQUEST_BYTES);
+                if (asked.tooLarge) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "飞书请求过大" }));
+                    return;
                 }
+                raw = asked.text;
                 const conversationId = String(request.headers["x-feishu-conversation"] ?? "");
                 // THE SAME PROOF THE DOCUMENT TOOLS USE: the request must carry the session's own
                 // capability, and the session must actually be running a turn. The Feishu credential is a
@@ -1050,9 +1075,12 @@ export function createHttpServer(options) {
                         json(403, { error: "Git 写操作只允许来自本机或局域网的请求。" });
                         return;
                     }
-                    let raw = "";
-                    for await (const chunk of request)
-                        raw += chunk;
+                    const asked = await readRequestText(request, 512000);
+                    if (asked.tooLarge) {
+                        json(413, { error: "请求过大" });
+                        return;
+                    }
+                    const raw = asked.text;
                     const body = raw ? JSON.parse(raw) : {};
                     json(200, await gitMutate(workspace.path, op, body.path, body.message));
                     return;
@@ -1113,15 +1141,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1151,15 +1182,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1234,15 +1268,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1262,15 +1299,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1303,15 +1343,18 @@ export function createHttpServer(options) {
             }
             let raw = "";
             let totalBytes = 0;
+            const reader = textBodyReader();
             for await (const chunk of request) {
-                totalBytes += chunk.length;
+                const piece = chunk;
+                totalBytes += piece.length;
                 if (totalBytes > MAX_FILE_BYTES * 2) {
                     response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
                     request.destroy();
                     return;
                 }
-                raw += chunk;
+                raw = reader.push(piece);
             }
+            raw = reader.finish();
             const json = (status, body) => {
                 response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             };
@@ -1407,14 +1450,12 @@ export function createHttpServer(options) {
             // body cost its full size in memory before the 403 said no. A question is a few hundred bytes;
             // 64KB is orders of magnitude above any honest one and far below what a hostile body could use,
             // and the shape is the same ceiling the `/api/tools` endpoints already enforce.
-            let raw = "";
-            for await (const chunk of request) {
-                raw += chunk;
-                if (raw.length > 64_000) {
-                    response.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: "question request too large" }));
-                    return;
-                }
+            const asked = await readRequestText(request, 64_000);
+            if (asked.tooLarge) {
+                response.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: "question request too large" }));
+                return;
             }
+            const raw = asked.text;
             try {
                 const body = JSON.parse(raw);
                 if (!body.conversationId || !body.question || !Array.isArray(body.options))
@@ -1633,15 +1674,18 @@ export function createHttpServer(options) {
                     }
                     let raw = "";
                     let totalBytes = 0;
+                    const reader = textBodyReader();
                     for await (const chunk of request) {
-                        totalBytes += chunk.length;
+                        const piece = chunk;
+                        totalBytes += piece.length;
                         if (totalBytes > MAX_FILE_BYTES * 2) {
                             json(413, { error: "请求体过大", code: "too_large" });
                             request.destroy();
                             return;
                         }
-                        raw += chunk;
+                        raw = reader.push(piece);
                     }
+                    raw = reader.finish();
                     const declared = Number(request.headers["content-length"] ?? "0");
                     if (Number.isFinite(declared) && declared > MAX_FILE_BYTES * 2) {
                         json(413, { error: "请求体过大", code: "too_large" });

package/dist/server/store.d.ts

@@ -118,6 +118,11 @@ export declare class Store {
      * caller cannot reach into the store's state through it.
      */
     workspaceForConversation(conversationId: string): Workspace | undefined;
+    workspace(workspaceId: string): Workspace | undefined;
+    /** Small detached rows used when refreshing each conversation's scoped model catalog. */
+    catalogConversationTargets(): Array<Pick<Conversation, "id" | "archivedAt" | "model">>;
+    /** Clone only one workspace's transcripts, never unrelated workspaces or app state. */
+    conversationsForWorkspace(workspaceId: string): Conversation[];
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
     /**
      * Sets (or clears) the app-wide default model.

package/dist/server/store.js

@@ -717,6 +717,22 @@ export class Store {
         const workspace = this.state.workspaces.find((item) => item.id === conversation?.workspaceId);
         return workspace ? { ...workspace } : undefined;
     }
+    workspace(workspaceId) {
+        const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
+        return workspace ? { ...workspace } : undefined;
+    }
+    /** Small detached rows used when refreshing each conversation's scoped model catalog. */
+    catalogConversationTargets() {
+        return this.state.conversations.map(({ id, archivedAt, model }) => ({
+            id,
+            archivedAt,
+            model: model ? { ...model } : undefined,
+        }));
+    }
+    /** Clone only one workspace's transcripts, never unrelated workspaces or app state. */
+    conversationsForWorkspace(workspaceId) {
+        return structuredClone(this.state.conversations.filter((item) => item.workspaceId === workspaceId));
+    }
     async setModelFilterRules(rules) {
         if (!Array.isArray(rules) || rules.some(rule => !rule || typeof rule.id !== "string" || typeof rule.workspacePattern !== "string" || typeof rule.modelPattern !== "string" || (rule.label !== undefined && typeof rule.label !== "string")))
             throw new Error("模型过滤规则格式不合法");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.136",
+  "version": "0.1.138",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -111,6 +111,7 @@
     "scripts/todo-tool.test.mjs",
     "scripts/tool-calls.test.mjs",
     "scripts/files-api.test.mjs",
+    "scripts/http-body-utf8-chunking.test.mjs",
     "scripts/files-eol-roundtrip.test.mjs",
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
@@ -187,6 +188,9 @@
     "scripts/visual-defects-browser.test.mjs",
     "scripts/session-state-animation-browser.test.mjs",
     "scripts/session-state-delivery-browser.test.mjs",
+    "scripts/transcript-render-scaling-browser.test.mjs",
+    "scripts/question-awaiting-signal-browser.test.mjs",
+    "scripts/withdraw-then-send-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
     "scripts/queue-dock.test.mjs",
     "scripts/scheduled-tasks-browser.test.mjs",