@bastani/atomic 0.9.15 → 0.9.16-alpha.1

package/dist/builtin/workflows/src/durable/dbos-lifecycle.ts

@@ -3,6 +3,7 @@ import {
 	provisionResolvedLocalDbos,
 	resolveDbosSystemDatabaseUrl,
 	shouldProvisionLocalDbos,
+	shutdownResolvedLocalDbos,
 } from "./dbos-local-postgres.js";
 import { getDbosProcessOwner, resetDbosProcessOwner } from "./dbos-process-owner.js";
 import { classifyDbosDurabilityFailure, readDbosFailureDetail } from "./dbos-registration-diagnostics.js";
@@ -41,6 +42,7 @@ export class DbosShutdownError extends DbosDurabilityError {
 }
 type DbosConfigurator = () => Promise<ConfiguredDbosDurability>;
 type LocalDbosProvisioner = () => Promise<void>;
+type LocalDbosShutdowner = () => Promise<void>;
 
 /**
  * Default path: resolve the local database first (explicit env URL, embedded
@@ -53,6 +55,7 @@ const defaultConfigurator: DbosConfigurator = async () => {
 
 let configureDurability: DbosConfigurator = defaultConfigurator;
 let provisionLocalDbos: LocalDbosProvisioner = provisionResolvedLocalDbos;
+let shutdownLocalDbos: LocalDbosShutdowner = shutdownResolvedLocalDbos;
 
 function owner(): ReturnType<typeof getDbosProcessOwner> {
 	return getDbosProcessOwner();
@@ -69,6 +72,11 @@ async function durabilityFailure(action: string, error: unknown): Promise<DbosDu
 	return new DbosDurabilityError(`DBOS workflow durability ${action} failed: ${detail}. ${guidance}`, cause);
 }
 
+function combinedShutdownFailure(errors: readonly unknown[]): unknown {
+	if (errors.length === 1) return errors[0];
+	return new AggregateError(errors, errors.map((error) => readDbosFailureDetail(error)).join("; "));
+}
+
 export async function configureDbosOnce(): Promise<ConfiguredDbosDurability> {
 	const slot = owner();
 	if (slot.failure !== undefined) throw slot.failure;
@@ -140,17 +148,29 @@ export async function shutdownDbos(): Promise<void> {
 	const configuredPromise = slot.configured;
 	if (configuredPromise === undefined) return;
 	slot.shutdownPromise = (async () => {
-		// A backend that never reached "ready" has nothing to flush or stop.
-		// `configured`/`launchPromise` memoize rejections, so re-awaiting them
-		// unguarded would rethrow the original provisioning failure out of every
-		// session dispose — crashing otherwise-successful runs at process exit.
+		// Configuration and launch failures are intentionally not rethrown during
+		// session disposal, but local provisioning may already have started an
+		// owned cluster. Always attempt that cleanup exactly once.
 		const durability = await configuredPromise.catch(() => undefined);
-		if (durability === undefined) return;
+		if (durability === undefined) {
+			await shutdownLocalDbos();
+			return;
+		}
 		if (slot.launchPromise !== undefined) await slot.launchPromise.catch(() => undefined);
-		if (slot.state !== "ready") return;
+		if (slot.state !== "ready") {
+			await shutdownLocalDbos();
+			return;
+		}
 		slot.state = "shutting_down";
-		await durability.backend.flush();
-		await durability.shutdown();
+		const errors: unknown[] = [];
+		for (const shutdown of [() => durability.backend.flush(), () => durability.shutdown(), shutdownLocalDbos]) {
+			try {
+				await shutdown();
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		if (errors.length > 0) throw combinedShutdownFailure(errors);
 		slot.state = "shut_down";
 	})().catch(async (error: unknown) => {
 		slot.failure = await durabilityFailure("shutdown", error);
@@ -179,8 +199,10 @@ export function dbosLifecycleState(): DbosLifecycleState {
 export function resetDbosLifecycleForTests(
 	configurator: DbosConfigurator = defaultConfigurator,
 	provisioner: LocalDbosProvisioner = provisionResolvedLocalDbos,
+	shutdowner: LocalDbosShutdowner = shutdownResolvedLocalDbos,
 ): void {
 	resetDbosProcessOwner();
 	configureDurability = configurator;
 	provisionLocalDbos = provisioner;
+	shutdownLocalDbos = shutdowner;
 }

package/dist/builtin/workflows/src/durable/dbos-local-postgres.ts

@@ -7,11 +7,16 @@
  *
  *   1. `DBOS_SYSTEM_DATABASE_URL` — the user's explicit database.
  *   2. Atomic's embedded Postgres (npm-distributed binaries, no Docker).
- *   3. DBOS's reusable `dbos-db` Docker container, only when the embedded
- *      binaries are unavailable for this platform and Docker exists.
+ *   3. DBOS's reusable `dbos-db` Docker container, only after embedded
+ *      provisioning fails without leaving retained-process cleanup pending.
  */
 
