@pi-harness/pi-harness 0.1.23 → 0.1.24

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

@@ -1,10 +1,10 @@
 import { execFile } from "node:child_process";
 import { mkdir, mkdtemp, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { atomicWriteFile } from "@pi-harness/core";
-import { MARKETPLACE_CAPABILITIES, MARKETPLACE_CATEGORIES, MARKETPLACE_PLUGINS, attachMarketplaceStatistics, createMarketplaceStatisticsLoader, paginateMarketplace, searchMarketplace, needsMarketplacePackageInstall, sortMarketplaceByRecommendation, } from "./marketplace.js";
+import { MARKETPLACE_CAPABILITIES, MARKETPLACE_CATEGORIES, MARKETPLACE_PLUGINS, attachMarketplaceStatistics, createMarketplaceStatisticsLoader, paginateMarketplace, searchMarketplace, needsMarketplacePackageInstall, marketplaceNpmPackageName, sortMarketplaceByRecommendation, } from "./marketplace.js";
 import { parseGitWorktrees } from "./workspaces.js";
 const loadMarketplaceStatistics = createMarketplaceStatisticsLoader();
 const DEFAULT_BODY_LIMIT_BYTES = 64 * 1024;
@@ -25,18 +25,19 @@ function sendJson(response, status, payload) {
     response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "content-length": Buffer.byteLength(body) });
     response.end(body);
 }
