@bastani/atomic 0.9.14 → 0.9.15

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

@@ -1,178 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-	appendInProcessControlRequest,
-	appendInProcessControlResult,
-	hasInProcessNestedRoute,
-	readInProcessControlRequests,
-	readInProcessControlResults,
-} from "../nested-routing.js";
-import {
-	assertSafeId,
-	clampNumber,
-	containedPath,
-	isSafeNestedId,
-	MAX_NESTED_EVENT_BYTES,
-	type NestedControlRequestRecord,
-	type NestedControlResultRecord,
-	type NestedRoute,
-	stringValue,
-	validateRouteShape,
-} from "./nested-core.js";
-import { writeRouteRecord } from "./nested-registry.js";
-
-export function parseNestedControlRequest(content: string, route: NestedRoute): NestedControlRequestRecord | undefined {
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object") return undefined;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.type !== "subagent.nested.control-request") return undefined;
-	if (raw.rootRunId !== route.rootRunId || raw.capabilityToken !== route.capabilityToken) return undefined;
-	if (!isSafeNestedId(raw.requestId) || !isSafeNestedId(raw.targetRunId)) return undefined;
-	if (raw.action !== "interrupt" && raw.action !== "resume") return undefined;
-	const ts = clampNumber(raw.ts);
-	if (ts === undefined) return undefined;
-	return {
-		type: "subagent.nested.control-request",
-		ts,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-		requestId: raw.requestId,
-		targetRunId: raw.targetRunId,
-		action: raw.action,
-		...(stringValue(raw.message, 16_000) ? { message: stringValue(raw.message, 16_000) } : {}),
-	};
-}
-
-export function parseNestedControlResult(content: string, route: NestedRoute): NestedControlResultRecord | undefined {
-	if (Buffer.byteLength(content, "utf-8") > MAX_NESTED_EVENT_BYTES) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object") return undefined;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.type !== "subagent.nested.control-result") return undefined;
-	if (raw.rootRunId !== route.rootRunId || raw.capabilityToken !== route.capabilityToken) return undefined;
-	if (!isSafeNestedId(raw.requestId) || !isSafeNestedId(raw.targetRunId)) return undefined;
-	const ts = clampNumber(raw.ts);
-	if (ts === undefined || typeof raw.ok !== "boolean") return undefined;
-	return {
-		type: "subagent.nested.control-result",
-		ts,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-		requestId: raw.requestId,
-		targetRunId: raw.targetRunId,
-		ok: raw.ok,
-		message: stringValue(raw.message, 16_000) ?? (raw.ok ? "Control request completed." : "Control request failed."),
-	};
-}
-
-export function writeNestedControlRequest(
-	route: NestedRoute,
-	request: Omit<NestedControlRequestRecord, "type" | "rootRunId" | "capabilityToken">,
-): string {
-	validateRouteShape(route);
-	assertSafeId("requestId", request.requestId);
-	assertSafeId("targetRunId", request.targetRunId);
-	const record: NestedControlRequestRecord = {
-		type: "subagent.nested.control-request",
-		...request,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseNestedControlRequest(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested control request failed validation.");
-	const filePath = writeRouteRecord(route.controlInbox, sanitized.ts, sanitized);
-	appendInProcessControlRequest(route, { ...sanitized, filePath });
-	return filePath;
-}
-
-export function readNestedControlRequests(
-	route: NestedRoute,
-): Array<NestedControlRequestRecord & { filePath: string }> {
-	validateRouteShape(route);
-	if (hasInProcessNestedRoute(route)) return [...readInProcessControlRequests(route)];
-	let entries: string[] = [];
-	try {
-		entries = fs
-			.readdirSync(route.controlInbox)
-			.filter((entry) => entry.endsWith(".json"))
-			.sort();
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-	}
-	const requests: Array<NestedControlRequestRecord & { filePath: string }> = [];
-	for (const entry of entries) {
-		const filePath = path.join(route.controlInbox, entry);
-		if (!containedPath(route.controlInbox, filePath)) continue;
-		try {
-			const stat = fs.statSync(filePath);
-			if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
-			const request = parseNestedControlRequest(fs.readFileSync(filePath, "utf-8"), route);
-			if (request) requests.push({ ...request, filePath });
-		} catch {}
-	}
-	return requests;
-}
-
-export function writeNestedControlResult(
-	route: NestedRoute,
-	result: Omit<NestedControlResultRecord, "type" | "rootRunId" | "capabilityToken">,
-): void {
-	validateRouteShape(route);
-	assertSafeId("requestId", result.requestId);
-	assertSafeId("targetRunId", result.targetRunId);
-	const record: NestedControlResultRecord = {
-		type: "subagent.nested.control-result",
-		...result,
-		rootRunId: route.rootRunId,
-		capabilityToken: route.capabilityToken,
-	};
-	const sanitized = parseNestedControlResult(JSON.stringify(record), route);
-	if (!sanitized) throw new Error("Nested control result failed validation.");
-	const filePath = writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
-	appendInProcessControlResult(route, { ...sanitized, filePath });
-}
-
-export function readNestedControlResults(route: NestedRoute): NestedControlResultRecord[] {
-	validateRouteShape(route);
-	if (hasInProcessNestedRoute(route)) return [...readInProcessControlResults(route)] as NestedControlResultRecord[];
-	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;
-	}
-	const results: NestedControlResultRecord[] = [];
-	for (const entry of entries) {
-		const eventPath = path.join(route.eventSink, entry);
-		if (!containedPath(route.eventSink, eventPath)) continue;
-		try {
-			const stat = fs.statSync(eventPath);
-			if (!stat.isFile() || stat.size > MAX_NESTED_EVENT_BYTES) continue;
-			const content = fs.readFileSync(eventPath, "utf-8");
-			const lines = content.includes("\n") ? content.split("\n").filter((line) => line.trim()) : [content];
-			for (const line of lines) {
-				const result = parseNestedControlResult(line, route);
-				if (result) results.push(result);
-			}
-		} catch {}
-	}
-	return results;
-}
-
-export function nestedRouteEnv(_route: NestedRoute): Record<string, string> {
-	return {};
-}

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

@@ -1,187 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { type NestedRouteInfo, type NestedRunSummary, TEMP_ROOT_DIR } from "../../../shared/types.js";
-import { MAX_SUBAGENT_NESTING_DEPTH } from "../../../shared/types-runtime.js";
-import { registerInProcessNestedRoute } from "../nested-routing.js";
-import { isSafeNestedPathId, type NestedPathEntry } from "./nested-paths.js";
-
-export const NESTED_EVENTS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-events");
-export const ROUTE_FILE = "route.json";
-export const REGISTRY_FILE = "registry.json";
-export const MAX_NESTED_EVENT_BYTES = 64 * 1024;
-export const MAX_NESTED_STEPS = 12;
-export const MAX_NESTED_CHILDREN = 16;
-export const MAX_NESTED_DEPTH = MAX_SUBAGENT_NESTING_DEPTH;
-export const MAX_PROCESSED_NESTED_EVENTS = 20_000;
-type NestedStatusEventType = "subagent.nested.started" | "subagent.nested.updated" | "subagent.nested.completed";
-type NestedControlResultEventType = "subagent.nested.control-result";
-
-export type NestedRoute = NestedRouteInfo;
-
-export interface NestedEventRecord {
-	type: NestedStatusEventType;
-	ts: number;
-	rootRunId: string;
-	parentRunId: string;
-	parentStepIndex?: number;
-	capabilityToken: string;
-	child: NestedRunSummary;
-}
-
-export interface NestedControlResultRecord {
-	type: NestedControlResultEventType;
-	ts: number;
-	rootRunId: string;
-	capabilityToken: string;
-	requestId: string;
-	targetRunId: string;
-	ok: boolean;
-	message: string;
-}
-
-export interface NestedControlRequestRecord {
-	type: "subagent.nested.control-request";
-	ts: number;
-	rootRunId: string;
-	capabilityToken: string;
-	requestId: string;
-	targetRunId: string;
-	action: "interrupt" | "resume";
-	message?: string;
-}
-
-export interface NestedRegistry {
-	rootRunId: string;
-	updatedAt: number;
-	children: NestedRunSummary[];
-	processedEvents: string[];
-}
-
-export function isSafeNestedId(value: unknown): value is string {
-	return isSafeNestedPathId(value);
-}
-
-export function assertSafeNestedId(label: string, value: string): void {
-	if (!isSafeNestedId(value)) throw new Error(`${label} must be a non-empty safe id token.`);
-}
-
-export function assertSafeId(label: string, value: string): void {
-	assertSafeNestedId(label, value);
-}
-
-export function containedPath(base: string, candidate: string): boolean {
-	const resolvedBase = path.resolve(base);
-	const resolvedCandidate = path.resolve(candidate);
-	return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
-}
-
-export function commonRouteRoot(route: Pick<NestedRoute, "eventSink" | "controlInbox">): string {
-	return path.dirname(path.resolve(route.eventSink));
-}
-
-export function validateNestedRouteShape(route: NestedRoute): void {
-	assertSafeId("rootRunId", route.rootRunId);
-	assertSafeId("capabilityToken", route.capabilityToken);
-	if (!containedPath(NESTED_EVENTS_DIR, route.eventSink))
-		throw new Error("Nested event sink is outside the subagent nested event root.");
-	if (!containedPath(NESTED_EVENTS_DIR, route.controlInbox))
-		throw new Error("Nested control inbox is outside the subagent nested event root.");
-	if (commonRouteRoot(route) !== path.dirname(path.resolve(route.controlInbox)))
-		throw new Error("Nested event sink and control inbox must share one route root.");
-}
-
-export function validateRouteShape(route: NestedRoute): void {
-	validateNestedRouteShape(route);
-}
-
-export function createNestedRoute(rootRunId: string): NestedRoute {
-	assertSafeId("rootRunId", rootRunId);
-	const capabilityToken = randomUUID();
-	const routeRoot = path.join(NESTED_EVENTS_DIR, `${rootRunId}-${capabilityToken}`);
-	const eventSink = path.join(routeRoot, "events");
-	const controlInbox = path.join(routeRoot, "controls");
-	fs.mkdirSync(eventSink, { recursive: true, mode: 0o700 });
-	fs.mkdirSync(controlInbox, { recursive: true, mode: 0o700 });
-	fs.writeFileSync(
-		path.join(routeRoot, ROUTE_FILE),
-		`${JSON.stringify({ rootRunId, capabilityToken, createdAt: Date.now() })}\n`,
-		{ mode: 0o600 },
-	);
-	const route = { rootRunId, eventSink, controlInbox, capabilityToken };
-	registerInProcessNestedRoute(route);
-	return route;
-}
-
-/** Whether any entry in the tree rooted at filePath has an mtime at or after cutoff, stopping at the first hit. */
-export function hasEntryNewerThan(filePath: string, cutoff: number): boolean {
-	const stat = fs.statSync(filePath);
-	if (stat.mtimeMs >= cutoff) return true;
-	if (!stat.isDirectory()) return false;
-	return directoryHasEntryNewerThan(filePath, cutoff);
-}
-
-function directoryHasEntryNewerThan(dirPath: string, cutoff: number): boolean {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(dirPath);
-	} catch {
-		return false;
-	}
-	for (const entry of entries) {
-		const childPath = path.join(dirPath, entry);
-		try {
-			const stat = fs.statSync(childPath);
-			if (stat.mtimeMs >= cutoff) return true;
-			if (stat.isDirectory() && directoryHasEntryNewerThan(childPath, cutoff)) return true;
-		} catch {
-			// Nested runtime cleanup is best-effort housekeeping.
-		}
-	}
-	return false;
-}
-
-function cleanupOldSubdirectories(root: string, maxAgeDays: number): void {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(root);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
-	const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-	for (const entry of entries) {
-		const entryPath = path.join(root, entry);
-		try {
-			if (!hasEntryNewerThan(entryPath, cutoff)) fs.rmSync(entryPath, { recursive: true, force: true });
-		} catch {
-			// Keep startup resilient if a child process removes or rewrites an entry while scanning.
-		}
-	}
-}
-
-export function cleanupOldNestedRuntimeDirs(maxAgeDays: number): void {
-	cleanupOldSubdirectories(NESTED_EVENTS_DIR, maxAgeDays);
-}
-
-export function resolveNestedRouteFromEnv(_env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	return undefined;
-}
-
-export function resolveInheritedNestedRouteFromEnv(_env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
-	return undefined;
-}
-
-export function resolveNestedParentAddressFromEnv(
-	_env: NodeJS.ProcessEnv = process.env,
-): { parentRunId: string; parentStepIndex?: number; depth: number; path: NestedPathEntry[] } | undefined {
-	return undefined;
-}
-
-export function clampNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-export function stringValue(value: unknown, max = 512): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
-}

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

