@evandu/super-pi 0.1.107 → 0.1.108

package/dist/client/index.html

@@ -8,7 +8,7 @@
     <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-B1K1OA_6.js"></script>
+    <script type="module" crossorigin src="/assets/index-CnIOGNIm.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Aa8KN3IB.css">
   </head>
   <body>

package/dist/server/content-search.d.ts

@@ -22,11 +22,21 @@ export type ContentSearchResult = {
     complete: boolean;
     reasons: string[];
 };
-/**
- * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
- * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
- * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
- * Instead give it one verified indexed file at a time; validate again before publishing any hit.
- * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
- */
-export declare function searchByContent(root: string, candidates: readonly ContentSearchCandidate[], query: string, indexStatus?: Pick<FileIndexSnapshot, "complete" | "skipped">): Promise<ContentSearchResult>;
+type RipgrepMatch = {
+    path: string;
+    line: number;
+    text: string;
+};
+type RipgrepRun = (input: {
+    rgPath: string;
+    pattern: string;
+    paths: string[];
+    signal: AbortSignal;
+    onMatch: (match: RipgrepMatch) => Promise<boolean>;
+}) => Promise<void>;
+export type ContentSearchOptions = {
+    resolveRipgrep?: () => Promise<string | undefined>;
+    runRipgrep?: RipgrepRun;
+};
+export declare function searchByContent(root: string, candidates: readonly ContentSearchCandidate[], query: string, indexStatus?: Pick<FileIndexSnapshot, "complete" | "skipped">, options?: ContentSearchOptions): Promise<ContentSearchResult>;
+export {};

package/dist/server/content-search.js

@@ -1,152 +1,249 @@
-import { open } from "node:fs/promises";
-import { basename } from "node:path";
-import { createGrepTool } from "@earendil-works/pi-coding-agent";
-import { isTextName, looksBinary, resolveInsideRoot } from "./files.js";
+import { spawn } from "node:child_process";
+import { open, stat } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { FilesError, createRootGuard, isTextName, looksBinary, toRelative } from "./files.js";
 export const MAX_CONTENT_RESULTS = 500;
 export const MAX_CONTENT_FILE_BYTES = 512 * 1024;
 export const MAX_CONTENT_DEPTH = 12;
 export const MAX_CONTENT_MS = 10000;
+let sdkRipgrep;
+/** Pi's public package export hides this helper; resolve the installed module used by createGrepTool. */
+async function resolveSdkRipgrep() {
+    sdkRipgrep ??= (async () => {
+        const entry = fileURLToPath(await import.meta.resolve("@earendil-works/pi-coding-agent"));
+        const manager = await import(pathToFileURL(join(dirname(entry), "utils", "tools-manager.js")).href);
+        return manager.getToolPath("rg") ?? manager.ensureTool("rg");
+    })();
+    return sdkRipgrep;
+}
+function normalizeLine(text) { return text.endsWith("\r\n") ? text.slice(0, -2) : text.endsWith("\n") ? text.slice(0, -1) : text; }
 /**
- * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
- * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
- * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
- * Instead give it one verified indexed file at a time; validate again before publishing any hit.
- * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
+ * One rg process for all indexed files. createGrepTool is deliberately not used: its path accepts only
+ * one directory/file and glob cannot express this arbitrary index set, so it would walk a second tree or
+ * spawn once per file. Matching still uses the SDK's exact ensureTool/getToolPath-selected ripgrep.
+ * The installed rg has no --files-from flag, so verified absolute candidates are passed as paths.
  */
