@ferris1225/pi-subagents 4.3.4 → 4.3.5

package/src/{worktree.ts → isolation/worktree.ts}

@@ -8,10 +8,17 @@
  * Failed integration deliberately retains both the worktree and patch.
  */
 
-import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync, symlinkSync } from "node:fs";
 import { copyFile, mkdir, mkdtemp, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import {
+	GIT_COMMAND_TIMEOUT_MS,
+	GIT_OUTPUT_MAX_BYTES,
+	runCommand,
+	type CommandResult,
+	type CommandRunner,
+	WORKTREE_PATCH_MAX_BYTES,
+} from "./git-command.ts";
 import { writeTempOwnerMarker } from "./temp-hygiene.ts";
 
 export type IsolationMode = "shared" | "worktree";
@@ -28,151 +35,6 @@ export function worktreeGroupId(worktree: Pick<WorktreeIsolation, "tempDir">): s
 		: base;
 }
 
-export interface CommandRunOptions {
-	cwd: string;
-	input?: Buffer;
-	signal?: AbortSignal;
-	timeoutMs?: number;
-	maxOutputBytes?: number;
-	/** Extra environment entries merged over the inherited environment. */
-	env?: Record<string, string>;
-}
-
-export interface CommandResult {
-	code: number;
-	stdout: Buffer;
-	stderr: Buffer;
-}
-
-/** Injectable, shell-free command runner used by every Git operation. */
-export type CommandRunner = (
-	command: string,
-	args: readonly string[],
-	options: CommandRunOptions,
-) => Promise<CommandResult>;
-
-export const GIT_COMMAND_TIMEOUT_MS = 120_000;
-export const GIT_COMMAND_KILL_GRACE_MS = 2_000;
-export const GIT_OUTPUT_MAX_BYTES = 64 * 1024 * 1024;
-export const WORKTREE_PATCH_MAX_BYTES = GIT_OUTPUT_MAX_BYTES;
-
-/** Git apply validates and writes in one process. The repository lane
- * (thread-lifecycle) already serializes every finalize against all writers of
- * the same canonical checkout, so applies never race each other here. */
-function terminateCommandTree(child: ChildProcess, force: boolean, processGroup: boolean): void {
-	if (process.platform === "win32" && child.pid !== undefined) {
-		const fallback = (): void => {
-			try {
-				child.kill(force ? "SIGKILL" : "SIGTERM");
-			} catch {
-				/* process may already be gone */
-			}
-		};
-		const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
-			stdio: "ignore",
-			windowsHide: true,
-		});
-		killer.once("error", fallback);
-		killer.once("close", (code) => {
-			if (code !== 0) fallback();
-		});
-		return;
-	}
-	try {
-		if (processGroup && child.pid !== undefined) {
-			process.kill(-child.pid, force ? "SIGKILL" : "SIGTERM");
-		} else {
-			child.kill(force ? "SIGKILL" : "SIGTERM");
-		}
-	} catch {
-		/* process may already be gone */
-	}
-}
-
-/** Default argument-safe runner. Output is bounded before binary patches enter
- * memory, and timeout/abort terminates the complete checkout-filter process tree. */
-export const runCommand: CommandRunner = (command, args, options) =>
-	new Promise<CommandResult>((resolveResult, reject) => {
-		if (options.signal?.aborted) {
-			reject(new Error(`Command aborted before start: ${command}`));
-			return;
-		}
-		const usePosixProcessGroup = process.platform !== "win32";
-		const child = spawn(command, [...args], {
-			cwd: options.cwd,
-			shell: false,
-			windowsHide: true,
-			stdio: ["pipe", "pipe", "pipe"],
-			detached: usePosixProcessGroup,
-			...(options.env ? { env: { ...process.env, ...options.env } } : {}),
-		});
-		const stdout: Buffer[] = [];
-		const stderr: Buffer[] = [];
-		const maxOutputBytes = options.maxOutputBytes ?? GIT_OUTPUT_MAX_BYTES;
-		let outputBytes = 0;
-		let finished = false;
-		let failure: Error | undefined;
-		let timeout: ReturnType<typeof setTimeout> | undefined;
-		let forceKillTimer: ReturnType<typeof setTimeout> | undefined;
-
-		const terminate = (): void => {
-			terminateCommandTree(child, false, usePosixProcessGroup);
-			if (!forceKillTimer) {
-				forceKillTimer = setTimeout(
-					() => terminateCommandTree(child, true, usePosixProcessGroup),
-					GIT_COMMAND_KILL_GRACE_MS,
-				);
-				if (typeof forceKillTimer.unref === "function") forceKillTimer.unref();
-			}
-		};
-		const fail = (error: Error): void => {
-			if (failure || finished) return;
-			failure = error;
-			terminate();
-		};
-		const append = (target: Buffer[], chunk: Buffer | string): void => {
-			if (failure || finished) return;
-			const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-			outputBytes += value.length;
-			if (outputBytes > maxOutputBytes) {
-				fail(new Error(`Command output exceeded ${maxOutputBytes} bytes: ${command}`));
-				return;
-			}
-			target.push(value);
-		};
-		const onAbort = (): void => fail(new Error(`Command aborted: ${command}`));
-		options.signal?.addEventListener("abort", onAbort, { once: true });
-		if (options.timeoutMs !== undefined && options.timeoutMs > 0) {
-			timeout = setTimeout(
-				() => fail(new Error(`Command timed out after ${options.timeoutMs}ms: ${command}`)),
-				options.timeoutMs,
-			);
-			if (typeof timeout.unref === "function") timeout.unref();
-		}
-
-		child.stdout?.on("data", (chunk: Buffer | string) => append(stdout, chunk));
-		child.stderr?.on("data", (chunk: Buffer | string) => append(stderr, chunk));
-		child.once("error", (error) => fail(error));
-		child.once("close", (code) => {
-			if (finished) return;
-			finished = true;
-			if (timeout) clearTimeout(timeout);
-			if (forceKillTimer) clearTimeout(forceKillTimer);
-			options.signal?.removeEventListener("abort", onAbort);
-			if (failure) {
-				reject(failure);
-				return;
-			}
-			resolveResult({
-				code: code ?? 1,
-				stdout: Buffer.concat(stdout),
-				stderr: Buffer.concat(stderr),
-			});
-		});
-		child.stdin?.once("error", () => undefined);
-		child.stdin?.end(options.input);
-	});
-
 export interface WorktreeTarget {
 	/** Canonical cwd requested by the caller. */
 	originalCwd: string;
@@ -663,7 +525,8 @@ class GitWorktreeIsolation implements WorktreeIsolation {
 	 * that index, so everything runs against a private copy of the checkout's
 	 * index: the copy first absorbs the current unstaged state (`add -A`),
 	 * making the working tree "ours" of the merge, and the user's real staged
-	 * state is never touched. */
+	 * state is never touched. The repository lane serializes finalization, and
+	 * each `git apply` validates and writes in one process. */
 	private async applyPatchThreeWay(): Promise<boolean> {
 		const indexCopy = join(this.tempDir, "apply-index");
 		try {

package/src/{completion.ts → lifecycle/completion.ts}

@@ -7,8 +7,8 @@
  * failure directly so it is never delayed.
  */
 
-import { formatUsageCompact, sumUsage, type RunWaitReason } from "./monitor.ts";
-import type { UsageStats } from "./rpc-run.ts";
+import { formatUsageCompact, sumUsage, type RunWaitReason } from "../presentation/monitor.ts";
+import type { UsageStats } from "../execution/rpc-control.ts";
 
 export interface CompletionBatchTimings {
 	debounceMs: number;

package/src/{durable.ts → lifecycle/durable.ts}

@@ -18,9 +18,9 @@ import { existsSync, type Dirent, readdirSync, statSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { uptime } from "node:os";
 import { dirname, join } from "node:path";
-import type { UsageStats } from "./rpc-run.ts";
+import type { UsageStats } from "../execution/rpc-control.ts";
 import type { SubagentThread } from "./runtime.ts";
-import { getResultOutput, isFailedResult, getProjectRoot, getSubagentsRoot, type SingleResult } from "./spawn.ts";
+import { getResultOutput, isFailedResult, getProjectRoot, getSubagentsRoot, type SingleResult } from "../execution/spawn.ts";
 import {
 	isPathInside,
 	restoreWorktreeIsolation,
@@ -28,7 +28,7 @@ import {
 	normalizeWorktreeSnapshot,
 	worktreeSnapshot,
 	type WorktreeSnapshot,
-} from "./worktree.ts";
+} from "../isolation/worktree.ts";
 
 export const THREADS_MANIFEST_FILE_NAME = "pi-subagents-threads.json";
 const THREADS_MANIFEST_VERSION = 1;

package/src/{runtime.ts → lifecycle/runtime.ts}

@@ -10,7 +10,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { rmSync } from "node:fs";
-import { resolveSubagentConcurrency, BackgroundTaskQueue } from "./background.ts";
+import { resolveSubagentConcurrency, BackgroundTaskQueue } from "../execution/background.ts";
 import {
 	createCompletionBatcher,
 	formatActiveRunsFooter,
@@ -18,13 +18,13 @@ import {
 	type CompletionBatcher,
 	type CompletionMessageItem,
 } from "./completion.ts";
-import { type ThinkingLevel } from "./config.ts";
+import { type ThinkingLevel } from "../configuration/config.ts";
 import { removeThreadRecord, threadRecordFromThread, upsertThreadRecord, type ThreadRecord } from "./durable.ts";
-import { isRunActiveStatus, monitor } from "./monitor.ts";
-import type { RpcRunControl } from "./rpc-run.ts";
-import type { StartBackgroundInternal } from "./thread-lifecycle.ts";
-import { isFailedResult, type SingleResult } from "./spawn.ts";
-import type { IsolationMode, WorktreeFinalization, WorktreeIsolation } from "./worktree.ts";
+import { isRunActiveStatus, monitor } from "../presentation/monitor.ts";
+import type { RpcRunControl } from "../execution/rpc-control.ts";
+import type { StartBackgroundInternal } from "./thread-shared.ts";
+import { isFailedResult, type SingleResult } from "../execution/spawn.ts";
+import type { IsolationMode, WorktreeFinalization, WorktreeIsolation } from "../isolation/worktree.ts";
 
 export type ThreadState =
 	| "queued"