-import { EMBEDDED_DBOS_SYSTEM_DATABASE_URL, ensureEmbeddedDbosPostgres } from "./dbos-embedded-postgres.js";
+import {
+	EMBEDDED_DBOS_SYSTEM_DATABASE_URL,
+	EmbeddedPostgresCleanupPendingError,
+	ensureEmbeddedDbosPostgres,
+	shutdownEmbeddedDbosPostgres,
+} from "./dbos-embedded-postgres.js";
 import { commandFailureDetail, delay, runLocalCommand, tcpReachable } from "./local-command.js";
 
 const DOCKER_CONTAINER = "dbos-db";
@@ -20,11 +25,14 @@ const DOCKER_READY_ATTEMPTS = 60;
 const DOCKER_READY_DELAY_MS = 500;
 
 type LocalDbosProvider = () => Promise<void>;
+type LocalDbosShutdowner = () => Promise<void>;
 
 let resolution: Promise<string | undefined> | undefined;
 let resolvedProvider: LocalDbosProvider | undefined;
 let embeddedProvider: LocalDbosProvider = ensureEmbeddedDbosPostgres;
 let dockerProvider: LocalDbosProvider = ensureDockerDbosPostgres;
+let shutdownEmbeddedProvider: LocalDbosShutdowner = shutdownEmbeddedDbosPostgres;
+let embeddedShutdown: Promise<void> | undefined;
 
 /**
  * Resolve the system database URL for this process and make its database
@@ -44,6 +52,22 @@ export async function provisionResolvedLocalDbos(): Promise<void> {
 	await (resolvedProvider ?? embeddedProvider)();
 }
 
+/** Stop the local database only when the resolved provider was embedded. */
+export function shutdownResolvedLocalDbos(): Promise<void> {
+	if (resolvedProvider !== embeddedProvider) return Promise.resolve();
+	embeddedShutdown ??= shutdownEmbeddedProvider().then(
+		() => {
+			resolvedProvider = undefined;
+			embeddedShutdown = undefined;
+		},
+		(error: unknown) => {
+			embeddedShutdown = undefined;
+			throw error;
+		},
+	);
+	return embeddedShutdown;
+}
+
 export function shouldProvisionLocalDbos(error: unknown): boolean {
 	if (process.env.DBOS_SYSTEM_DATABASE_URL?.trim()) return false;
 	const message = error instanceof Error ? `${error.message}\n${error.cause ?? ""}` : String(error);
@@ -61,6 +85,12 @@ async function resolve(): Promise<string | undefined> {
 		resolvedProvider = embeddedProvider;
 		return EMBEDDED_DBOS_SYSTEM_DATABASE_URL;
 	} catch (embeddedError) {
+		if (embeddedError instanceof EmbeddedPostgresCleanupPendingError) {
+			// A second database must not hide the exact child lease whose startup
+			// rollback timed out. Keep teardown routed to that embedded owner.
+			resolvedProvider = embeddedProvider;
+			throw embeddedError;
+		}
 		try {
 			await dockerProvider();
 			resolvedProvider = dockerProvider;
@@ -125,9 +155,12 @@ async function requireDockerSuccess(action: string, args: string[]): Promise<voi
 export function resetLocalDbosProvisioningForTests(
 	embedded: LocalDbosProvider = ensureEmbeddedDbosPostgres,
 	docker: LocalDbosProvider = ensureDockerDbosPostgres,
+	shutdownEmbedded: LocalDbosShutdowner = shutdownEmbeddedDbosPostgres,
 ): void {
 	resolution = undefined;
 	resolvedProvider = undefined;
+	embeddedShutdown = undefined;
 	embeddedProvider = embedded;
 	dockerProvider = docker;
+	shutdownEmbeddedProvider = shutdownEmbedded;
 }

package/dist/builtin/workflows/src/durable/local-command.ts

@@ -8,12 +8,22 @@ export interface LocalCommandResult {
 	readonly exitCode: number;
 	readonly stdout: string;
 	readonly stderr: string;
+	/** True when bounded capture discarded the beginning of stdout. */
+	readonly stdoutTruncated?: true;
+	/** True when bounded capture discarded the beginning of stderr. */
+	readonly stderrTruncated?: true;
 }
 
 const OUTPUT_LIMIT_BYTES = 16_384;
 
 export interface LocalCommandOptions {
 	readonly env?: Readonly<Record<string, string>>;
+	/**
+	 * For daemon launchers whose successful descendants inherit stdio, settle
+	 * from a successful direct-child exit. Nonzero exits still drain through
+	 * `close`, preserving bounded failure diagnostics.
+	 */
+	readonly completion?: "successful-exit";
 	/** POSIX drop-privilege identity for the spawned process (root only). */
 	readonly uid?: number;
 	readonly gid?: number;
@@ -34,16 +44,62 @@ export function runLocalCommand(
 		});
 		let stdout = "";
 		let stderr = "";
+		let stdoutTruncated = false;
+		let stderrTruncated = false;
+		let settled = false;
+		let exitFallback: NodeJS.Immediate | undefined;
 		child.stdout.setEncoding("utf8");
 		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk: string) => {
-			stdout = boundedAppend(stdout, chunk);
-		});
-		child.stderr.on("data", (chunk: string) => {
-			stderr = boundedAppend(stderr, chunk);
-		});
-		child.once("error", reject);
-		child.once("close", (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+		const onStdout = (chunk: string): void => {
+			const appended = boundedAppend(stdout, chunk);
+			stdout = appended.value;
+			stdoutTruncated ||= appended.truncated;
+		};
+		const onStderr = (chunk: string): void => {
+			const appended = boundedAppend(stderr, chunk);
+			stderr = appended.value;
+			stderrTruncated ||= appended.truncated;
+		};
+		const cleanup = (): void => {
+			if (exitFallback !== undefined) clearImmediate(exitFallback);
+			child.off("error", onError);
+			child.off("exit", onExit);
+			child.off("close", onClose);
+			child.stdout.off("data", onStdout);
+			child.stderr.off("data", onStderr);
+			child.stdout.destroy();
+			child.stderr.destroy();
+		};
+		const finish = (code: number | null): void => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve({
+				exitCode: code ?? 1,
+				stdout,
+				stderr,
+				...(stdoutTruncated ? { stdoutTruncated: true as const } : {}),
+				...(stderrTruncated ? { stderrTruncated: true as const } : {}),
+			});
+		};
+		const onError = (error: Error): void => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onExit = (code: number | null): void => {
+			if (code !== 0) return;
+			// pg_ctl redirects server output with `-l`; only its successful child
+			// exit needs early settlement because Postgres can retain inherited EOF.
+			exitFallback = setImmediate(() => finish(code));
+		};
+		const onClose = (code: number | null): void => finish(code);
+		child.stdout.on("data", onStdout);
+		child.stderr.on("data", onStderr);
+		child.once("error", onError);
+		if (options?.completion === "successful-exit") child.once("exit", onExit);
+		child.once("close", onClose);
 	});
 }
 