+// A multi-byte UTF-8 sequence can straddle a chunk boundary, so the raw bytes are collected and decoded once; decoding each chunk on its own would replace the split sequence with U+FFFD.
 async function bodyText(request, maxBytes = DEFAULT_BODY_LIMIT_BYTES) {
     const chunks = [];
     let length = 0;
     for await (const chunk of request) {
         const input = chunk;
-        const value = typeof input === "string" ? input : Buffer.from(input).toString("utf8");
-        length += Buffer.byteLength(value);
+        const buffer = typeof input === "string" ? Buffer.from(input, "utf8") : Buffer.isBuffer(input) ? input : Buffer.from(input);
+        length += buffer.length;
         if (length > maxBytes)
             throw new PayloadTooLargeError();
-        chunks.push(value);
+        chunks.push(buffer);
     }
-    return chunks.join("");
+    return Buffer.concat(chunks).toString("utf8");
 }
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
@@ -56,10 +57,16 @@ function jsonSafe(value, seen = new WeakSet()) {
         return Object.prototype.toString.call(value);
     if (seen.has(value))
         return "[Circular]";
+    // Only the ancestors of the current node stay marked: a sibling that repeats the same object (Pi pushes one AgentMessage instance into both the message list and its events) is legitimate data, not a cycle.
     seen.add(value);
-    if (Array.isArray(value))
-        return value.map((item) => jsonSafe(item, seen));
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item, seen)]));
+    try {
+        if (Array.isArray(value))
+            return value.map((item) => jsonSafe(item, seen));
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item, seen)]));
+    }
+    finally {
+        seen.delete(value);
+    }
 }
 function createStatus(services, events) {
     const activeModel = services.runtime.session.model ?? services.models.model;
@@ -306,6 +313,7 @@ function sanitizeLogValue(value, state, depth = 0) {
         return "[Max Depth]";
     if (state.seen.has(value))
         return "[Circular]";
+    // Unmarked once its subtree is done, so an object logged twice as a sibling is rendered twice instead of being mistaken for a cycle.
     state.seen.add(value);
     try {
         if (value instanceof Date)
@@ -339,6 +347,9 @@ function sanitizeLogValue(value, state, depth = 0) {
     catch {
         return "[Unavailable]";
     }
+    finally {
+        state.seen.delete(value);
+    }
 }
 function sanitizeLogArguments(args) {
     const sanitized = sanitizeLogValue(args, { remaining: loggerPanelNodeLimit, seen: new WeakSet() });
@@ -478,17 +489,18 @@ function gitTerminationMessage(command, termination) {
         ? `git ${command} timed out after ${GIT_TIMEOUT_MS / 1000} seconds`
         : `git ${command} produced more output than the buffer limit allows`;
 }
+// `-z` is what makes the paths usable: without it git wraps any path holding a space, a quote or a non-ASCII byte in C-style quoting, and the quoted form is not a pathspec git will accept back on diff, add or ls-files.
 function gitStatus(cwd) {
     return new Promise((resolveStatus, rejectStatus) => {
-        execFile("git", ["status", "--short", "--untracked-files=all"], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 512 * 1024 }, (error, stdout, stderr) => {
+        execFile("git", ["status", "--short", "-z", "--untracked-files=all"], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 512 * 1024 }, (error, stdout, stderr) => {
             if (error === null) {
                 resolveStatus({ output: stdout, truncated: false });
                 return;
             }
             const termination = gitTermination(error);
             if (termination === "output-limit") {
-                // Keep the complete lines that arrived before the kill; the final line may have been cut mid-path.
-                resolveStatus({ output: stdout.slice(0, stdout.lastIndexOf("\n") + 1), truncated: true });
+                // Keep the complete records that arrived before the kill; the final one may have been cut mid-path.
+                resolveStatus({ output: stdout.slice(0, stdout.lastIndexOf("\0") + 1), truncated: true });
                 return;
             }
             if (termination === undefined && error.code === 128 && /not a git repository/i.test(stderr)) {
@@ -539,6 +551,26 @@ async function isDirectory(path) {
         return false;
     }
 }
+async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+// The loader resolves a bare plugin specifier from the profile file upwards (`createRequire(profilePath).resolve(name)`), never from the shell the harness was started in, so a marketplace package has to land in the package that owns the profile or it installs successfully and then fails to load.
+async function marketplaceInstallDirectory(configPath, fallback) {
+    let directory = dirname(resolve(configPath));
+    let parent = dirname(directory);
+    while (parent !== directory) {
+        if (await isFile(join(directory, "package.json")))
+            return directory;
+        directory = parent;
+        parent = dirname(directory);
+    }
+    return fallback;
+}
 function pickDirectory() {
     return new Promise((resolvePath, reject) => {
         execFile("osascript", ["-e", 'POSIX path of (choose folder with prompt "选择 Pi 工作区")'], { timeout: 120_000, maxBuffer: 64 * 1024 }, (error, stdout, stderr) => {
@@ -989,15 +1021,17 @@ export default {
                         sendJson(response, 409, { error: "Plugin is already installed", plugin });
                         return;
                     }
-                    const packageJsonPath = join(services.launch.cwd, "package.json");
-                    const packageLockPath = join(services.launch.cwd, "package-lock.json");
+                    const installDirectory = await marketplaceInstallDirectory(configPath, services.launch.cwd);
+                    const packageJsonPath = join(installDirectory, "package.json");
+                    const packageLockPath = join(installDirectory, "package-lock.json");
                     const packageJsonBefore = await readFile(packageJsonPath, "utf8").catch(() => undefined);
                     const packageLockBefore = await readFile(packageLockPath, "utf8").catch(() => undefined);
                     let profileBefore;
                     let entryId;
                     try {
                         if (needsMarketplacePackageInstall(plugin)) {
-                            await runProcess("npm", ["install", "--save-exact", "--package-lock=false", `${plugin.packageName}@${plugin.version}`], services.launch.cwd);
+                            const specifier = `${marketplaceNpmPackageName(plugin.packageName)}@${plugin.version}`;
+                            await runProcess("npm", ["install", "--save-exact", "--package-lock=false", specifier], installDirectory);
                         }
                         profileBefore = await appendMarketplaceProfile(configPath, plugin);
                         if (!needsMarketplacePackageInstall(plugin)) {
@@ -1021,9 +1055,14 @@ export default {
                             await loader.remove(entryId).catch(() => { });
                         if (profileBefore !== undefined)
                             await writeFile(configPath, profileBefore, "utf8").catch(() => { });
-                        if (packageJsonBefore !== undefined)
+                        // A manifest npm created for this install is removed rather than left behind; restoring is only possible when one existed before.
+                        if (packageJsonBefore === undefined)
+                            await unlink(packageJsonPath).catch(() => { });
+                        else
                             await writeFile(packageJsonPath, packageJsonBefore, "utf8").catch(() => { });
-                        if (packageLockBefore !== undefined)
+                        if (packageLockBefore === undefined)
+                            await unlink(packageLockPath).catch(() => { });
+                        else
                             await writeFile(packageLockPath, packageLockBefore, "utf8").catch(() => { });
                         sendJson(response, 502, { error: errorText(error) });
                     }
@@ -1125,8 +1164,9 @@ export default {
                     }
                     const profileEntryId = entry.options.id;
                     const profileBefore = await readFile(configPath, "utf8");
-                    const packageJsonPath = join(services.launch.cwd, "package.json");
-                    const packageLockPath = join(services.launch.cwd, "package-lock.json");
+                    const installDirectory = await marketplaceInstallDirectory(configPath, services.launch.cwd);
+                    const packageJsonPath = join(installDirectory, "package.json");
+                    const packageLockPath = join(installDirectory, "package-lock.json");
                     const packageJsonBefore = await readFile(packageJsonPath, "utf8").catch(() => undefined);
                     const packageLockBefore = await readFile(packageLockPath, "utf8").catch(() => undefined);
                     await entry.parent.remove(entry.options.id);
@@ -1134,7 +1174,7 @@ export default {
                     try {
                         await updateMarketplaceProfile(configPath, profileEntryId, { remove: true });
                         if (needsMarketplacePackageInstall(plugin))
-                            await runProcess("npm", ["uninstall", "--package-lock=false", plugin.packageName], services.launch.cwd);
+                            await runProcess("npm", ["uninstall", "--package-lock=false", marketplaceNpmPackageName(plugin.packageName)], installDirectory);
                         sendJson(response, 200, { uninstalled: true, id: payload.id });
                     }
                     catch (error) {
@@ -1246,18 +1286,22 @@ export default {
                     sendJson(response, 500, { error: errorText(error) });
                     return;
                 }
-                const items = status.output
-                    .split("\n")
-                    .map((line) => line.trimEnd())
-                    .filter((line) => line.length > 0)
-                    .map((line) => {
-                    const status = line.slice(0, 2).trim() || "??";
-                    return {
-                        path: line.slice(3),
-                        status,
-                        label: status === "??" ? "untracked" : status.includes("D") ? "deleted" : status.includes("A") ? "added" : "modified",
-                    };
-                });
+                const records = status.output.split("\0");
+                const items = [];
+                for (let index = 0; index < records.length; index += 1) {
+                    const record = records[index] ?? "";
+                    if (record.length < 4)
+                        continue;
+                    const code = record.slice(0, 2).trim() || "??";
+                    // Rename and copy records carry the original path in a second NUL-terminated field, which is not a workspace change of its own.
+                    if (code.startsWith("R") || code.startsWith("C"))
+                        index += 1;
+                    items.push({
+                        path: record.slice(3),
+                        status: code,
+                        label: code === "??" ? "untracked" : code.includes("D") ? "deleted" : code.includes("A") ? "added" : "modified",
+                    });
+                }
                 sendJson(response, 200, { items, ...(status.truncated ? { truncated: true } : {}) });
             },
         });
@@ -1744,21 +1788,48 @@ export default {
                         sendJson(response, 409, { error: "Cannot batch-delete the active session" });
                         return;
                     }
-                    await mutateSessionMetadata(manager, context.logger, async (metadata) => {
+                    if (action === "delete") {
+                        // The unlinks run outside the metadata mutation: a failure halfway through must not discard the key removals for the files that are already gone from disk.
+                        const removed = [];
+                        const failed = [];
                         for (const path of paths) {
-                            if (action === "delete") {
+                            try {
                                 await unlink(path);
-                                delete metadata[path];
+                                removed.push(path);
                             }
-                            else {
-                                const current = metadata[path] ?? {};
-                                metadata[path] = {
-                                    ...current,
-                                    ...(action === "archive" || action === "unarchive" ? { archived: action === "archive" } : {}),
-                                    ...(action === "pin" || action === "unpin" ? { pinned: action === "pin" } : {}),
-                                };
+                            catch (error) {
+                                // A session another tab already deleted leaves nothing to unlink, but its metadata entry still has to go.
+                                if (error.code === "ENOENT")
+                                    removed.push(path);
+                                else
+                                    failed.push({ path, error: errorText(error) });
                             }
                         }
+                        await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                            for (const path of removed)
+                                delete metadata[path];
+                        });
+                        if (failed.length > 0) {
+                            sendJson(response, 409, {
+                                error: `Some sessions could not be deleted: ${failed.map((item) => item.path).join(", ")}`,
+                                action,
+                                count: removed.length,
+                                failed,
+                            });
+                            return;
+                        }
+                        sendJson(response, 200, { action, count: removed.length });
+                        return;
+                    }
+                    await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                        for (const path of paths) {
+                            const current = metadata[path] ?? {};
+                            metadata[path] = {
+                                ...current,
+                                ...(action === "archive" || action === "unarchive" ? { archived: action === "archive" } : {}),
+                                ...(action === "pin" || action === "unpin" ? { pinned: action === "pin" } : {}),
+                            };
+                        }
                     });
                     sendJson(response, 200, { action, count: paths.length });
                 }