@@ -1,57 +0,0 @@
-import * as path from "node:path";
-
-const MAX_NESTED_ID_LENGTH = 128;
-export const MAX_NESTED_PATH_ENTRIES = 4;
-
-export type NestedPathEntry = { runId: string; stepIndex?: number; agent?: string };
-
-export function isSafeNestedPathId(value: unknown): value is string {
-	return (
-		typeof value === "string" &&
-		value.length > 0 &&
-		value.length <= MAX_NESTED_ID_LENGTH &&
-		!path.isAbsolute(value) &&
-		!value.includes("/") &&
-		!value.includes("\\") &&
-		!value.includes("..")
-	);
-}
-
-function finiteNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function nonEmptyString(value: unknown, max: number): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
-}
-
-export function sanitizeNestedPath(value: unknown): NestedPathEntry[] {
-	if (!Array.isArray(value)) return [];
-	return value
-		.map((part) => {
-			if (!part || typeof part !== "object") return undefined;
-			const record = part as Record<string, unknown>;
-			if (!isSafeNestedPathId(record.runId)) return undefined;
-			return {
-				runId: record.runId,
-				...(finiteNumber(record.stepIndex) !== undefined ? { stepIndex: finiteNumber(record.stepIndex) } : {}),
-				...(nonEmptyString(record.agent, 128) ? { agent: nonEmptyString(record.agent, 128) } : {}),
-			};
-		})
-		.filter((part): part is NestedPathEntry => Boolean(part))
-		.slice(0, MAX_NESTED_PATH_ENTRIES);
-}
-
-export function parseNestedPathEnv(value: string | undefined): NestedPathEntry[] {
-	if (!value) return [];
-	try {
-		return sanitizeNestedPath(JSON.parse(value) as unknown);
-	} catch {
-		return [];
-	}
-}
-
-export function encodeNestedPathEnv(value: NestedPathEntry[]): string {
-	const sanitized = sanitizeNestedPath(value);
-	return sanitized.length ? JSON.stringify(sanitized) : "";
-}

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

