@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/runs/shared/worktree-hook.ts

@@ -1,181 +0,0 @@
-import { errorMessage, isRecord, isUnknownArray } from "../../shared/unknown.ts";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { runSetupCommand } from "./worktree-process.ts";
-
-export const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30_000;
-export interface WorktreeSetupHookConfig {
-  readonly hookPath: string;
-  readonly timeoutMs?: number;
-}
-export interface ResolvedWorktreeSetupHook {
-  readonly hookPath: string;
-  readonly timeoutMs: number;
-}
-export interface WorktreeSetupHookInput {
-  readonly version: 1;
-  readonly repoRoot: string;
-  readonly worktreePath: string;
-  readonly agentCwd: string;
-  readonly branch: string;
-  readonly index: number;
-  readonly runId: string;
-  readonly baseCommit: string;
-  readonly agent?: string;
-}
-
-function parseHookTimeout(timeoutMs: number | undefined): number {
-  if (timeoutMs === undefined) {
-    return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
-  }
-  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-    throw new Error("worktree setup hook timeout must be an integer greater than 0");
-  }
-  return timeoutMs;
-}
-
-export function resolveWorktreeSetupHook(
-  repoRoot: string,
-  config: WorktreeSetupHookConfig | undefined,
-): ResolvedWorktreeSetupHook | undefined {
-  if (!config) {
-    return undefined;
-  }
-  const hookPath = config.hookPath.trim();
-  if (hookPath.length === 0) {
-    throw new Error("worktree setup hook path cannot be empty");
-  }
-  const expandedHookPath = hookPath.startsWith("~/")
-    ? path.join(os.homedir(), hookPath.slice(2))
-    : hookPath;
-  let resolvedPath: string;
-  if (path.isAbsolute(expandedHookPath)) {
-    resolvedPath = expandedHookPath;
-  } else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
-    resolvedPath = path.resolve(repoRoot, expandedHookPath);
-  } else {
-    throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
-  }
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(`worktree setup hook not found: ${resolvedPath}`);
-  }
-  if (fs.statSync(resolvedPath).isDirectory()) {
-    throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
-  }
-  return { hookPath: resolvedPath, timeoutMs: parseHookTimeout(config.timeoutMs) };
-}
-
-function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
-  const trimmed = rawPath.trim();
-  if (trimmed.length === 0) {
-    throw new Error("synthetic path cannot be empty");
-  }
-  if (path.isAbsolute(trimmed)) {
-    throw new Error(`synthetic path must be relative: ${rawPath}`);
-  }
-  const relative = path.relative(worktreePath, path.resolve(worktreePath, trimmed));
-  if (relative.length === 0 || relative === ".") {
-    throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
-  }
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
-  }
-  return path.normalize(relative);
-}
-
-function requirePathStrings(paths: unknown): readonly string[] {
-  if (!isUnknownArray(paths)) {
-    throw new Error(
-      "worktree setup hook output field 'syntheticPaths' must be an array of relative paths",
-    );
-  }
-  const result: string[] = [];
-  for (const candidate of paths) {
-    if (typeof candidate !== "string") {
-      throw new Error(
-        "worktree setup hook output field 'syntheticPaths' must contain only strings",
-      );
-    }
-    result.push(candidate);
-  }
-  return result;
-}
-
-function parseSyntheticPaths(rawStdout: string): readonly string[] {
-  const trimmed = rawStdout.trim();
-  if (trimmed.length === 0) {
-    throw new Error("worktree setup hook returned empty stdout; expected JSON object");
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (error) {
-    const message = errorMessage(error);
-    throw new Error(`worktree setup hook returned invalid JSON: ${message}`, { cause: error });
-  }
-  if (!isRecord(parsed)) {
-    throw new Error("worktree setup hook stdout must be a JSON object");
-  }
-  if (!("syntheticPaths" in parsed) || parsed.syntheticPaths === undefined) {
-    return [];
-  }
-  return requirePathStrings(parsed.syntheticPaths);
-}
-
-/** Validates hook-declared scratch paths against Git before granting cleanup authority. */
-async function validateSyntheticPaths(
-  input: WorktreeSetupHookInput,
-  paths: readonly string[],
-  signal?: AbortSignal,
-): Promise<string[]> {
-  const uniquePaths = new Set<string>();
-  for (const candidate of paths) {
-    const normalizedPath = normalizeSyntheticPath(input.worktreePath, candidate);
-    // Keep Git queries ordered and stop before granting authority to another path on cancellation.
-    // oxlint-disable-next-line no-await-in-loop
-    const result = await runSetupCommand({
-      command: "git",
-      args: ["-C", input.worktreePath, "ls-files", "--", normalizedPath],
-      cwd: input.worktreePath,
-      signal,
-    });
-    if (result.status === 0 && result.stdout.trim().length > 0) {
-      throw new Error(
-        `worktree setup hook cannot mark tracked paths as synthetic: ${normalizedPath}`,
-      );
-    }
-    uniquePaths.add(normalizedPath);
-  }
-  return [...uniquePaths];
-}
-
-export async function runWorktreeSetupHook(
-  hook: ResolvedWorktreeSetupHook,
-  input: WorktreeSetupHookInput,
-  signal?: AbortSignal,
-): Promise<string[]> {
-  let result;
-  try {
-    result = await runSetupCommand({
-      command: hook.hookPath,
-      args: [],
-      cwd: input.worktreePath,
-      signal,
-      input: JSON.stringify(input),
-      timeoutMs: hook.timeoutMs,
-    });
-  } catch (error) {
-    signal?.throwIfAborted();
-    const message = errorMessage(error);
-    throw new Error(`worktree setup hook failed: ${message}`, { cause: error });
-  }
-  if (result.status !== 0) {
-    const details =
-      [result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ?? "no output";
-    throw new Error(
-      `worktree setup hook failed with exit code ${String(result.status)}: ${details}`,
-    );
-  }
-  return validateSyntheticPaths(input, parseSyntheticPaths(result.stdout), signal);
-}

package/src/runs/shared/worktree-location.ts

@@ -1,61 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { TEMP_ROOT_DIR } from "../../shared/types.ts";
-import { runGit, runGitChecked } from "./worktree-process.ts";
-
-interface WorktreeTaskCwdConflict {
-  readonly index: number;
-  readonly agent: string;
-  readonly cwd: string;
-}
-function normalizeComparableCwd(cwd: string): string {
-  const resolved = path.resolve(cwd);
-  try {
-    return fs.realpathSync(resolved);
-  } catch {
-    return resolved;
-  } // Missing paths are still compared as absolute paths.
-}
-
-export function findWorktreeTaskCwdConflict(
-  tasks: readonly { readonly agent: string; readonly cwd?: string }[],
-  sharedCwd: string,
-): WorktreeTaskCwdConflict | undefined {
-  const normalizedSharedCwd = normalizeComparableCwd(sharedCwd);
-  for (const [index, task] of tasks.entries()) {
-    if (task.cwd === undefined || task.cwd.length === 0) {
-      continue;
-    }
-    const taskCwd = path.isAbsolute(task.cwd) ? task.cwd : path.resolve(sharedCwd, task.cwd);
-    if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd) {
-      continue;
-    }
-    return { index, agent: task.agent, cwd: task.cwd };
-  }
-  return undefined;
-}
-
-export function formatWorktreeTaskCwdConflict(
-  conflict: WorktreeTaskCwdConflict,
-  sharedCwd: string,
-): string {
-  return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
-}
-export function buildWorktreeBranch(runId: string, index: number): string {
-  return `pi-parallel-${runId}-${index}`;
-}
-export function buildWorktreePath(runId: string, index: number): string {
-  return path.join(TEMP_ROOT_DIR, "worktrees", `pi-worktree-${runId}-${index}`);
-}
-
-export function resolveExpectedWorktreeAgentCwd(cwd: string, runId: string, index: number): string {
-  const repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-  if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
-    throw new Error("worktree isolation requires a git repository");
-  }
-  const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-  const normalized = rawPrefix.length > 0 ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
-  const cwdRelative = normalized === "." ? "" : normalized;
-  const worktreePath = buildWorktreePath(runId, index);
-  return cwdRelative.length > 0 ? path.join(worktreePath, cwdRelative) : worktreePath;
-}

