@bastani/atomic 0.9.14 → 0.9.15

package/dist/builtin/subagents/src/extension/fanout-child.ts

@@ -1,259 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { ExtensionAPI, ToolDefinition } from "@bastani/atomic";
-import { APP_NAME } from "@bastani/atomic";
-
-import { discoverAgents } from "../agents/agents.js";
-import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
-import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.js";
-import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.js";
-import type { ChildModePolicy } from "../runs/inprocess/child-policy.js";
-import { hasInProcessNestedRoute, subscribeInProcessControlRequests } from "../runs/inprocess/nested-routing.js";
-import {
-	type NestedRoute,
-	readNestedControlRequests,
-	resolveNestedRouteFromEnv,
-	writeNestedControlResult,
-} from "../runs/inprocess/runtime-support/nested-api.js";
-import { getArtifactsDir } from "../shared/artifacts.js";
-import type { Details, SubagentState } from "../shared/types.js";
-import { beginApiLifecycle } from "./api-lifecycle.js";
-import { loadConfig } from "./config.js";
-import { SubagentParams } from "./schemas.js";
-
-function getSubagentSessionRoot(parentSessionFile: string | null): string {
-	if (parentSessionFile) {
-		const baseName = path.basename(parentSessionFile, ".jsonl");
-		const sessionsDir = path.dirname(parentSessionFile);
-		return path.join(sessionsDir, baseName);
-	}
-	return fs.mkdtempSync(path.join(os.tmpdir(), `${APP_NAME}-subagent-session-`));
-}
-
-function expandTilde(p: string): string {
-	return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
-}
-
-export function createChildSafeState(): SubagentState {
-	return {
-		baseCwd: "",
-		currentSessionId: null,
-		subagentInProgress: false,
-		foregroundRuns: new Map(),
-		foregroundControls: new Map(),
-		lastForegroundControlId: null,
-		pendingForegroundControlNotices: new Map(),
-		lastUiContext: null,
-	};
-}
-
-const MAX_SEEN_REQUEST_IDS = 1024;
-const TRIMMED_SEEN_REQUEST_IDS = 512;
-const MAX_PENDING_RESULTS = 256;
-const MAX_PENDING_RESULT_ATTEMPTS = 10;
-const MAX_PENDING_RESULT_AGE_MS = 60_000;
-type NestedControlResultPayload = Parameters<typeof writeNestedControlResult>[1];
-
-interface PendingControlResult {
-	result: NestedControlResultPayload;
-	firstFailureAt: number;
-	attempts: number;
-}
-
-function rememberSeenRequest(seen: Set<string>, requestId: string): void {
-	seen.add(requestId);
-	if (seen.size <= MAX_SEEN_REQUEST_IDS) return;
-	const keep = [...seen].slice(-TRIMMED_SEEN_REQUEST_IDS);
-	seen.clear();
-	for (const id of keep) seen.add(id);
-}
-
-function dropControlRequestFile(filePath: string, requestId: string): void {
-	try {
-		fs.unlinkSync(filePath);
-	} catch (error) {
-		console.error(`Failed to remove processed nested control request '${requestId}' at '${filePath}':`, error);
-	}
-}
-
-function shouldDropPendingResult(pending: PendingControlResult, pendingSize: number, now: number): boolean {
-	return (
-		pending.attempts >= MAX_PENDING_RESULT_ATTEMPTS ||
-		now - pending.firstFailureAt >= MAX_PENDING_RESULT_AGE_MS ||
-		pendingSize > MAX_PENDING_RESULTS
-	);
-}
-
-function buildNestedControlResult(
-	pi: ExtensionAPI,
-	state: SubagentState,
-	request: ReturnType<typeof readNestedControlRequests>[number],
-): Promise<NestedControlResultPayload> {
-	return (async () => {
-		let ok = false;
-		let message = "Control request failed.";
-		try {
-			const control = state.foregroundControls.get(request.targetRunId);
-			if (!control) {
-				message = `Nested run ${request.targetRunId} is not active in this fanout child.`;
-			} else if (request.action === "interrupt") {
-				ok = control.interrupt?.() === true;
-				message = ok
-					? `Interrupt requested for nested run ${request.targetRunId}.`
-					: `Nested run ${request.targetRunId} has no active child step to interrupt.`;
-			} else if (!request.message?.trim()) {
-				message = "Nested resume requires message.";
-			} else if (!control.currentAgent) {
-				message = `Nested run ${request.targetRunId} has no active child message route.`;
-			} else {
-				const index = control.currentIndex ?? 0;
-				const target = resolveSubagentIntercomTarget(request.targetRunId, control.currentAgent, index);
-				ok = await deliverSubagentIntercomMessageEvent(
-					pi.events,
-					target,
-					`Follow-up for nested run ${request.targetRunId} (${control.currentAgent}):\n\n${request.message.trim()}`,
-					500,
-					{ source: "nested-resume", runId: request.targetRunId, agent: control.currentAgent, index },
-				);
-				message = ok
-					? `Delivered follow-up to live nested run ${request.targetRunId}.`
-					: `Nested child intercom target is not registered: ${target}`;
-			}
-		} catch (error) {
-			message = error instanceof Error ? error.message : String(error);
-		}
-		return { ts: Date.now(), requestId: request.requestId, targetRunId: request.targetRunId, ok, message };
-	})();
-}
-
-const nestedControlListenerCleanups = new WeakMap<ExtensionAPI, () => void>();
-
-export function stopNestedControlInboxListener(pi: ExtensionAPI): void {
-	nestedControlListenerCleanups.get(pi)?.();
-	nestedControlListenerCleanups.delete(pi);
-}
-
-export function startNestedControlInboxListener(pi: ExtensionAPI, state: SubagentState): (() => void) | undefined {
-	stopNestedControlInboxListener(pi);
-	let route: NestedRoute | undefined;
-	try {
-		route = resolveNestedRouteFromEnv();
-	} catch {
-		return undefined;
-	}
-	if (!route) return undefined;
-	const seen = new Set<string>();
-	const inFlight = new Set<string>();
-	const pendingResults = new Map<string, PendingControlResult>();
-	const processRequest = (request: ReturnType<typeof readNestedControlRequests>[number]): void => {
-		if (seen.has(request.requestId) || inFlight.has(request.requestId)) return;
-		inFlight.add(request.requestId);
-		void (async () => {
-			try {
-				const pending = pendingResults.get(request.requestId);
-				const result = pending?.result ?? (await buildNestedControlResult(pi, state, request));
-				try {
-					writeNestedControlResult(route!, result);
-				} catch (error) {
-					const now = Date.now();
-					const nextPending: PendingControlResult = {
-						result,
-						firstFailureAt: pending?.firstFailureAt ?? now,
-						attempts: (pending?.attempts ?? 0) + 1,
-					};
-					pendingResults.set(request.requestId, nextPending);
-					if (shouldDropPendingResult(nextPending, pendingResults.size, now)) {
-						pendingResults.delete(request.requestId);
-						rememberSeenRequest(seen, request.requestId);
-						dropControlRequestFile(request.filePath, request.requestId);
-						console.error(
-							`Dropping nested control result for request '${request.requestId}' targeting '${request.targetRunId}' after ${nextPending.attempts} failed writes via inbox '${route!.controlInbox}':`,
-							error,
-						);
-					} else if (nextPending.attempts === 1) {
-						console.error(
-							`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route!.controlInbox}'; keeping request for retry:`,
-							error,
-						);
-					}
-					return;
-				}
-				pendingResults.delete(request.requestId);
-				rememberSeenRequest(seen, request.requestId);
-				dropControlRequestFile(request.filePath, request.requestId);
-			} finally {
-				inFlight.delete(request.requestId);
-			}
-		})();
-	};
-	const processPending = (): void => {
-		for (const request of readNestedControlRequests(route!)) processRequest(request);
-	};
-	processPending();
-	const memoryCleanup = hasInProcessNestedRoute(route)
-		? subscribeInProcessControlRequests(route, processRequest)
-		: undefined;
-	let watcher: fs.FSWatcher | undefined;
-	if (!memoryCleanup) {
-		try {
-			watcher = fs.watch(route.controlInbox, { persistent: false }, () => processPending());
-		} catch (error) {
-			console.error(`Failed to watch nested control inbox '${route.controlInbox}':`, error);
-		}
-	}
-	const cleanup = () => {
-		memoryCleanup?.();
-		watcher?.close();
-		if (nestedControlListenerCleanups.get(pi) === cleanup) nestedControlListenerCleanups.delete(pi);
-	};
-	nestedControlListenerCleanups.set(pi, cleanup);
-	return cleanup;
-}
-
-export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, childPolicy?: ChildModePolicy): void {
-	if (!childPolicy?.fanoutAuthorized) return;
-
-	const lifecycle = beginApiLifecycle(pi);
-
-	try {
-		const config = loadConfig();
-		const state = createChildSafeState();
-		let nestedListenerCleanup: (() => void) | undefined;
-		const executor = createSubagentExecutor({
-			pi,
-			state,
-			config,
-			tempArtifactsDir: getArtifactsDir(null),
-			getSubagentSessionRoot,
-			expandTilde,
-			discoverAgents,
-			childPolicy,
-			allowMutatingManagementActions: childPolicy ? childPolicy.managementActions === "full" : false,
-		});
-		lifecycle.setCleanup(() => nestedListenerCleanup?.());
-
-		const tool: ToolDefinition<typeof SubagentParams, Details> = {
-			name: "subagent",
-			label: "Subagent",
-			description: [
-				"Delegate to subagents from child-safe fanout mode.",
-				"Execution calls always start non-interactively.",
-				"Allowed management/control actions: list, get, status, interrupt, resume, doctor.",
-				"Agent config mutation actions create, update, and delete are blocked in this mode.",
-			].join("\n"),
-			parameters: SubagentParams,
-			execute(id, params, signal, onUpdate, ctx) {
-				const executionSignal = signal ?? ctx.signal ?? new AbortController().signal;
-				return executor.execute(id, params as SubagentParamsLike, executionSignal, onUpdate, ctx);
-			},
-		};
-
-		pi.registerTool(tool);
-		nestedListenerCleanup = startNestedControlInboxListener(pi, state);
-		pi.on?.("session_shutdown", () => lifecycle.dispose());
-	} catch (error) {
-		lifecycle.dispose();
-		throw error;
-	}
-}

