@pi-harness/pi-harness 0.1.85 → 0.1.87

package/packages/api-gateway/dist/index.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { existsSync, writeFileSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, opendir, readFile, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
@@ -23,6 +23,12 @@ const PROCESS_FAILURE_TEXT_LIMIT = 400;
 const PROCESS_TIMEOUT_MS = 120_000;
 // Mutating commands run user hooks (pre-commit, lint-staged, test suites) and may stage large trees; killing them part-way leaves index.lock and a half-finished operation behind, so they get a far more generous bound than read-only queries.
 const GIT_MUTATION_TIMEOUT_MS = 120_000;
+const MAX_WORKSPACE_FILES = 5_000;
+const MAX_WORKSPACE_FILE_CANDIDATES = 20_000;
+const MAX_WORKSPACE_DIRECTORIES = 2_000;
+const MAX_WORKSPACE_DEPTH = 16;
+const WORKSPACE_FILE_CACHE_MS = 1_000;
+const IGNORED_WORKSPACE_DIRECTORIES = new Set([".git", "node_modules", ".pi", "dist", "build"]);
 class PayloadTooLargeError extends Error {
     constructor() {
         super("Request body is too large");
@@ -124,6 +130,7 @@ async function createSessionSnapshot(services, events, logger, messages = servic
         sessionId: session.sessionId,
         sessionFile: session.sessionFile,
         name: typeof manager?.getSessionName === "function" ? (manager.getSessionName() ?? undefined) : undefined,
+        forked: typeof manager?.getHeader === "function" && typeof manager.getHeader()?.parentSession === "string",
         messages,
         entries: typeof manager?.getEntries === "function" ? manager.getEntries() : [],
         events,
@@ -673,6 +680,106 @@ function gitCommand(cwd, args, timeoutMs = GIT_TIMEOUT_MS) {
         });
     });
 }
