pi-crew 0.9.53 → 0.9.55

package/src/runtime/pi-json-output.ts

@@ -0,0 +1,170 @@
+export interface ParsedPiUsage {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: number;
+	turns?: number;
+}
+
+export interface ParsedPiJsonOutput {
+	jsonEvents: number;
+	textEvents: string[];
+	finalText?: string;
+	usage?: ParsedPiUsage;
+	/** Unified patches extracted from tool_result events (edit tool patch field) */
+	patches?: string[];
+	/** Model/provider error messages extracted from message_end events (e.g.
+	 * "429 ... overloaded"). Used to detect runs that exited 0 but produced
+	 * nothing because the model was rate-limited — see task-runner 429 fix. */
+	errorMessages?: string[];
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = obj[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return undefined;
+}
+
+function mergeUsage(target: ParsedPiUsage, source: ParsedPiUsage): ParsedPiUsage {
+	return {
+		input: source.input ?? target.input,
+		output: source.output ?? target.output,
+		cacheRead: source.cacheRead ?? target.cacheRead,
+		cacheWrite: source.cacheWrite ?? target.cacheWrite,
+		cost: source.cost ?? target.cost,
+		turns: source.turns ?? target.turns,
+	};
+}
+
+function extractUsage(value: unknown): ParsedPiUsage | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: ParsedPiUsage = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	// Pi --mode json nests usage under message for message_end / turn_end events.
+	for (const key of ["usage", "message", "tokenUsage", "tokens", "stats"]) {
+		const nested = extractUsage(obj[key]);
+		if (nested) return nested;
+	}
+	return undefined;
+}
+
+function textFromContent(content: unknown): string[] {
+	if (typeof content === "string") return [content];
+	if (!Array.isArray(content)) return [];
+	const text: string[] = [];
+	for (const part of content) {
+		const obj = asRecord(part);
+		if (!obj) continue;
+		if (obj.type === "text" && typeof obj.text === "string") text.push(obj.text);
+		else if (typeof obj.content === "string") text.push(obj.content);
+	}
+	return text;
+}
+
+/** Extract assistant-text fragments from a parsed Pi JSON event.
+ *  Exported so {@link ChildPiLineObserver} can capture the RAW (uncapped)
+ *  assistant text for the authoritative result, mirroring the extraction
+ *  order this function uses inside {@link parsePiJsonOutput}. */
+export function extractText(value: unknown): string[] {
+	const obj = asRecord(value);
+	if (!obj) return [];
+	const message = asRecord(obj.message);
+	if (message?.role !== undefined && message.role !== "assistant") return [];
+	const text: string[] = [];
+	if (typeof obj.text === "string") text.push(obj.text);
+	if (typeof obj.output === "string") text.push(obj.output);
+	if (typeof obj.finalOutput === "string") text.push(obj.finalOutput);
+	if (typeof obj.final_output === "string") text.push(obj.final_output);
+	if (!message) text.push(...textFromContent(obj.content));
+	if (message) text.push(...textFromContent(message.content));
+	return text.filter((entry) => entry.trim().length > 0);
+}
+
+export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
+	let jsonEvents = 0;
+	const textEvents: string[] = [];
+	const patches: string[] = [];
+	const errorMessages: string[] = [];
+	let usage: ParsedPiUsage | undefined;
+	for (const line of stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let event: unknown;
+		try {
+			event = JSON.parse(trimmed) as unknown;
+		} catch {
+			continue;
+		}
+		jsonEvents++;
+		textEvents.push(...extractText(event));
+		// Extract unified patches from tool_result events
+		extractPatch(event, patches);
+		// Extract provider/model error messages from message_end events (429 fix).
+		const errMsg = extractErrorMessage(event);
+		if (errMsg) errorMessages.push(errMsg);
+		const eventUsage = extractUsage(event);
+		if (eventUsage) usage = mergeUsage(usage ?? {}, eventUsage);
+	}
+	return {
+		jsonEvents,
+		textEvents,
+		finalText: textEvents.length > 0 ? textEvents[textEvents.length - 1] : undefined,
+		usage,
+		patches: patches.length > 0 ? patches : undefined,
+		errorMessages: errorMessages.length > 0 ? errorMessages : undefined,
+	};
+}
+
+/**
+ * Pull the provider/model error message out of a `message_end` event. The shape
+ * is `{type:"message_end", message:{role:"assistant", content:[], errorMessage:"429 ...", stopReason:"error"}}`.
+ * Returns undefined for events without an errorMessage.
+ */
+function extractErrorMessage(event: unknown): string | undefined {
+	const obj = asRecord(event);
+	if (!obj) return undefined;
+	// message_end events carry the error on the nested message object.
+	const message = asRecord(obj.message) ?? obj;
+	const errorMessage = message.errorMessage;
+	return typeof errorMessage === "string" && errorMessage.trim() ? errorMessage.trim() : undefined;
+}
+
+/**
+ * Extract unified patches from a tool_result event.
+ * pi's edit tool now includes a `patch` field (standard unified diff format).
+ * We detect it by looking for lines starting with "---" or "+++" which indicate
+ * unified diff format.
+ */
+function extractPatch(event: unknown, patches: string[]): void {
+	const obj = asRecord(event);
+	if (obj?.type !== "tool_result") return;
+
+	const content = obj.content;
+	if (!Array.isArray(content)) return;
+
+	for (const item of content) {
+		const part = asRecord(item);
+		if (part?.type !== "text") continue;
+		const text = typeof part.text === "string" ? part.text : "";
+
+		// Check if this looks like a unified patch (starts with "---" or "+++")
+		if (text.includes("--- a/") || text.includes("diff ---")) {
+			patches.push(text);
+		}
+	}
+}