package/dist/builtin/subagents/src/runs/inprocess/nested-routing.ts

@@ -1,218 +0,0 @@
-/**
- * In-process nested routing and control registry.
- *
- * Routes still expose the file-backed shape for compatibility with cold starts and
- * older sessions, but a live host registers the same route here. Live children are
- * addressed by their run id or canonical task path, so control never needs a
- * request file, an inherited capability-token environment variable, or a poller.
- */
-
-export interface InProcessNestedRouteKey {
-	readonly rootRunId: string;
-	readonly capabilityToken: string;
-}
-
-export interface InProcessControlRequest {
-	readonly type: "subagent.nested.control-request";
-	readonly rootRunId: string;
-	readonly capabilityToken: string;
-	readonly ts: number;
-	readonly requestId: string;
-	readonly targetRunId: string;
-	readonly action: "interrupt" | "resume";
-	readonly message?: string;
-	readonly filePath: string;
-}
-
-export interface InProcessControlResult {
-	readonly ts: number;
-	readonly requestId: string;
-	readonly targetRunId: string;
-	readonly ok: boolean;
-	readonly message: string;
-	readonly filePath?: string;
-}
-
-export interface InProcessNestedResumeOutcome {
-	readonly status: "ok" | "error" | "interrupted" | "continued";
-	readonly path: string;
-	readonly sessionFile?: string;
-	readonly envelope?: string;
-}
-
-export interface InProcessNestedAttemptHandle {
-	readonly runId: string;
-	readonly path: string;
-	readonly status: () => string;
-	readonly interrupt: () => Promise<void>;
-	readonly resume: (message: string) => Promise<InProcessNestedResumeOutcome>;
-}
-
-interface RouteState {
-	readonly key: InProcessNestedRouteKey;
-	readonly events: object[];
-	readonly controlRequests: Map<string, InProcessControlRequest>;
-	readonly controlResults: Map<string, InProcessControlResult>;
-	readonly listeners: Set<(request: InProcessControlRequest) => void | Promise<void>>;
-}
-
-const routeStates = new Map<string, RouteState>();
-const attemptHandles = new Map<string, Map<string, InProcessNestedAttemptHandle>>();
-
-function routeKey(route: InProcessNestedRouteKey): string {
-	return `${route.rootRunId}\u0000${route.capabilityToken}`;
-}
-
-function attemptKey(id: string): string {
-	return id.trim();
-}
-
-function stateFor(route: InProcessNestedRouteKey): RouteState | undefined {
-	return routeStates.get(routeKey(route));
-}
-
-export function registerInProcessNestedRoute(route: InProcessNestedRouteKey): void {
-	const key = routeKey(route);
-	if (!routeStates.has(key)) {
-		routeStates.set(key, {
-			key: { rootRunId: route.rootRunId, capabilityToken: route.capabilityToken },
-			events: [],
-			controlRequests: new Map(),
-			controlResults: new Map(),
-			listeners: new Set(),
-		});
-	}
-}
-
-export function unregisterInProcessNestedRoute(route: InProcessNestedRouteKey): void {
-	routeStates.delete(routeKey(route));
-}
-
-export function hasInProcessNestedRoute(route: InProcessNestedRouteKey): boolean {
-	return stateFor(route) !== undefined;
-}
-
-export function appendInProcessNestedEvent(route: InProcessNestedRouteKey, event: object): void {
-	const state = stateFor(route);
-	if (!state) return;
-	state.events.push(event);
-	if (state.events.length > 20_000) state.events.splice(0, state.events.length - 20_000);
-}
-
-export function readInProcessNestedEvents(route: InProcessNestedRouteKey): readonly object[] {
-	return stateFor(route)?.events ?? [];
-}
-
-export function appendInProcessControlRequest(route: InProcessNestedRouteKey, request: InProcessControlRequest): void {
-	const state = stateFor(route);
-	if (!state) return;
-	state.controlRequests.set(request.requestId, request);
-	for (const listener of state.listeners) queueMicrotask(() => void listener(request));
-}
-
-export function readInProcessControlRequests(route: InProcessNestedRouteKey): readonly InProcessControlRequest[] {
-	return stateFor(route) ? [...stateFor(route)!.controlRequests.values()] : [];
-}
-
-export function removeInProcessControlRequest(route: InProcessNestedRouteKey, requestId: string): void {
-	stateFor(route)?.controlRequests.delete(requestId);
-}
-
-export function appendInProcessControlResult(route: InProcessNestedRouteKey, result: InProcessControlResult): void {
-	const state = stateFor(route);
-	if (!state) return;
-	state.controlResults.set(result.requestId, result);
-}
-
-export function readInProcessControlResults(route: InProcessNestedRouteKey): readonly InProcessControlResult[] {
-	return stateFor(route) ? [...stateFor(route)!.controlResults.values()] : [];
-}
-
-export function subscribeInProcessControlRequests(
-	route: InProcessNestedRouteKey,
-	listener: (request: InProcessControlRequest) => void | Promise<void>,
-): (() => void) | undefined {
-	const state = stateFor(route);
-	if (!state) return undefined;
-	state.listeners.add(listener);
-	for (const request of state.controlRequests.values()) queueMicrotask(() => void listener(request));
-	return () => state.listeners.delete(listener);
-}
-
-export function registerInProcessNestedAttempt(handle: InProcessNestedAttemptHandle): () => void {
-	const key = attemptKey(handle.runId);
-	let handles = attemptHandles.get(key);
-	if (!handles) {
-		handles = new Map();
-		attemptHandles.set(key, handles);
-	}
-	handles.set(handle.path, handle);
-	const pathKey = attemptKey(handle.path);
-	if (pathKey !== key) {
-		let byPath = attemptHandles.get(pathKey);
-		if (!byPath) {
-			byPath = new Map();
-			attemptHandles.set(pathKey, byPath);
-		}
-		byPath.set(handle.path, handle);
-	}
-	return () => {
-		for (const lookupKey of [key, pathKey]) {
-			const current = attemptHandles.get(lookupKey);
-			if (!current || current.get(handle.path) !== handle) continue;
-			current.delete(handle.path);
-			if (current.size === 0) attemptHandles.delete(lookupKey);
-		}
-	};
-}
-
-function handlesFor(id: string): InProcessNestedAttemptHandle[] {
-	return [...(attemptHandles.get(attemptKey(id))?.values() ?? [])];
-}
-
-export interface InProcessNestedControlResult {
-	readonly ok: boolean;
-	readonly message: string;
-	readonly outcome?: InProcessNestedResumeOutcome;
-}
-
-export async function interruptInProcessNestedAttempt(
-	targetId: string,
-): Promise<InProcessNestedControlResult | undefined> {
-	const handles = handlesFor(targetId);
-	if (handles.length === 0) return undefined;
-	const active = handles.filter((handle) => handle.status() === "running" || handle.status() === "continued");
-	if (active.length === 0) {
-		return { ok: false, message: `Nested run ${targetId} has no active child attempt to interrupt.` };
-	}
-	await Promise.all(active.map((handle) => handle.interrupt()));
-	return { ok: true, message: `Interrupt requested for nested run ${targetId}.` };
-}
-
-export async function resumeInProcessNestedAttempt(
-	targetId: string,
-	message: string,
-): Promise<InProcessNestedControlResult | undefined> {
-	const handles = handlesFor(targetId);
-	if (handles.length === 0) return undefined;
-	const handle =
-		handles.find((candidate) => candidate.status() === "interrupted" || candidate.status() === "error") ?? handles[0];
-	if (!handle) return undefined;
-	if (handle.status() === "running" || handle.status() === "continued") {
-		return { ok: false, message: `Nested run ${targetId} is still running; resume is not required.` };
-	}
-	const outcome = await handle.resume(message);
-	return {
-		ok: outcome.status === "ok" || outcome.status === "continued",
-		message:
-			outcome.status === "ok"
-				? `Reloaded nested run ${targetId} through the in-process control plane.`
-				: `Nested run ${targetId} resume ended with status '${outcome.status}'.`,
-		outcome,
-	};
-}
-
-export function clearInProcessNestedRouting(): void {
-	routeStates.clear();
-	attemptHandles.clear();
-}

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