+function ignoredWorkspaceDirectory(name) {
+    return IGNORED_WORKSPACE_DIRECTORIES.has(process.platform === "win32" || process.platform === "darwin" ? name.toLowerCase() : name);
+}
+async function existingWorkspaceFiles(root, candidates, truncated) {
+    const canonicalRoot = await realpath(resolve(root));
+    const paths = [];
+    for (let start = 0; start < candidates.length && paths.length < MAX_WORKSPACE_FILES; start += 64) {
+        const batch = candidates.slice(start, start + 64);
+        const existing = await Promise.all(batch.map(async (path) => {
+            const target = resolve(canonicalRoot, path);
+            if (escapesRoot(relative(canonicalRoot, target)))
+                return undefined;
+            try {
+                const canonical = await realpath(target);
+                if (escapesRoot(relative(canonicalRoot, canonical)) || !(await stat(canonical)).isFile())
+                    return undefined;
+                return path;
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        for (const path of existing) {
+            if (path !== undefined)
+                paths.push(path);
+            if (paths.length >= MAX_WORKSPACE_FILES)
+                break;
+        }
+    }
+    return { paths: paths.sort(), truncated: truncated || paths.length >= MAX_WORKSPACE_FILES };
+}
+async function gitWorkspaceFiles(root) {
+    const result = await gitCommand(root, ["ls-files", "--cached", "--others", "--exclude-standard", "--deduplicate", "-z"]);
+    if (result.code !== 0 && result.terminated !== "output-limit") {
+        if (/not a git repository/iu.test(result.stderr))
+            return undefined;
+        throw new Error(result.terminated ? gitTerminationMessage("ls-files", result.terminated) : result.stderr.trim() || "Unable to list workspace files");
+    }
+    const lastBoundary = result.stdout.lastIndexOf("\0");
+    const completeOutput = result.terminated === "output-limit" ? result.stdout.slice(0, lastBoundary + 1) : result.stdout;
+    const allCandidates = [...new Set(completeOutput.split("\0").filter((path) => path !== "" && !path.includes("\uFFFD")))];
+    const candidates = allCandidates.slice(0, MAX_WORKSPACE_FILE_CANDIDATES);
+    return existingWorkspaceFiles(root, candidates, result.terminated === "output-limit" || allCandidates.length > candidates.length);
+}
+async function walkedWorkspaceFiles(root) {
+    const canonicalRoot = await realpath(resolve(root));
+    const pending = [{ directory: canonicalRoot, depth: 0 }];
+    const paths = [];
+    let directories = 0;
+    let scanned = 0;
+    let truncated = false;
+    while (pending.length > 0 && paths.length < MAX_WORKSPACE_FILES && directories < MAX_WORKSPACE_DIRECTORIES && scanned < MAX_WORKSPACE_FILE_CANDIDATES) {
+        const current = pending.shift();
+        if (current === undefined)
+            break;
+        directories += 1;
+        try {
+            const handle = await opendir(current.directory);
+            for await (const entry of handle) {
+                scanned += 1;
+                if (scanned > MAX_WORKSPACE_FILE_CANDIDATES) {
+                    truncated = true;
+                    break;
+                }
+                const name = entry.name;
+                if (name.includes("\uFFFD")) {
+                    truncated = true;
+                    continue;
+                }
+                const target = join(current.directory, name);
+                if (entry.isSymbolicLink())
+                    continue;
+                if (entry.isFile()) {
+                    paths.push(relative(canonicalRoot, target).split(sep).join("/"));
+                    if (paths.length >= MAX_WORKSPACE_FILES) {
+                        truncated = true;
+                        break;
+                    }
+                }
+                else if (entry.isDirectory() && !ignoredWorkspaceDirectory(name)) {
+                    if (current.depth >= MAX_WORKSPACE_DEPTH)
+                        truncated = true;
+                    else
+                        pending.push({ directory: target, depth: current.depth + 1 });
+                }
+            }
+        }
+        catch (error) {
+            if (current.directory === canonicalRoot)
+                throw error;
+            truncated = true;
+        }
+    }
+    if (pending.length > 0 || directories >= MAX_WORKSPACE_DIRECTORIES || scanned >= MAX_WORKSPACE_FILE_CANDIDATES)
+        truncated = true;
+    return { paths: paths.sort(), truncated };
+}
+async function workspaceFiles(root) {
+    return (await gitWorkspaceFiles(root)) ?? walkedWorkspaceFiles(root);
+}
 function probeEveryApiCliAuth() {
     const executable = process.env.EVERYAPI_CLI_PATH?.trim() || "everyapi";
     return new Promise((resolveStatus) => {
@@ -774,6 +881,25 @@ export default {
         };
         const disposePluginPanels = registerPluginPanels(context, services);
         let busy = false;
+        let workspaceFileCache;
+        let workspaceFileRequest;
+        const readWorkspaceFiles = (cwd) => {
+            if (workspaceFileCache?.cwd === cwd && workspaceFileCache.expiresAt > Date.now())
+                return Promise.resolve(workspaceFileCache.catalogue);
+            if (workspaceFileRequest?.cwd === cwd)
+                return workspaceFileRequest.promise;
+            const promise = workspaceFiles(cwd)
+                .then((catalogue) => {
+                workspaceFileCache = { cwd, expiresAt: Date.now() + WORKSPACE_FILE_CACHE_MS, catalogue };
+                return catalogue;
+            })
+                .finally(() => {
+                if (workspaceFileRequest?.promise === promise)
+                    workspaceFileRequest = undefined;
+            });
+            workspaceFileRequest = { cwd, promise };
+            return promise;
+        };
         const events = [];
         const eventClients = new Set();
         const initialRunAt = Date.now();
@@ -1537,6 +1663,21 @@ export default {
                 sendJson(response, 200, { items, ...(status.truncated ? { truncated: true } : {}) });
             },
         });
+        const disposeWorkspaceFiles = services.webServer.register({
+            path: "/api/workspace/files",
+            async handler(_request, response) {
+                try {
+                    const catalogue = await readWorkspaceFiles(activeCwd(services));
+                    sendJson(response, 200, {
+                        items: catalogue.paths.map((path) => ({ path, status: "", label: "workspace" })),
+                        truncated: catalogue.truncated,
+                    });
+                }
+                catch (error) {
+                    sendJson(response, 500, { error: errorText(error) });
+                }
+            },
+        });
         const disposeFileDiff = services.webServer.register({
             path: "/api/files/diff",
             async handler(request, response) {
@@ -2233,6 +2374,7 @@ export default {
                             modified: item.modified,
                             messageCount: item.messageCount,
                             firstMessage: item.firstMessage,
+                            forked: typeof item.parentSessionPath === "string" && item.parentSessionPath !== "",
                             archived: metadata[item.path]?.archived === true,
                             pinned: metadata[item.path]?.pinned === true,
                         })),
@@ -2270,6 +2412,7 @@ export default {
             disposeWorkspaces();
             disposePickDirectory();
             disposeFiles();
+            disposeWorkspaceFiles();
             disposeFileDiff();
             disposeFileCommit();
             disposeFileRevert();