package/src/runtime/pi-spawn.ts

@@ -0,0 +1,273 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface PiSpawnCommand {
+	command: string;
+	args: string[];
+}
+
+const PI_PACKAGE_NAMES = ["@earendil-works/pi-coding-agent", "@mariozechner/pi-coding-agent"];
+
+function isRunnableNodeScript(filePath: string): boolean {
+	return fs.existsSync(filePath) && /\.(?:mjs|cjs|js)$/i.test(filePath);
+}
+
+/**
+ * Check that a resolved path is within known safe prefixes.
+ * Allowed prefixes: npm global bin (APPDATA/npm), project node_modules/.bin,
+ * or the current process's execPath directory.
+ */
+function isWithinAllowedPrefixes(resolvedPath: string): boolean {
+	const normalized = path.resolve(resolvedPath).toLowerCase();
+
+	const allowedPrefixes: string[] = [];
+
+	// Current process execPath directory (e.g. node installation)
+	try {
+		const execDir = path.dirname(fs.realpathSync.native(process.execPath));
+		allowedPrefixes.push(execDir.toLowerCase());
+		allowedPrefixes.push(path.join(path.dirname(execDir), "lib", "node_modules").toLowerCase());
+	} catch {
+		/* ignore */
+	}
+
+	// npm global bin via APPDATA
+	if (process.env.APPDATA) {
+		allowedPrefixes.push(path.join(process.env.APPDATA, "npm").toLowerCase());
+	}
+
+	const npmPrefix = process.env.npm_config_prefix ?? process.env.NPM_CONFIG_PREFIX;
+	if (npmPrefix) {
+		allowedPrefixes.push(path.resolve(npmPrefix).toLowerCase());
+		allowedPrefixes.push(path.join(path.resolve(npmPrefix), "lib", "node_modules").toLowerCase());
+	}
+
+	// Project-local node_modules/.bin
+	try {
+		const projectBin = path.resolve("node_modules", ".bin");
+		allowedPrefixes.push(projectBin.toLowerCase());
+	} catch {
+		/* ignore */
+	}
+
+	// User home npm-global
+	try {
+		const homeNpm = path.join(os.homedir(), ".npm-global", "bin");
+		allowedPrefixes.push(homeNpm.toLowerCase());
+	} catch {
+		/* ignore */
+	}
+
+	// User home .local/bin
+	try {
+		const homeLocal = path.join(os.homedir(), ".local", "bin");
+		allowedPrefixes.push(homeLocal.toLowerCase());
+	} catch {
+		/* ignore */
+	}
+
+	return allowedPrefixes.some((prefix) => normalized.startsWith(prefix));
+}
+
+function resolvePiPackageRoot(): string | undefined {
+	try {
+		const entry = process.argv[1];
+		if (!entry) return undefined;
+		let dir = path.dirname(fs.realpathSync(entry));
+		while (dir !== path.dirname(dir)) {
+			try {
+				const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8")) as { name?: string };
+				if (pkg.name && PI_PACKAGE_NAMES.includes(pkg.name)) return dir;
+			} catch {
+				// Continue walking upward.
+			}
+			dir = path.dirname(dir);
+		}
+	} catch {
+		return undefined;
+	}
+	return undefined;
+}
+
+function packageBinScript(packageJsonPath: string): string | undefined {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as {
+			bin?: string | Record<string, string>;
+		};
+		const binPath = typeof pkg.bin === "string" ? pkg.bin : (pkg.bin?.pi ?? Object.values(pkg.bin ?? {})[0]);
+		if (!binPath) return undefined;
+		const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
+		return isRunnableNodeScript(candidate) ? candidate : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function findPiPackageJsonFrom(startDir: string): string | undefined {
+	let dir = startDir;
+	while (dir !== path.dirname(dir)) {
+		const direct = path.join(dir, "package.json");
+		try {
+			const pkg = JSON.parse(fs.readFileSync(direct, "utf-8")) as {
+				name?: string;
+			};
+			if (pkg.name && PI_PACKAGE_NAMES.includes(pkg.name)) return direct;
+		} catch {
+			// Continue searching upward and in node_modules.
+		}
+		for (const pkgName of PI_PACKAGE_NAMES) {
+			const [scope, name] = pkgName.replace("@", "").split("/");
+			const dependency = path.join(dir, "node_modules", `@${scope}`, name, "package.json");
+			if (fs.existsSync(dependency)) return dependency;
+		}
+		dir = path.dirname(dir);
+	}
+	return undefined;
+}
+
+/**
+ * Discover the real npm global node_modules directory at runtime.
+ *
+ * Why this exists (Issue #33): on Windows, pi may be installed somewhere
+ * other than %APPDATA%\npm — e.g. nvm-windows puts the global node_modules
+ * under %NVM_HOME%/<version>/node_modules, Volta under
+ * %LOCALAPPDATA%\Volta, fnm under %LOCALAPPDATA%\fnm_multishells. The static
+ * %APPDATA%\npm paths in resolvePiCliScript() miss all of those, and the
+ * fallback spawn("pi") then fails with ENOENT because child_process.spawn does
+ * NOT do PATHEXT resolution on Windows (only exec/execSync via cmd.exe do).
+ *
+ * `npm root -g` is the canonical way to find the global node_modules dir and
+ * works across every npm-based install layout. We run it via execSync, which
+ * DOES resolve `npm.cmd` through PATHEXT. Capped at 5s; any failure (npm not
+ * on PATH, slow start, etc.) just falls through to the other resolution roots.
+ *
+ * Memoized: the npm global root does not change during a process lifetime, so
+ * this is a one-time ~200ms cost rather than per-worker.
+ *
+ * @internal — exported for unit-test injection via __setNpmGlobalRootForTest.
+ */
+let cachedNpmGlobalRoot: string | undefined | null = null;
+export function resolveNpmGlobalRoot(): string | undefined {
+	if (cachedNpmGlobalRoot !== null) {
+		return cachedNpmGlobalRoot ?? undefined;
+	}
+	let resolved: string | undefined;
+	try {
+		const out = execSync("npm root -g", {
+			encoding: "utf-8",
+			timeout: 5000,
+			stdio: ["pipe", "pipe", "pipe"], // suppress npm's stderr chatter
+			windowsHide: true,
+		}).trim();
+		resolved = out.length > 0 ? out : undefined;
+	} catch {
+		resolved = undefined;
+	}
+	cachedNpmGlobalRoot = resolved ?? null;
+	return resolved;
+}
+
+/**
+ * Given an npm global node_modules root, derive the candidate package dirs for
+ * each supported pi scope. Pure + exported so the mapping is unit-testable
+ * without spawning npm.
+ * @internal
+ */
+export function buildNpmGlobalPackageDirs(npmGlobalRoot: string): string[] {
+	return PI_PACKAGE_NAMES.map((pkgName) => path.join(npmGlobalRoot, ...pkgName.split("/")));
+}
+
+/** @internal — test hook: inject a fake global root (or undefined) and reset the memo. */
+export function __setNpmGlobalRootForTest(root: string | undefined): void {
+	cachedNpmGlobalRoot = root ?? null;
+}
+
+function resolvePiCliScript(): string | undefined {
+	const argv1 = process.argv[1];
+	if (argv1) {
+		const argvPath = path.isAbsolute(argv1) ? argv1 : path.resolve(argv1);
+		// Only trust argv1 if we can confirm the current process is running from
+		// the pi-coding-agent package directory. Otherwise, when pi-crew is invoked
+		// from a standalone test script (process.argv[1] = test script path),
+		// resolvePiCliScript would incorrectly return the test script as the pi
+		// CLI. resolvePiPackageRoot walks up from argv1 looking for a package.json
+		// named @earendil-works/pi-coding-agent or @mariozechner/pi-coding-agent.
+		if (resolvePiPackageRoot() && isRunnableNodeScript(argvPath)) return argvPath;
+	}
+
+	// npm-global package dirs derived from `npm root -g` — placed BEFORE the
+	// %APPDATA%\npm static paths and the cwd/import.meta fallbacks so that a pi
+	// install under nvm-windows / Volta / fnm is found even when %APPDATA%\npm
+	// doesn't contain it. Covers Issue #33.
+	const npmGlobalRoot = resolveNpmGlobalRoot();
+	const npmGlobalDirs = npmGlobalRoot ? buildNpmGlobalPackageDirs(npmGlobalRoot) : [];
+
+	const roots = [
+		resolvePiPackageRoot(),
+		...npmGlobalDirs,
+		process.env.APPDATA ? path.join(process.env.APPDATA, "npm", "node_modules", "@earendil-works", "pi-coding-agent") : undefined,
+		process.env.APPDATA ? path.join(process.env.APPDATA, "npm", "node_modules", "@mariozechner", "pi-coding-agent") : undefined,
+		path.dirname(fileURLToPath(import.meta.url)),
+		process.cwd(),
+	].filter((entry): entry is string => Boolean(entry));
+
+	for (const root of roots) {
+		const packageJsonPath = root.endsWith("package.json") ? root : (findPiPackageJsonFrom(root) ?? path.join(root, "package.json"));
+		const script = packageBinScript(packageJsonPath);
+		if (script) return script;
+	}
+	return undefined;
+}
+
+function validateExplicitBin(explicit: string): string | undefined {
+	const resolved = path.resolve(explicit);
+	if (!fs.existsSync(resolved)) return undefined;
+	// Reject paths outside allowed safe prefixes
+	if (!isWithinAllowedPrefixes(resolved)) {
+		throw new Error(
+			`PI_TEAMS_PI_BIN path '${resolved}' is outside allowed prefixes. ` +
+				`Allowed: npm global bin, project node_modules/.bin, APPDATA/npm, or process execPath directory.`,
+		);
+	}
+	// Reject if symlink points outside expected directories
+	try {
+		const real = fs.realpathSync(resolved);
+		if (!isWithinAllowedPrefixes(real)) {
+			throw new Error(`PI_TEAMS_PI_BIN symlink target '${real}' is outside allowed prefixes.`);
+		}
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("allowed prefixes")) throw e;
+		console.error("[pi-spawn] validateExplicitBin: unexpected realpathSync error:", e);
+		return undefined;
+	}
+	return resolved;
+}
+
+export function getPiSpawnCommand(args: string[]): PiSpawnCommand {
+	const explicit = process.env.PI_TEAMS_PI_BIN?.trim();
+	if (explicit) {
+		const validated = validateExplicitBin(explicit);
+		if (validated) {
+			if (isRunnableNodeScript(validated))
+				return {
+					command: process.execPath,
+					args: [validated, ...args],
+				};
+			return { command: validated, args };
+		}
+	}
+	if (process.platform === "win32") {
+		// Windows: resolve via resolvePiCliScript to find the bundled .js entry point
+		const script = resolvePiCliScript();
+		if (script) return { command: process.execPath, args: [script, ...args] };
+	}
+	// Linux/macOS: also resolve the full path so child processes can find 'pi' even if
+	// PATH is minimal (e.g. in detached background-runner processes). Fall back to "pi"
+	// only if resolution fails.
+	const script = resolvePiCliScript();
+	if (script) return { command: process.execPath, args: [script, ...args] };
+	return { command: "pi", args };
+}