pi-subagents 0.68.0 → 0.70.0

package/src/runs/shared/run-fanout-budget.ts

@@ -1,267 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, waitForFileSystemRetry } from "../../shared/file-system-retry.ts";
-import {
-	TEMP_ROOT_DIR,
-	type RunFanoutBudgetDescriptor,
-	type RunFanoutBudgetSnapshot,
-	type RunFanoutRejection,
-} from "../../shared/types.ts";
-
-const RUN_FANOUT_ROOT = path.join(TEMP_ROOT_DIR, "run-fanout-budgets");
-
-interface FanoutBudgetManifest {
-	version: 1;
-	rootRunId: string;
-	limit: number;
-	createdAt: number;
-}
-
-interface FanoutBudgetClaim {
-	version: 1;
-	claimId: string;
-	path: string;
-	claimedAt: number;
-}
-
-export class RunFanoutLimitError extends Error {
-	readonly rejection: RunFanoutRejection;
-	readonly snapshot: RunFanoutBudgetSnapshot;
-
-	constructor(rejection: RunFanoutRejection) {
-		super(formatRunFanoutRejection(rejection));
-		this.name = "RunFanoutLimitError";
-		this.rejection = rejection;
-		this.snapshot = { used: rejection.used, limit: rejection.limit, remaining: rejection.remaining };
-	}
-}
-
-function safeRootRunId(rootRunId: string): string {
-	return rootRunId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || randomUUID();
-}
-
-function parseManifest(value: unknown): FanoutBudgetManifest | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const manifest = value as Partial<FanoutBudgetManifest>;
-	if (manifest.version !== 1 || typeof manifest.rootRunId !== "string" || !manifest.rootRunId
-		|| !Number.isInteger(manifest.limit) || (manifest.limit ?? 0) <= 0
-		|| typeof manifest.createdAt !== "number" || !Number.isFinite(manifest.createdAt)) return undefined;
-	return manifest as FanoutBudgetManifest;
-}
-
-function readManifest(directory: string): FanoutBudgetManifest {
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(fs.readFileSync(path.join(directory, "manifest.json"), "utf-8"));
-	} catch (error) {
-		throw new Error(`Run fan-out budget manifest is unreadable at '${directory}': ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const manifest = parseManifest(parsed);
-	if (!manifest) throw new Error(`Run fan-out budget manifest is invalid at '${directory}'.`);
-	return manifest;
-}
-
-function validateDirectory(directory: string): string {
-	let realDirectory: string;
-	let realRoot: string;
-	try {
-		realDirectory = fs.realpathSync(path.resolve(directory));
-		realRoot = fs.realpathSync(path.resolve(RUN_FANOUT_ROOT));
-	} catch (error) {
-		throw new Error(`Run fan-out budget directory is unavailable: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (realDirectory !== realRoot && !realDirectory.startsWith(`${realRoot}${path.sep}`)) {
-		throw new Error("Run fan-out budget directory resolves outside the managed budget root.");
-	}
-	return realDirectory;
-}
-
-export function createRunFanoutBudget(rootRunId: string, limit: number): RunFanoutBudgetDescriptor {
-	if (!Number.isInteger(limit) || limit <= 0) throw new Error("Run fan-out limit must be a positive integer.");
-	fs.mkdirSync(RUN_FANOUT_ROOT, { recursive: true, mode: 0o700 });
-	let directory: string;
-	do directory = path.join(RUN_FANOUT_ROOT, `${safeRootRunId(rootRunId)}-${randomUUID()}`);
-	while (fs.existsSync(directory));
-	fs.mkdirSync(path.join(directory, "claims"), { recursive: true, mode: 0o700 });
-	const manifest: FanoutBudgetManifest = { version: 1, rootRunId, limit, createdAt: Date.now() };
-	fs.writeFileSync(path.join(directory, "manifest.json"), `${JSON.stringify(manifest)}\n`, { mode: 0o600, flag: "wx" });
-	return { version: 1, rootRunId, directory, limit };
-}
-
-export function validateRunFanoutBudgetDescriptor(value: unknown): RunFanoutBudgetDescriptor {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Run fan-out budget descriptor is missing or invalid.");
-	const descriptor = value as Partial<RunFanoutBudgetDescriptor>;
-	if (descriptor.version !== 1 || typeof descriptor.rootRunId !== "string" || !descriptor.rootRunId
-		|| typeof descriptor.directory !== "string" || !descriptor.directory
-		|| !Number.isInteger(descriptor.limit) || (descriptor.limit ?? 0) <= 0
-		|| (descriptor.parentPath !== undefined && typeof descriptor.parentPath !== "string")) {
-		throw new Error("Run fan-out budget descriptor is invalid.");
-	}
-	const directory = validateDirectory(descriptor.directory);
-	const manifest = readManifest(directory);
-	if (manifest.rootRunId !== descriptor.rootRunId || manifest.limit !== descriptor.limit) {
-		throw new Error("Run fan-out budget descriptor does not match its manifest.");
-	}
-	return { version: 1, rootRunId: descriptor.rootRunId, directory, limit: descriptor.limit, ...(descriptor.parentPath ? { parentPath: descriptor.parentPath } : {}) };
-}
-
-export function writeRunFanoutBudgetDescriptor(asyncDir: string, descriptor: RunFanoutBudgetDescriptor): void {
-	const valid = validateRunFanoutBudgetDescriptor(descriptor);
-	fs.mkdirSync(asyncDir, { recursive: true });
-	fs.writeFileSync(path.join(asyncDir, "run-fanout-budget.json"), `${JSON.stringify(valid)}\n`, { mode: 0o600 });
-}
-
-export function readRunFanoutBudgetDescriptor(asyncDir: string | undefined): RunFanoutBudgetDescriptor | undefined {
-	if (!asyncDir) return undefined;
-	const descriptorPath = path.join(asyncDir, "run-fanout-budget.json");
-	if (!fs.existsSync(descriptorPath)) return undefined;
-	try {
-		return validateRunFanoutBudgetDescriptor(JSON.parse(fs.readFileSync(descriptorPath, "utf-8")));
-	} catch (error) {
-		throw new Error(`Invalid persisted run fan-out budget '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-
-interface AdmissionLockOwner {
-	pid: number;
-	token: string;
-}
-
-const ADMISSION_LOCK_STALE_MS = 60_000;
-
-function readAdmissionLockOwner(lockPath: string): AdmissionLockOwner | undefined {
-	try {
-		const owner = JSON.parse(fs.readFileSync(path.join(lockPath, "owner.json"), "utf-8")) as Partial<AdmissionLockOwner>;
-		if (Number.isSafeInteger(owner.pid) && (owner.pid ?? 0) > 0 && typeof owner.token === "string" && owner.token) return owner as AdmissionLockOwner;
-	} catch {}
-	return undefined;
-}
-
-function admissionLockIsStale(lockPath: string): boolean {
-	const owner = readAdmissionLockOwner(lockPath);
-	if (owner) {
-		try {
-			process.kill(owner.pid, 0);
-			return false;
-		} catch (error) {
-			return (error as NodeJS.ErrnoException).code !== "EPERM";
-		}
-	}
-	try { return Date.now() - fs.statSync(lockPath).mtimeMs > ADMISSION_LOCK_STALE_MS; }
-	catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-		throw error;
-	}
-}
-
-function withAdmissionLock<T>(directory: string, operation: () => T): T {
-	const lockPath = path.join(directory, "admission.lock");
-	const owner: AdmissionLockOwner = { pid: process.pid, token: randomUUID() };
-	for (let attempt = 0; ; attempt++) {
-		try {
-			fs.mkdirSync(lockPath, { mode: 0o700 });
-			try { fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { mode: 0o600 }); }
-			catch (error) {
-				fs.rmSync(lockPath, { recursive: true, force: true });
-				throw error;
-			}
-			break;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-			if (admissionLockIsStale(lockPath)) {
-				const stalePath = path.join(directory, `admission.stale-${randomUUID()}`);
-				try {
-					fs.renameSync(lockPath, stalePath);
-					fs.rmSync(stalePath, { recursive: true, force: true });
-					continue;
-				} catch (reclaimError) {
-					if ((reclaimError as NodeJS.ErrnoException).code !== "ENOENT") throw reclaimError;
-				}
-			}
-			const delay = DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt];
-			if (delay === undefined) throw new Error(`Timed out acquiring run fan-out admission lock at '${directory}'.`);
-			waitForFileSystemRetry(delay);
-		}
-	}
-	try { return operation(); }
-	finally {
-		if (readAdmissionLockOwner(lockPath)?.token === owner.token) fs.rmSync(lockPath, { recursive: true, force: true });
-	}
-}
-
-function claimCount(directory: string): number {
-	const claimsDir = path.join(directory, "claims");
-	let entries: fs.Dirent[];
-	try { entries = fs.readdirSync(claimsDir, { withFileTypes: true }); }
-	catch (error) {
-		throw new Error(`Run fan-out claims directory is unreadable at '${claimsDir}': ${error instanceof Error ? error.message : String(error)}`);
-	}
-	return entries.filter((entry) => /^\d{6}\.json$/.test(entry.name)).length;
-}
-
-export function getRunFanoutBudgetSnapshot(descriptor: RunFanoutBudgetDescriptor): RunFanoutBudgetSnapshot {
-	const valid = validateRunFanoutBudgetDescriptor(descriptor);
-	const used = claimCount(valid.directory);
-	return { used, limit: valid.limit, remaining: Math.max(0, valid.limit - used) };
-}
-
-function qualifyRunFanoutPaths(descriptor: RunFanoutBudgetDescriptor, paths: string[]): string[] {
-	const prefix = descriptor.parentPath?.trim();
-	return paths.map((item) => prefix ? `${prefix}/${item}` : item);
-}
-
-function commitRunFanoutBatch<T>(descriptor: RunFanoutBudgetDescriptor, paths: string[], commit: (snapshot: RunFanoutBudgetSnapshot) => T): T {
-	const valid = validateRunFanoutBudgetDescriptor(descriptor);
-	if (paths.length === 0) return commit(getRunFanoutBudgetSnapshot(valid));
-	const qualified = qualifyRunFanoutPaths(valid, paths);
-	return withAdmissionLock(valid.directory, () => {
-		const before = getRunFanoutBudgetSnapshot(valid);
-		if (qualified.length > before.remaining) {
-			throw new RunFanoutLimitError({ code: "RUN_FANOUT_LIMIT", path: qualified[before.remaining] ?? qualified[0]!, requested: qualified.length, ...before });
-		}
-		const created: string[] = [];
-		try {
-			for (const claimPath of qualified) {
-				for (let slot = 0; slot < valid.limit; slot++) {
-					const slotPath = path.join(valid.directory, "claims", `${String(slot).padStart(6, "0")}.json`);
-					try {
-						const fd = fs.openSync(slotPath, "wx", 0o600);
-						created.push(slotPath);
-						try {
-							const claim: FanoutBudgetClaim = { version: 1, claimId: randomUUID(), path: claimPath, claimedAt: Date.now() };
-							fs.writeFileSync(fd, `${JSON.stringify(claim)}\n`, "utf-8");
-						} finally { fs.closeSync(fd); }
-						break;
-					} catch (error) {
-						if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;
-						throw error;
-					}
-				}
-			}
-			return commit(getRunFanoutBudgetSnapshot(valid));
-		} catch (error) {
-			for (const slotPath of created) {
-				try { fs.unlinkSync(slotPath); } catch {}
-			}
-			throw error;
-		}
-	});
-}
-
-export function claimRunFanoutBatch(descriptor: RunFanoutBudgetDescriptor, paths: string[]): RunFanoutBudgetSnapshot {
-	return commitRunFanoutBatch(descriptor, paths, (snapshot) => snapshot);
-}
-
-export function claimRunFanoutBatchWithCommit<T>(descriptor: RunFanoutBudgetDescriptor, paths: string[], commit: () => T): T {
-	return commitRunFanoutBatch(descriptor, paths, commit);
-}
-
-export function formatRunFanoutBudget(snapshot: RunFanoutBudgetSnapshot): string {
-	return `Run fan-out: ${snapshot.used}/${snapshot.limit} used, ${snapshot.remaining} remaining`;
-}
-
-function formatRunFanoutRejection(rejection: RunFanoutRejection): string {
-	return `Run fan-out limit reached at ${rejection.path} (${rejection.used}/${rejection.limit} used; ${rejection.requested} requested, ${rejection.remaining} remaining). No children from this admission group were started. Start a new top-level run or raise config.maxSubagentSpawnsPerRun.`;
-}

package/src/runs/shared/run-history.ts

@@ -1,201 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getAgentDir } from "../../shared/utils.ts";
-import { isUnexplainedProcessSignal } from "./process-signal.ts";
-
-export type RunOutcome = "completed" | "failed" | "timed_out" | "stopped" | "interrupted";
-
-export interface RunEntry {
-	agent: string;
-	task: string;
-	taskHash?: string;
-	ts: number;
-	status: "ok" | "error";
-	outcome?: RunOutcome;
-	duration: number;
-	exit?: number;
-}
-
-const ROTATE_READ_THRESHOLD = 1200;
-const ROTATE_KEEP = 1000;
-const PRIVATE_DIR_MODE = 0o700;
-const PRIVATE_FILE_MODE = 0o600;
-const REDACTED_TASK = "[redacted]";
-const historyFileStates = new Map<string, { mtimeMs: number; ctimeMs: number; size: number; ino: number; lineCount: number }>();
-
-function getHistoryPath(): string {
-	return path.join(getAgentDir(), "run-history.jsonl");
-}
-
-function hashTask(task: string): string {
-	return createHash("sha256").update(task).digest("hex");
-}
-
-function hardenHistoryStorage(historyPath: string): void {
-	const historyDir = path.dirname(historyPath);
-	fs.mkdirSync(historyDir, { recursive: true, mode: PRIVATE_DIR_MODE });
-	try {
-		if ((fs.statSync(historyDir).mode & 0o777) !== PRIVATE_DIR_MODE) fs.chmodSync(historyDir, PRIVATE_DIR_MODE);
-	} catch {}
-	try {
-		if ((fs.statSync(historyPath).mode & 0o777) !== PRIVATE_FILE_MODE) fs.chmodSync(historyPath, PRIVATE_FILE_MODE);
-	} catch {}
-}
-
-function sanitizeHistoryLine(line: string): string | undefined {
-	let value: unknown;
-	try {
-		value = JSON.parse(line);
-	} catch {
-		return undefined;
-	}
-	if (!value || typeof value !== "object") return undefined;
-
-	const record = value as Record<string, unknown>;
-	const task = typeof record.task === "string" ? record.task : "";
-	const taskHash = typeof record.taskHash === "string" && record.taskHash
-		? record.taskHash
-		: task && task !== REDACTED_TASK
-			? hashTask(task)
-			: undefined;
-
-	return JSON.stringify({
-		...record,
-		task: REDACTED_TASK,
-		...(taskHash ? { taskHash } : {}),
-	});
-}
-
-function sanitizeHistoryLines(raw: string): { lines: string[]; changed: boolean } {
-	const lines: string[] = [];
-	let changed = false;
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		const sanitized = sanitizeHistoryLine(trimmed);
-		if (!sanitized) {
-			changed = true;
-			continue;
-		}
-		if (sanitized !== trimmed) changed = true;
-		lines.push(sanitized);
-	}
-	return { lines, changed };
-}
-
-function writePrivateHistory(historyPath: string, lines: string[]): void {
-	fs.writeFileSync(historyPath, lines.length ? `${lines.join("\n")}\n` : "", { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
-	try { fs.chmodSync(historyPath, PRIVATE_FILE_MODE); } catch {}
-}
-
-function rememberHistoryFile(historyPath: string, lineCount: number): void {
-	const stat = fs.statSync(historyPath);
-	historyFileStates.set(historyPath, {
-		mtimeMs: stat.mtimeMs,
-		ctimeMs: stat.ctimeMs,
-		size: stat.size,
-		ino: stat.ino,
-		lineCount,
-	});
-	if (historyFileStates.size > 8) historyFileStates.delete(historyFileStates.keys().next().value!);
-}
-
-function sanitizeHistoryFile(historyPath: string): number {
-	let stat: fs.Stats;
-	try {
-		stat = fs.statSync(historyPath);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return 0;
-		throw error;
-	}
-	const cached = historyFileStates.get(historyPath);
-	if (cached
-		&& cached.mtimeMs === stat.mtimeMs
-		&& cached.ctimeMs === stat.ctimeMs
-		&& cached.size === stat.size
-		&& cached.ino === stat.ino) {
-		return cached.lineCount;
-	}
-	const raw = fs.readFileSync(historyPath, "utf-8");
-	const { lines, changed } = sanitizeHistoryLines(raw);
-	if (changed) writePrivateHistory(historyPath, lines);
-	rememberHistoryFile(historyPath, lines.length);
-	return lines.length;
-}
-
-function appendPrivateHistoryLine(historyPath: string, line: string): void {
-	const fd = fs.openSync(historyPath, fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_WRONLY, PRIVATE_FILE_MODE);
-	try {
-		fs.writeSync(fd, `${line}\n`);
-	} finally {
-		fs.closeSync(fd);
-	}
-}
-
-export function recordRun(
-	agent: string,
-	task: string,
-	exitCode: number,
-	durationMs: number,
-	terminal: { interrupted?: boolean; processSignal?: string | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean } = {},
-): void {
-	try {
-		const outcome: RunOutcome = terminal.stopped
-			? "stopped"
-			: terminal.interrupted
-				? "interrupted"
-				: terminal.timedOut
-					? "timed_out"
-					: exitCode !== 0 && isUnexplainedProcessSignal(terminal)
-						? "stopped"
-						: exitCode === 0 ? "completed" : "failed";
-		const entry: RunEntry = {
-			agent,
-			task: REDACTED_TASK,
-			taskHash: hashTask(task),
-			ts: Math.floor(Date.now() / 1000),
-			status: exitCode === 0 ? "ok" : "error",
-			outcome,
-			duration: durationMs,
-			...(exitCode !== 0 ? { exit: exitCode } : {}),
-		};
-		const historyPath = getHistoryPath();
-		hardenHistoryStorage(historyPath);
-		let lineCount: number | undefined;
-		try { lineCount = sanitizeHistoryFile(historyPath); } catch {}
-		appendPrivateHistoryLine(historyPath, JSON.stringify(entry));
-		if (lineCount === undefined) historyFileStates.delete(historyPath);
-		else rememberHistoryFile(historyPath, lineCount + 1);
-	} catch {
-		// Best-effort — never crash the execution flow for history recording
-	}
-}
-
-export function loadRunsForAgent(agent: string): RunEntry[] {
-	const historyPath = getHistoryPath();
-	try { hardenHistoryStorage(historyPath); } catch {}
-	if (!fs.existsSync(historyPath)) return [];
-	let raw: string;
-	try {
-		raw = fs.readFileSync(historyPath, "utf-8");
-	} catch {
-		return [];
-	}
-
-	let { lines, changed } = sanitizeHistoryLines(raw);
-
-	if (lines.length > ROTATE_READ_THRESHOLD) {
-		lines = lines.slice(-ROTATE_KEEP);
-		changed = true;
-	}
-	try {
-		if (changed) writePrivateHistory(historyPath, lines);
-		rememberHistoryFile(historyPath, lines.length);
-	} catch {}
-
-	return lines
-		.map((line) => { try { return JSON.parse(line) as RunEntry; } catch { return undefined; } })
-		.filter((entry): entry is RunEntry => entry !== undefined && entry.agent === agent)
-		.reverse();
-}

package/src/runs/shared/runtime-acknowledged-extensions.ts

@@ -1,44 +0,0 @@
-import type { RuntimeAcknowledgedChildExtensions } from "../../shared/types.ts";
-
-export const RUNTIME_EXTENSION_ACK_EVENT = "subagent:acknowledge-extension";
-export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS = 32;
-export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH = 128;
-
-export function isRuntimeAcknowledgedExtensionId(value: unknown): value is string {
-	return typeof value === "string"
-		&& value.length > 0
-		&& value.length <= MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH
-		&& /^[A-Za-z0-9._:@+-]+$/.test(value)
-		&& !value.includes("..")
-		&& !value.includes("/")
-		&& !value.includes("\\");
-}
-
-export function projectRuntimeAcknowledgedExtensions(ids: Iterable<unknown>): RuntimeAcknowledgedChildExtensions | undefined {
-	const unique: string[] = [];
-	const seen = new Set<string>();
-	for (const id of ids) {
-		if (!isRuntimeAcknowledgedExtensionId(id) || seen.has(id)) continue;
-		seen.add(id);
-		unique.push(id);
-	}
-	if (unique.length === 0) return undefined;
-	return {
-		version: 1,
-		source: "child-runtime",
-		ids: unique.slice(0, MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
-		omitted: Math.max(0, unique.length - MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
-	};
-}
-
-export function sanitizeRuntimeAcknowledgedExtensions(value: unknown): RuntimeAcknowledgedChildExtensions | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	if (raw.version !== 1 || raw.source !== "child-runtime" || !Array.isArray(raw.ids)) return undefined;
-	const projected = projectRuntimeAcknowledgedExtensions(raw.ids);
-	if (!projected) return undefined;
-	const omitted = typeof raw.omitted === "number" && Number.isFinite(raw.omitted)
-		? Math.max(0, Math.floor(raw.omitted))
-		: 0;
-	return { ...projected, omitted: projected.omitted + omitted };
-}