@@ -1,42 +0,0 @@
-import type { NestedRunSummary, SubagentState } from "../../../shared/types.js";
-import { MAX_NESTED_CHILDREN } from "./nested-core.js";
-import { projectNestedEvents } from "./nested-registry.js";
-import { terminal } from "./nested-sanitize.js";
-
-export function attachRootChildrenToSteps<T extends { children?: NestedRunSummary[]; index?: number }>(
-	rootRunId: string,
-	steps: T[] | undefined,
-	children: NestedRunSummary[] | undefined,
-): void {
-	if (!steps?.length) return;
-	for (const step of steps) step.children = undefined;
-	if (!children?.length) return;
-	for (const child of children) {
-		if (child.parentRunId !== rootRunId || child.parentStepIndex === undefined) continue;
-		const step = steps.find((candidate, index) => (candidate.index ?? index) === child.parentStepIndex);
-		if (!step) continue;
-		step.children ??= [];
-		step.children = [...step.children.filter((existing) => existing.id !== child.id), child].slice(
-			0,
-			MAX_NESTED_CHILDREN,
-		);
-	}
-}
-
-export function updateForegroundNestedProjection(
-	control: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never,
-): void {
-	if (!control.nestedRoute) return;
-	const registry = projectNestedEvents(control.nestedRoute);
-	control.nestedChildren = registry.children;
-}
-
-export function hasLiveNestedDescendants(children: NestedRunSummary[] | undefined): boolean {
-	if (!children?.length) return false;
-	for (const child of children) {
-		if (!terminal(child.state)) return true;
-		if (hasLiveNestedDescendants(child.children)) return true;
-		if (hasLiveNestedDescendants(child.steps?.flatMap((step) => step.children ?? []))) return true;
-	}
-	return false;
-}