package/src/runs/shared/worktree-preservation.ts

@@ -1,10 +0,0 @@
-import type { WorktreeSetup } from "./worktree-contract.ts";
-
-/** Resource owner mutation: failed patch capture must prohibit destructive cleanup. */
-export function markWorktreesForPreservation(setup: WorktreeSetup, reason: string): void {
-  setup.preserveOnCleanup = true;
-  setup.preservationReason =
-    (setup.preservationReason ?? "").length > 0
-      ? `${setup.preservationReason ?? ""}; ${reason}`
-      : reason;
-}

package/src/runs/shared/worktree-process.ts

@@ -1,132 +0,0 @@
-import { hasErrorCode } from "../../shared/unknown.ts";
-import { spawn, spawnSync } from "node:child_process";
-import { addAbortListener } from "node:events";
-import { trySignalChildTree } from "../../shared/post-exit-stdio-guard.ts";
-
-export interface GitResult {
-  readonly stdout: string;
-  readonly stderr: string;
-  readonly status: number | null;
-  readonly error?: Error;
-}
-
-function normalizeGitStream(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
-
-export function runGit(cwd: string, args: readonly string[]): GitResult {
-  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
-  return {
-    stdout: normalizeGitStream(result.stdout),
-    stderr: normalizeGitStream(result.stderr),
-    status: result.status,
-    error: result.error,
-  };
-}
-
-export function runGitChecked(cwd: string, args: readonly string[]): string {
-  const result = runGit(cwd, args);
-  if (result.status !== 0) {
-    const message =
-      [result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ??
-      result.error?.message ??
-      `git -C ${cwd} ${args.join(" ")} failed`;
-    throw new Error(message, { cause: result.error });
-  }
-  return result.stdout;
-}
-
-interface SetupCommand {
-  readonly command: string;
-  readonly args: readonly string[];
-  readonly cwd: string;
-  readonly signal?: AbortSignal;
-  readonly input?: string;
-  readonly timeoutMs?: number;
-}
-
-/** Owns the child, its bounded output, abort listener, and timeout until stdio closes. */
-export function runSetupCommand(options: SetupCommand): Promise<GitResult> {
-  const { command, args, cwd, signal, input, timeoutMs } = options;
-  signal?.throwIfAborted();
-  return new Promise<GitResult>((resolve, reject) => {
-    let stdout = "";
-    let stderr = "";
-    let outputBytes = 0;
-    let failure: Error | undefined;
-    const child = spawn(command, [...args], { cwd, detached: true, stdio: "pipe" });
-    const terminate = () => {
-      trySignalChildTree(child, "SIGKILL");
-    };
-    const abortListener = signal && addAbortListener(signal, terminate);
-    const timer =
-      timeoutMs === undefined
-        ? undefined
-        : setTimeout(() => {
-            failure = new Error(`worktree setup hook timed out after ${timeoutMs}ms`);
-            terminate();
-          }, timeoutMs);
-    timer?.unref();
-    for (const stream of [child.stdout, child.stderr]) {
-      stream.setEncoding("utf8");
-      stream.on("data", (chunk: string) => {
-        outputBytes += Buffer.byteLength(chunk);
-        if (outputBytes > 1024 * 1024) {
-          failure ??= new Error(`${command} output exceeded 1048576 bytes`);
-          terminate();
-        } else if (stream === child.stdout) {
-          stdout += chunk;
-        } else {
-          stderr += chunk;
-        }
-      });
-    }
-    child.on("error", (error) => {
-      failure = error;
-      terminate();
-    });
-    child.on("exit", (status) => {
-      if (status !== 0) {
-        terminate();
-      }
-    });
-    child.on("close", (status) => {
-      clearTimeout(timer);
-      abortListener?.[Symbol.dispose]();
-      if (signal?.aborted === true) {
-        resolve({ stdout, stderr, status });
-      } else if (failure) {
-        reject(failure);
-      } else {
-        resolve({ stdout, stderr, status });
-      }
-    });
-    child.stdin.on("error", (error) => {
-      if (hasErrorCode(error, "EPIPE")) {
-        return;
-      } // The hook may exit without reading its payload.
-      failure = error;
-      terminate();
-    });
-    child.stdin.end(input);
-  }).then((result) => {
-    // AbortSignal.throwIfAborted preserves arbitrary native cancellation reasons.
-    signal?.throwIfAborted();
-    return result;
-  });
-}
-
-export async function runSetupGit(
-  cwd: string,
-  args: readonly string[],
-  signal?: AbortSignal,
-): Promise<string> {
-  const result = await runSetupCommand({ command: "git", args: ["-C", cwd, ...args], cwd, signal });
-  if (result.status !== 0) {
-    throw new Error(
-      [result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ??
-        `git -C ${cwd} ${args.join(" ")} failed`,
-    );
-  }
-  return result.stdout;
-}