@@ -1,55 +0,0 @@
-export {
-	nestedRouteEnv,
-	parseNestedControlRequest,
-	parseNestedControlResult,
-	readNestedControlRequests,
-	readNestedControlResults,
-	writeNestedControlRequest,
-	writeNestedControlResult,
-} from "./nested-control.js";
-export type {
-	NestedControlRequestRecord,
-	NestedControlResultRecord,
-	NestedEventRecord,
-	NestedRegistry,
-	NestedRoute,
-} from "./nested-core.js";
-export {
-	assertSafeNestedId,
-	cleanupOldNestedRuntimeDirs,
-	createNestedRoute,
-	isSafeNestedId,
-	MAX_NESTED_CHILDREN,
-	MAX_NESTED_DEPTH,
-	MAX_NESTED_EVENT_BYTES,
-	MAX_NESTED_STEPS,
-	MAX_PROCESSED_NESTED_EVENTS,
-	NESTED_EVENTS_DIR,
-	resolveInheritedNestedRouteFromEnv,
-	resolveNestedParentAddressFromEnv,
-	resolveNestedRouteFromEnv,
-	validateNestedRouteShape,
-} from "./nested-core.js";
-export {
-	encodeNestedPathEnv,
-	MAX_NESTED_PATH_ENTRIES,
-	parseNestedPathEnv,
-	sanitizeNestedPath,
-} from "./nested-paths.js";
-export {
-	attachRootChildrenToSteps,
-	hasLiveNestedDescendants,
-	updateForegroundNestedProjection,
-} from "./nested-projection.js";
-export type { NestedRunMatch, NestedRunResolutionScope } from "./nested-registry.js";
-export {
-	findNestedRouteForRootId,
-	findNestedRun,
-	findNestedRunById,
-	findNestedRunMatchesById,
-	projectNestedEvents,
-	projectNestedRegistryForRoot,
-	readNestedRegistry,
-	writeNestedEvent,
-} from "./nested-registry.js";
-export { applyNestedEvent, parseNestedEventRecords, sanitizeSummary } from "./nested-sanitize.js";