@@ -71,7 +127,9 @@ export function tcpReachable(host: string, port: number, timeoutMs = 1_000): Pro
 	});
 }
 
-function boundedAppend(current: string, chunk: string): string {
+function boundedAppend(current: string, chunk: string): { readonly value: string; readonly truncated: boolean } {
 	const next = current + chunk;
-	return next.length <= OUTPUT_LIMIT_BYTES ? next : next.slice(-OUTPUT_LIMIT_BYTES);
+	return next.length <= OUTPUT_LIMIT_BYTES
+		? { value: next, truncated: false }
+		: { value: next.slice(-OUTPUT_LIMIT_BYTES), truncated: true };
 }

package/dist/builtin/workflows/src/extension/dispatcher.ts

@@ -29,6 +29,7 @@ import {
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import type { WorkflowToolArgs } from "./index.js";
 import type { WorkflowInputEntry, WorkflowToolResult } from "./render-result.js";
+import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
 
 type WorkflowRunResult = Extract<WorkflowToolResult, { action: "run" }>;
 
@@ -90,6 +91,10 @@ export interface DispatcherOpts {
 	cwd?: string;
 	/** Host-resolved non-default session directory inherited by stages without explicit sessionDir. */
 	defaultSessionDir?: string;
+	/** Cancels only startup admission waiting; the detached run keeps its own lifecycle. */
+	signal?: AbortSignal;
+	/** Reports the exact detached identity before startup admission is awaited. */
+	onRunAccepted?: (runId: string) => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -198,7 +203,8 @@ export async function dispatch(args: WorkflowToolArgs, opts: DispatcherOpts): Pr
 				return failedRunResult(def.name, runId, error instanceof Error ? error.message : String(error));
 			}
 			const { accepted } = launch;
-			const admission = await launch.wait;
+			opts.onRunAccepted?.(accepted.runId);
+			const admission = await raceWorkflowRequestAbort(launch.wait, opts.signal);
 			if (!admission.started) {
 				const activeStore = opts.store ?? defaultStore;
 				const snapshot = activeStore.runs().find((run) => run.id === accepted.runId);

package/dist/builtin/workflows/src/extension/extension-factory.ts

@@ -89,8 +89,8 @@ function factory(pi: ExtensionAPI): void {
 		runtimeState.ensureWorkflowResourcesLoaded,
 		{ resolvePostMortemDeps: (runId) => postMortemDepsForRun(runId, postMortemResolverDeps) },
 	);
-	const executeWorkflowToolWithAutoAttach: typeof executeWorkflowTool = async (args, ctx) => {
-		const result = await executeWorkflowTool(args, ctx);
+	const executeWorkflowToolWithAutoAttach: typeof executeWorkflowTool = async (args, ctx, signal, onRunAccepted) => {
+		const result = await executeWorkflowTool(args, ctx, signal, onRunAccepted);
 		if (
 			workflowPolicyFromContext(ctx).mode === "interactive" &&
 			typeof args.workflow === "string" &&