-export async function searchByContent(root, candidates, query, indexStatus = { complete: true, skipped: [] }) {
-    await resolveInsideRoot(root, "");
+const runRipgrep = ({ rgPath, pattern, paths, signal, onMatch }) => new Promise((resolve, reject) => {
+    const child = spawn(rgPath, ["--json", "--line-number", "--color=never", "--hidden", "--no-ignore", "--text", "--fixed-strings", "--", pattern, ...paths], { stdio: ["ignore", "pipe", "pipe"], shell: false, windowsHide: true });
+    let stdout = "";
+    let stderr = "";
+    let chain = Promise.resolve(true);
+    let stopped = false;
+    const stop = () => { if (!stopped) {
+        stopped = true;
+        child.kill();
+    } };
+    const onAbort = () => stop();
+    signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        let newline;
+        while ((newline = stdout.indexOf("\n")) >= 0) {
+            const row = stdout.slice(0, newline);
+            stdout = stdout.slice(newline + 1);
+            chain = chain.then(async (continueSearch) => {
+                if (!continueSearch)
+                    return false;
+                let event;
+                try {
+                    event = JSON.parse(row);
+                }
+                catch {
+                    return true;
+                }
+                if (event.type !== "match")
+                    return true;
+                const path = event.data?.path?.text;
+                const line = event.data?.line_number;
+                const text = event.data?.lines?.text;
+                if (!path || !Number.isSafeInteger(line))
+                    return true;
+                const keepGoing = await onMatch({ path, line: line, text: typeof text === "string" ? normalizeLine(text) : "" });
+                if (!keepGoing)
+                    stop();
+                return keepGoing;
+            });
+            chain.catch(() => { });
+        }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.on("error", (error) => { signal.removeEventListener("abort", onAbort); reject(new Error(`Failed to run ripgrep: ${error.message}`)); });
+    child.on("close", (code) => {
+        signal.removeEventListener("abort", onAbort);
+        void chain.then(() => {
+            if (signal.aborted || stopped || code === 0 || code === 1)
+                resolve();
+            else
+                reject(new Error(`ripgrep failed (${code}): ${stderr.trim() || "unknown error"}`));
+        }, reject);
+    });
+});
+async function checkedTextFile(absolute) {
+    try {
+        const info = await stat(absolute);
+        if (!info.isFile())
+            return "skip";
+        if (info.size > MAX_CONTENT_FILE_BYTES)
+            return "size";
+        const handle = await open(absolute, "r");
+        try {
+            const buffer = Buffer.alloc(MAX_CONTENT_FILE_BYTES + 1);
+            let length = 0;
+            while (length < buffer.length) {
+                const read = await handle.read(buffer, length, buffer.length - length, null);
+                if (!read.bytesRead)
+                    break;
+                length += read.bytesRead;
+            }
+            if (length > MAX_CONTENT_FILE_BYTES)
+                return "size";
+            const bytes = buffer.subarray(0, length);
+            if (looksBinary(bytes) || bytes.includes(0))
+                return "skip";
+            new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+            return "text";
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return "skip";
+    }
+}
+async function checkedFileSize(absolute) {
+    try {
+        const info = await stat(absolute);
+        return !info.isFile() ? "skip" : info.size > MAX_CONTENT_FILE_BYTES ? "size" : "ok";
+    }
+    catch {
+        return "skip";
+    }
+}
+function needsContainmentCheck(path) {
+    return /(^|[\\/])\.\.([\\/]|$)|^[\\/]|^[A-Za-z]:/.test(path);
+}
+async function mapConcurrently(items, limit, fn) {
+    const output = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            output[index] = await fn(items[index]);
+        }
+    }));
+    return output;
+}
+export async function searchByContent(root, candidates, query, indexStatus = { complete: true, skipped: [] }, options = {}) {
+    const guard = createRootGuard(root);
+    await guard("");
     const hits = [];
     const skipped = new Set(indexStatus.skipped);
     const reasons = new Set(indexStatus.complete ? [] : ["index"]);
     const needle = query.trim();
     if (!needle)
         return { hits, truncated: false, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
-    const tool = createGrepTool(root);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), MAX_CONTENT_MS);
+    const paths = [];
+    const candidateByPath = new Map();
+    const eligible = [];
+    for (const candidate of candidates) {
+        if (controller.signal.aborted) {
+            reasons.add("time");
+            break;
+        }
+        if (candidate.kind !== "file")
+            continue;
+        if (candidate.path.replace(/\\/g, "/").split("/").length - 1 > MAX_CONTENT_DEPTH) {
+            skipped.add(candidate.path);
+            reasons.add("depth");
+            continue;
+        }
+        if (candidate.text === false || !isTextName(candidate.path)) {
+            skipped.add(candidate.path);
+            continue;
+        }
+        if (candidate.size !== null && candidate.size > MAX_CONTENT_FILE_BYTES) {
+            skipped.add(candidate.path);
+            reasons.add("size");
+            continue;
+        }
+        // Index paths are normalized and symlink-free. Reject any shape that could escape before creating an
+        // rg argument; all output still takes the full shared containment path below before it is published.
+        if (needsContainmentCheck(candidate.path)) {
+            await guard(candidate.path);
+        }
+        eligible.push(candidate);
+    }
+    // Do bounded metadata checks concurrently. rg's binary heuristic cannot prove strict UTF-8, so matching
+    // files get the full byte check below; output passes the shared containment guard before publication.
+    const checkedCandidates = await mapConcurrently(eligible, 96, async (candidate) => ({ candidate, absolute: join(root, candidate.path), classification: await checkedFileSize(join(root, candidate.path)) }));
+    for (const { candidate, absolute, classification } of checkedCandidates) {
+        if (controller.signal.aborted) {
+            reasons.add("time");
+            break;
+        }
+        if (classification !== "ok") {
+            skipped.add(candidate.path);
+            if (classification === "size")
+                reasons.add("size");
+            continue;
+        }
+        paths.push(absolute);
+        candidateByPath.set(candidate.path, candidate);
+    }
     try {
-        for (const candidate of candidates) {
-            if (candidate.kind !== "file")
-                continue;
-            if (controller.signal.aborted) {
-                reasons.add("time");
-                break;
-            }
-            // Validate even an excluded candidate: metadata and cached paths are not a security boundary.
-            let absolute;
-            try {
-                absolute = await resolveInsideRoot(root, candidate.path);
-            }
-            catch (error) {
-                const code = error.code;
-                if (code === "outside_workspace" || code === "bad_path" || code === "workspace_missing")
-                    throw error;
-                skipped.add(candidate.path);
-                reasons.add("unreadable");
-                continue;
-            }
-            if (candidate.path.replace(/\\/g, "/").split("/").length - 1 > MAX_CONTENT_DEPTH) {
-                skipped.add(candidate.path);
-                reasons.add("depth");
-                continue;
-            }
-            if (candidate.text === false || !isTextName(candidate.path)) {
-                skipped.add(candidate.path);
-                continue;
-            }
-            let bytes;
-            try {
-                // Read at most cap+1 bytes even if a file grows after stat; never allocate its untrusted size.
-                const handle = await open(absolute, "r");
+        if (controller.signal.aborted)
+            return { hits, truncated: true, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
+        const rgPath = await (options.resolveRipgrep ?? resolveSdkRipgrep)();
+        if (!rgPath)
+            throw new FilesError(503, "内容搜索不可用（ripgrep 不可用）", "ripgrep_unavailable");
+        await (options.runRipgrep ?? runRipgrep)({ rgPath, pattern: needle, paths, signal: controller.signal, onMatch: async (match) => {
+                if (controller.signal.aborted) {
+                    reasons.add("time");
+                    return false;
+                }
+                let path;
+                let absolute;
                 try {
-                    const info = await handle.stat();
-                    if (!info.isFile()) {
-                        skipped.add(candidate.path);
-                        reasons.add("unreadable");
-                        continue;
-                    }
-                    if (info.size > MAX_CONTENT_FILE_BYTES) {
-                        skipped.add(candidate.path);
-                        reasons.add("size");
-                        continue;
-                    }
-                    const buffer = Buffer.alloc(MAX_CONTENT_FILE_BYTES + 1);
-                    let length = 0;
-                    while (length < buffer.length) {
-                        const read = await handle.read(buffer, length, buffer.length - length, null);
-                        if (!read.bytesRead)
-                            break;
-                        length += read.bytesRead;
-                    }
-                    if (length > MAX_CONTENT_FILE_BYTES) {
-                        skipped.add(candidate.path);
-                        reasons.add("size");
-                        continue;
-                    }
-                    bytes = buffer.subarray(0, length);
+                    path = toRelative(root, match.path);
+                    absolute = await guard(path);
                 }
-                finally {
-                    await handle.close();
+                catch (error) {
+                    const code = error.code;
+                    if (code === "outside_workspace" || code === "bad_path" || code === "workspace_missing")
+                        throw error;
+                    skipped.add(match.path);
+                    reasons.add("unreadable");
+                    return true;
                 }
-            }
-            catch {
-                skipped.add(candidate.path);
-                reasons.add("unreadable");
-                continue;
-            }
-            if (looksBinary(bytes) || bytes.includes(0)) {
-                skipped.add(candidate.path);
-                continue;
-            }
-            try {
-                new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-            }
-            catch {
-                skipped.add(candidate.path);
-                continue;
-            }
-            let result;
-            try {
-                result = await tool.execute("content-search", {
-                    pattern: needle, path: absolute, literal: true, limit: MAX_CONTENT_RESULTS - hits.length,
-                }, controller.signal);
-            }
-            catch (error) {
-                if (controller.signal.aborted) {
-                    reasons.add("time");
-                    break;
+                if (!candidateByPath.has(path)) {
+                    skipped.add(path);
+                    reasons.add("unreadable");
+                    return true;
                 }
-                // SDK/ripgrep failures are request failures, never a successful empty search.
-                throw error;
-            }
-            const prefix = basename(absolute) + ":";
-            const rows = [];
-            for (const block of result.content) {
-                if (block.type !== "text")
-                    continue;
-                for (const row of block.text.split("\n")) {
-                    if (!row.startsWith(prefix))
-                        continue;
-                    const match = /^(\d+): (.*)$/.exec(row.slice(prefix.length));
-                    if (!match)
-                        continue;
-                    rows.push({ path: candidate.path, name: basename(absolute), line: Number(match[1]), text: match[2] });
+                const classification = await checkedTextFile(absolute);
+                if (classification !== "text") {
+                    skipped.add(path);
+                    if (classification === "size")
+                        reasons.add("size");
+                    return true;
                 }
-            }
-            if (rows.length) {
-                await resolveInsideRoot(root, candidate.path);
-                hits.push(...rows.slice(0, MAX_CONTENT_RESULTS - hits.length));
-            }
-            const details = result.details;
-            if (details?.truncation?.truncated)
-                reasons.add("output");
-            if (details?.linesTruncated)
-                reasons.add("line");
-            if (details?.matchLimitReached || hits.length >= MAX_CONTENT_RESULTS) {
-                reasons.add("results");
-                break;
-            }
-        }
+                hits.push({ path, name: basename(absolute), line: match.line, text: match.text });
+                if (hits.length >= MAX_CONTENT_RESULTS) {
+                    reasons.add("results");
+                    return false;
+                }
+                return true;
+            } });
+        if (controller.signal.aborted)
+            reasons.add("time");
     }
     finally {
         clearTimeout(timer);

package/dist/server/store.js

@@ -508,28 +508,48 @@ function reconcileTodos(state) {
  *
  * If a task originated from a tool call in a conversation, its tool call block is marked as failed
  * so the chat transcript accurately reflects that the task was interrupted by server restart.
+ *
+ * WHY ONLY THE LINKED ONES ARE SWEPT, and not every entry in the list.
+ *
+ * A task is created by exactly one route: the `/api/exec` endpoint, and that endpoint REQUIRES a
+ * `conversationId` (it is what the capability check and the tool-call anchor are resolved against).
+ * So every task this server ever creates is linked to a conversation's tool call, and every one of
+ * those is swept here - the zombie problem is fully covered.
+ *
+ * A task with NO conversation anchor is a shape this server cannot produce. The sweep cannot account
+ * for it either: there is no tool call to mark failed, so there is nothing to tell the reader that
+ * the task died. Deleting it would remove a record without replacing it with an explanation, which is
+ * the one outcome worse than a stale entry. So those are LEFT ALONE, and this function says so in its
+ * return value rather than silently keeping them.
  */
 function reconcileBackgroundTasks(state) {
     const tasks = Array.isArray(state.backgroundTasks) ? state.backgroundTasks : [];
     state.backgroundTasks = [];
     if (!tasks.length)
-        return { orphaned: [], changed: false };
+        return { orphaned: [], changed: false, unlinked: [] };
     const orphaned = [];
+    const unlinked = [];
     for (const task of tasks) {
         if (!task)
             continue;
+        // The three fields are destructured rather than tested through a boolean, because a boolean does not
+        // narrow their types and `toolCalls[undefined]` is not an index.
+        const { conversationId, originMessageId, originCallRow } = task;
+        if (!conversationId || originMessageId === undefined || originCallRow === undefined) {
+            unlinked.push(task);
+            state.backgroundTasks.push(task);
+            continue;
+        }
         orphaned.push(task);
-        if (task.conversationId && task.originMessageId !== undefined && task.originCallRow !== undefined) {
-            const conv = state.conversations?.find((c) => c?.id === task.conversationId);
-            const msg = conv?.messages?.find((m) => m?.id === task.originMessageId);
-            const call = msg?.toolCalls?.[task.originCallRow];
-            if (call?.backgroundTask && call.backgroundTask.status === "running") {
-                call.backgroundTask.status = "failed";
-                call.backgroundTask.output = "任务随服务重启被终止";
-            }
+        const conv = state.conversations?.find((c) => c?.id === conversationId);
+        const msg = conv?.messages?.find((m) => m?.id === originMessageId);
+        const call = msg?.toolCalls?.[originCallRow];
+        if (call?.backgroundTask && call.backgroundTask.status === "running") {
+            call.backgroundTask.status = "failed";
+            call.backgroundTask.output = "任务随服务重启被终止";
         }
     }
-    return { orphaned, changed: true };
+    return { orphaned, changed: orphaned.length > 0, unlinked };
 }
 export class Store {
     repository;
@@ -579,6 +599,12 @@ export class Store {
                     console.warn(`Super Pi: workflow ${plan.id} was still marked running when the last server stopped - it is now stopped, because no step can still be executing.`);
                 for (const task of orphanedTasks.orphaned)
                     console.warn(`Super Pi: background task ${task.id} (${task.title}) was left in flight when the last server stopped - it has been cleaned up.`);
+                // The unlinked ones are said out loud rather than swept silently. They cannot come from this
+                // server - `/api/exec` requires a conversationId - so they are a hand-written or legacy entry,
+                // and the reader is told they were left alone instead of wondering why one task vanished and
+                // another did not.
+                for (const task of orphanedTasks.unlinked)
+                    console.warn(`Super Pi: background task ${task.id} (${task.title}) has no conversation to be traced back to - it was left in place, because there is no tool call to mark as interrupted.`);
                 // Announced for the same reason: a conversation that failed while nobody was watching is invisible
                 // otherwise, and the user who was watching a spinner when the server died deserves to learn that
                 // their run is over rather than guessing from the fact that it stopped moving.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.107",
+  "version": "0.1.108",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -94,6 +94,7 @@
     "scripts/task-tool.test.mjs",
     "scripts/tool-register-env.test.mjs",
     "scripts/bg-task-zombie.test.mjs",
+    "scripts/scoped-sidebar-tabs.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",