@bastani/atomic 0.9.14 → 0.9.15

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-registry.ts

@@ -1,352 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeAtomicJson } from "../../../shared/atomic-json.js";
-import type { NestedRunSummary } from "../../../shared/types.js";
-import { appendInProcessNestedEvent, hasInProcessNestedRoute, readInProcessNestedEvents } from "../nested-routing.js";
-import {
-	assertSafeId,
-	commonRouteRoot,
-	containedPath,
-	MAX_NESTED_EVENT_BYTES,
-	MAX_PROCESSED_NESTED_EVENTS,
-	NESTED_EVENTS_DIR,
-	type NestedEventRecord,
-	type NestedRegistry,
-	type NestedRoute,
-	REGISTRY_FILE,
-	ROUTE_FILE,
-	validateRouteShape,
-} from "./nested-core.js";
-import { applyNestedEvent, parseNestedEventRecords, parseRecord, sanitizeSummary } from "./nested-sanitize.js";
-
-const REGISTRY_LOCK_DIR = ".registry.lock";
-const REGISTRY_LOCK_TIMEOUT_MS = 2_000;
-const REGISTRY_LOCK_STALE_MS = 30_000;
-const REGISTRY_LOCK_POLL_MS = 10;
-
-function registryPath(route: NestedRoute): string {
-	return path.join(commonRouteRoot(route), REGISTRY_FILE);
-}
-
-function registryLockPath(route: NestedRoute): string {
-	return path.join(commonRouteRoot(route), REGISTRY_LOCK_DIR);
-}
-
-function sleepSync(ms: number): void {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-function acquireRegistryLock(route: NestedRoute): () => void {
-	const lockPath = registryLockPath(route);
-	const deadline = Date.now() + REGISTRY_LOCK_TIMEOUT_MS;
-	while (true) {
-		try {
-			fs.mkdirSync(lockPath, { mode: 0o700 });
-			try {
-				fs.writeFileSync(
-					path.join(lockPath, "owner.json"),
-					`${JSON.stringify({ pid: process.pid, createdAt: Date.now() })}\n`,
-					{ mode: 0o600 },
-				);
-			} catch {
-				// Lock ownership metadata is diagnostic only.
-			}
-			return () => fs.rmSync(lockPath, { recursive: true, force: true });
-		} catch (error) {
-			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "EEXIST") throw error;
-			try {
-				const stat = fs.statSync(lockPath);
-				if (Date.now() - stat.mtimeMs > REGISTRY_LOCK_STALE_MS) {
-					fs.rmSync(lockPath, { recursive: true, force: true });
-					continue;
-				}
-			} catch (statError) {
-				if ((statError as NodeJS.ErrnoException).code !== "ENOENT") throw statError;
-				continue;
-			}
-			if (Date.now() >= deadline)
-				throw new Error(`Timed out waiting for nested registry lock for root '${route.rootRunId}'.`);
-			sleepSync(REGISTRY_LOCK_POLL_MS);
-		}
-	}
-}
-
-export function findNestedRouteForRootId(rootRunId: string): NestedRoute | undefined {
-	assertSafeId("rootRunId", rootRunId);
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(NESTED_EVENTS_DIR);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-	for (const entry of entries) {
-		if (!entry.startsWith(`${rootRunId}-`)) continue;
-		const routeRoot = path.join(NESTED_EVENTS_DIR, entry);
-		try {
-			const metadata = JSON.parse(fs.readFileSync(path.join(routeRoot, ROUTE_FILE), "utf-8")) as {
-				rootRunId?: unknown;
-				capabilityToken?: unknown;
-			};
-			if (metadata.rootRunId !== rootRunId || typeof metadata.capabilityToken !== "string") continue;
-			const route = {
-				rootRunId,
-				eventSink: path.join(routeRoot, "events"),
-				controlInbox: path.join(routeRoot, "controls"),
-				capabilityToken: metadata.capabilityToken,
-			};
-			validateRouteShape(route);
-			return route;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-				console.error(`Ignoring unreadable nested route metadata under '${routeRoot}':`, error);
-			}
-		}
-	}
-	return undefined;
-}
-
-export function projectNestedRegistryForRoot(rootRunId: string): NestedRegistry | undefined {
-	const route = findNestedRouteForRootId(rootRunId);
-	return route ? projectNestedEvents(route) : undefined;
-}
-
-export function findNestedRun(children: NestedRunSummary[] | undefined, id: string): NestedRunSummary | undefined {
-	if (!children?.length) return undefined;
-	for (const child of children) {
-		if (child.id === id) return child;
-		const nested =
-			findNestedRun(child.children, id) ??
-			findNestedRun(
-				child.steps?.flatMap((step) => step.children ?? []),
-				id,
-			);
-		if (nested) return nested;
-	}
-	return undefined;
-}
-
-export interface NestedRunMatch {
-	rootRunId: string;
-	route: NestedRoute;
-	run: NestedRunSummary;
-}
-
-export interface NestedRunResolutionScope {
-	routes: NestedRoute[];
-	descendantOf?: { parentRunId: string; parentStepIndex?: number };
-}
-
-function collectNestedRuns(
-	children: NestedRunSummary[] | undefined,
-	output: NestedRunSummary[] = [],
-): NestedRunSummary[] {
-	for (const child of children ?? []) {
-		output.push(child);
-		collectNestedRuns(child.children, output);
-		collectNestedRuns(
-			child.steps?.flatMap((step) => step.children ?? []),
-			output,
-		);
-	}
-	return output;
-}
-
-function collectScopedNestedRuns(
-	children: NestedRunSummary[] | undefined,
-	scope: NestedRunResolutionScope["descendantOf"],
-	output: NestedRunSummary[] = [],
-): NestedRunSummary[] {
-	if (!scope) return collectNestedRuns(children, output);
-	for (const child of children ?? []) {
-		if (
-			child.parentRunId === scope.parentRunId &&
-			(scope.parentStepIndex === undefined || child.parentStepIndex === scope.parentStepIndex)
-		) {
-			collectNestedRuns([child], output);
-			continue;
-		}
-		collectScopedNestedRuns(child.children, scope, output);
-		collectScopedNestedRuns(
-			child.steps?.flatMap((step) => step.children ?? []),
-			scope,
-			output,
-		);
-	}
-	return output;
-}
-
-function listNestedRoutes(): NestedRoute[] {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(NESTED_EVENTS_DIR);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
-	const routes: NestedRoute[] = [];
-	for (const entry of entries) {
-		const routeRoot = path.join(NESTED_EVENTS_DIR, entry);
-		try {
-			const metadata = JSON.parse(fs.readFileSync(path.join(routeRoot, ROUTE_FILE), "utf-8")) as {
-				rootRunId?: unknown;
-				capabilityToken?: unknown;
-			};
-			if (typeof metadata.rootRunId !== "string" || typeof metadata.capabilityToken !== "string") continue;
-			const route = {
-				rootRunId: metadata.rootRunId,
-				eventSink: path.join(routeRoot, "events"),
-				controlInbox: path.join(routeRoot, "controls"),
-				capabilityToken: metadata.capabilityToken,
-			};
-			validateRouteShape(route);
-			routes.push(route);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-				console.error(`Ignoring unreadable nested route metadata under '${routeRoot}':`, error);
-			}
-		}
-	}
-	return routes;
-}
-
-export function findNestedRunMatchesById(
-	id: string,
-	options: { prefix?: boolean; scope?: NestedRunResolutionScope } = {},
-): NestedRunMatch[] {
-	assertSafeId("id", id);
-	const matches: NestedRunMatch[] = [];
-	for (const route of options.scope?.routes ?? listNestedRoutes()) {
-		try {
-			const registry = projectNestedEvents(route);
-			for (const run of collectScopedNestedRuns(registry.children, options.scope?.descendantOf)) {
-				if (options.prefix ? run.id.startsWith(id) : run.id === id)
-					matches.push({ rootRunId: route.rootRunId, route, run });
-			}
-		} catch {}
-	}
-	return matches;
-}
-
-export function findNestedRunById(id: string): { rootRunId: string; run: NestedRunSummary } | undefined {
-	const match = findNestedRunMatchesById(id)[0];
-	return match ? { rootRunId: match.rootRunId, run: match.run } : undefined;
-}
-
-export function readNestedRegistry(route: NestedRoute): NestedRegistry {
-	validateRouteShape(route);
-	try {
-		const parsed = JSON.parse(fs.readFileSync(registryPath(route), "utf-8")) as NestedRegistry;
-		return {
-			rootRunId: route.rootRunId,
-			updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : 0,
-			children: Array.isArray(parsed.children)
-				? parsed.children
-						.map((child) => sanitizeSummary(child))
-						.filter((child): child is NestedRunSummary => Boolean(child))
-				: [],
-			processedEvents: Array.isArray(parsed.processedEvents)
-				? parsed.processedEvents
-						.filter((item): item is string => typeof item === "string")
-						.slice(-MAX_PROCESSED_NESTED_EVENTS)
-				: [],
-		};
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-		return { rootRunId: route.rootRunId, updatedAt: 0, children: [], processedEvents: [] };
-	}
-}
-
-export function projectNestedEvents(route: NestedRoute): NestedRegistry {
-	validateRouteShape(route);
-	if (hasInProcessNestedRoute(route)) {
-		const release = acquireRegistryLock(route);
-		try {
-			let registry = readNestedRegistry(route);
-			for (const event of readInProcessNestedEvents(route)) {
-				const parsed = parseRecord(JSON.stringify(event), route);
-				if (parsed) registry = applyNestedEvent(registry, parsed);
-			}
-			return registry;
-		} finally {
-			release();
-		}
-	}
-	const release = acquireRegistryLock(route);
-	try {
-		let registry = readNestedRegistry(route);
-		const seen = new Set(registry.processedEvents);
-		let changed = false;
-		let entries: string[] = [];
-		try {
-			entries = fs
-				.readdirSync(route.eventSink)
-				.filter((entry) => entry.endsWith(".json") || entry.endsWith(".jsonl"))
-				.sort();
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-		}
-		for (const entry of entries) {
-			if (seen.has(entry)) continue;
-			const eventPath = path.join(route.eventSink, entry);
-			if (!containedPath(route.eventSink, eventPath)) continue;
-			let content: string;
-			try {
-				const stat = fs.statSync(eventPath);
-				if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
-				content = fs.readFileSync(eventPath, "utf-8");
-			} catch {
-				continue;
-			}
-			for (const event of parseNestedEventRecords(content, route)) {
-				registry = applyNestedEvent(registry, event);
-				changed = true;
-			}
-			seen.add(entry);
-			changed = true;
-		}
-		if (changed) {
-			// Event files are immutable; retain enough filenames for worst-case bounded fanout without unbounded registry growth.
-			registry = { ...registry, processedEvents: [...seen].slice(-MAX_PROCESSED_NESTED_EVENTS) };
-			// Registry projection is lock-serialized across parent and fanout-child processes.
-			// Child and runner processes only create immutable event files, so parent status.json
-			// remains owned by the existing runner writer and is never rewritten here.
-			writeAtomicJson(registryPath(route), registry);
-		}
-		return registry;
-	} finally {
-		release();
-	}
-}
-
-export function writeRouteRecord(dir: string, ts: number, payload: object): string {
-	const content = `${JSON.stringify(payload)}\n`;
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES)
-		throw new Error("Nested route record exceeds the maximum size.");
-	fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-	const name = `${String(ts).padStart(13, "0")}-${randomUUID()}.json`;
-	const tmp = path.join(dir, `.${name}.tmp`);
-	const finalPath = path.join(dir, name);
-	fs.writeFileSync(tmp, content, { mode: 0o600 });
-	fs.renameSync(tmp, finalPath);
-	return finalPath;
-}
-
-export function writeNestedEvent(
-	route: NestedRoute,
-	event: Omit<NestedEventRecord, "rootRunId" | "capabilityToken">,
-): void {
-	// Child and runner processes append immutable route events; parent projection owns registry/status aggregation.
-	validateRouteShape(route);
-	const record: NestedEventRecord = {
-		...event,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseRecord(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested event record failed validation.");
-	appendInProcessNestedEvent(route, sanitized);
-	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
-}

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-rendering.ts

@@ -1,136 +0,0 @@
-import { formatDuration, formatTokens, shortenPath } from "../../../shared/formatters.js";
-import { formatActivityLabel } from "../../../shared/status-format.js";
-import { type ActivityState, MAX_SUBAGENT_NESTING_DEPTH, type NestedRunSummary } from "../../../shared/types.js";
-
-export interface NestedRunCounts {
-	total: number;
-	running: number;
-	paused: number;
-	complete: number;
-	failed: number;
-	queued: number;
-}
-
-export function countNestedRuns(children: NestedRunSummary[] | undefined): NestedRunCounts {
-	const counts: NestedRunCounts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, queued: 0 };
-	for (const child of children ?? []) {
-		counts.total++;
-		counts[child.state]++;
-		const nested = countNestedRuns([
-			...(child.children ?? []),
-			...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
-		]);
-		counts.total += nested.total;
-		counts.running += nested.running;
-		counts.paused += nested.paused;
-		counts.complete += nested.complete;
-		counts.failed += nested.failed;
-		counts.queued += nested.queued;
-	}
-	return counts;
-}
-
-export function formatNestedAggregate(children: NestedRunSummary[] | undefined): string | undefined {
-	const counts = countNestedRuns(children);
-	if (counts.total === 0) return undefined;
-	const parts = [
-		counts.running > 0 ? `${counts.running} running` : "",
-		counts.paused > 0 ? `${counts.paused} paused` : "",
-		counts.failed > 0 ? `${counts.failed} failed` : "",
-		counts.complete > 0 ? `${counts.complete} complete` : "",
-		counts.queued > 0 ? `${counts.queued} queued` : "",
-	].filter(Boolean);
-	return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length ? ` (${parts.join(", ")})` : ""}`;
-}
-
-function nestedRunLabel(run: NestedRunSummary): string {
-	if (run.agent) return run.agent;
-	if (run.agents?.length)
-		return run.agents.length === 1
-			? run.agents[0]!
-			: `${run.agents.slice(0, 2).join(", ")}${run.agents.length > 2 ? ` +${run.agents.length - 2}` : ""}`;
-	return run.id;
-}
-
-function formatNestedActivity(input: {
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	totalTokens?: NestedRunSummary["totalTokens"];
-}): string | undefined {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined)
-		facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	if (input.totalTokens) facts.push(`${formatTokens(input.totalTokens.total)} tok`);
-	const activity = formatActivityLabel(input.lastActivityAt, input.activityState as ActivityState | undefined);
-	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
-}
-
-function formatNestedRunLines(
-	children: NestedRunSummary[] | undefined,
-	options: { indent: string; maxDepth: number; maxLines: number; commandHints?: boolean },
-): string[] {
-	const lines: string[] = [];
-	const append = (items: NestedRunSummary[] | undefined, depth: number, indent: string): void => {
-		if (!items?.length || lines.length >= options.maxLines) return;
-		if (depth > options.maxDepth) {
-			const aggregate = formatNestedAggregate(items);
-			if (aggregate && lines.length < options.maxLines) lines.push(`${indent}↳ ${aggregate}`);
-			return;
-		}
-		for (let index = 0; index < items.length; index++) {
-			const child = items[index]!;
-			if (lines.length >= options.maxLines) {
-				const aggregate = formatNestedAggregate(items.slice(index));
-				if (aggregate) lines[lines.length - 1] = `${indent}↳ ${aggregate}`;
-				return;
-			}
-			const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
-			const error = child.error ? ` | error: ${child.error}` : "";
-			lines.push(
-				`${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity ? ` | ${activity}` : ""}${error}`,
-			);
-			if (options.commandHints && lines.length < options.maxLines)
-				lines.push(`${indent}  Status: subagent({ action: "status", id: "${child.id}" })`);
-			if (depth === options.maxDepth) {
-				const aggregate = formatNestedAggregate([
-					...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
-					...(child.children ?? []),
-				]);
-				if (aggregate && lines.length < options.maxLines) lines.push(`${indent}  ↳ ${aggregate}`);
-				continue;
-			}
-			for (const [stepIndex, step] of (child.steps ?? []).entries()) {
-				if (lines.length >= options.maxLines) return;
-				const stepActivity = step.status === "running" ? formatNestedActivity(step) : undefined;
-				lines.push(
-					`${indent}  ${stepIndex + 1}. ${step.agent} ${step.status}${stepActivity ? ` | ${stepActivity}` : ""}${step.error ? ` | error: ${step.error}` : ""}`,
-				);
-				append(step.children, depth + 1, `${indent}    `);
-			}
-			append(child.children, depth + 1, `${indent}  `);
-		}
-	};
-	append(children, 0, options.indent);
-	return lines;
-}
-
-export function formatNestedRunStatusLines(
-	children: NestedRunSummary[] | undefined,
-	options: { indent?: string; maxDepth?: number; maxLines?: number; commandHints?: boolean } = {},
-): string[] {
-	return formatNestedRunLines(children, {
-		indent: options.indent ?? "  ",
-		maxDepth: options.maxDepth ?? MAX_SUBAGENT_NESTING_DEPTH,
-		maxLines: options.maxLines ?? 40,
-		commandHints: options.commandHints ?? false,
-	});
-}