@mysten-incubation/devstack 0.0.0

package/dist/build-integrations/vitest/stack-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-context.mjs","names":["readStackContextRuntime"],"sources":["../../../src/build-integrations/vitest/stack-context.ts"],"sourcesContent":["// Stack-context loader for the vitest integration — thin wrapper\n// over `runtime/readStackContext`.\n//\n// The vitest preset is a passive reader of the supervisor's manifest.\n// Discovery, decode, and version-gate live in `runtime/`; this module\n// only:\n//   - resolves the vitest-flavored env contract (`DEVSTACK_RUNTIME_ROOT`\n//     plus legacy `DEVSTACK_STATE_DIR` alias),\n//   - exposes the manifest plus `endpoint(name)` / `displayEndpoint(name)`\n//     convenience accessors test bodies use,\n//   - re-shapes the canonical error tags into the vitest-flavored union\n//     (`VitestManifestNotFoundError` / `VitestManifestShapeError`) so\n//     caller `catchTag` flows stay stable.\n\nimport {\n\tmanifestEnvelopeFromStackContext,\n\tManifestDiscoveryError,\n\tManifestShapeError,\n\treadStackContext as readStackContextRuntime,\n\ttype StackContext as RuntimeStackContext,\n} from '../runtime/index.ts';\nimport type { ManifestEnvelope } from '../../substrate/manifest.ts';\nimport { VITEST_ENV_VARS } from './env.ts';\nimport { VitestManifestNotFoundError, VitestManifestShapeError } from './errors.ts';\n\n/** Read-only projection over the live manifest, scoped to the vitest\n *  surface's needs. The full envelope is reconstructed (`manifest`)\n *  for the test-side helpers that compare deep shapes; the convenience\n *  accessors cover the common case. */\nexport interface StackContext {\n\t/** Absolute path of the manifest file the projection came from. */\n\treadonly manifestPath: string;\n\t/** Reconstructed envelope — same shape downstream consumers had\n\t *  pre-consolidation. */\n\treadonly manifest: ManifestEnvelope;\n\t/** Identity tuple shortcut. */\n\treadonly identity: ManifestEnvelope['identity'];\n\t/** Flat endpoint lookup — returns the URL string or `undefined`. */\n\treadonly endpoint: (name: string) => string | undefined;\n\t/** Display URL variant — falls back to `url` when `displayUrl` is\n\t *  null (the routed-vs-direct distinction the router decides). */\n\treadonly displayEndpoint: (name: string) => string | undefined;\n}\n\nexport interface LoadStackContextOptions {\n\t/** Starting directory for the walk-up. Defaults to `process.cwd()`. */\n\treadonly cwd?: string;\n\t/** Stack name override. Defaults to `process.env.DEVSTACK_STACK`\n\t *  with a final fallback to `'main'`. */\n\treadonly stack?: string;\n\t/** Runtime root override (legacy `.devstack` directory). Defaults\n\t *  to `process.env.DEVSTACK_RUNTIME_ROOT` /\n\t *  `process.env.DEVSTACK_STATE_DIR` with a final fallback to\n\t *  `'.devstack'`. */\n\treadonly runtimeRoot?: string;\n\t/** Explicit absolute manifest path. Bypasses the walk-up but is\n\t *  still validated to exist. Lower precedence than the\n\t *  `DEVSTACK_MANIFEST_PATH` env var. */\n\treadonly manifestPath?: string;\n\t/** Env bag for the resolver. Defaults to `process.env`. Tests pass\n\t *  a fixture. */\n\treadonly env?: Readonly<Record<string, string | undefined>>;\n\t/** When `true`, throw `VitestManifestNotFoundError` on miss instead\n\t *  of returning `undefined`. */\n\treadonly required?: boolean;\n}\n\nconst project = (ctx: RuntimeStackContext): StackContext => {\n\tconst envelope: ManifestEnvelope = manifestEnvelopeFromStackContext(ctx);\n\treturn {\n\t\tmanifestPath: ctx.manifestPath,\n\t\tmanifest: envelope,\n\t\tidentity: envelope.identity,\n\t\tendpoint: (name) => ctx.endpoints.byName(name)?.url,\n\t\tdisplayEndpoint: (name) => {\n\t\t\tconst e = ctx.endpoints.byName(name);\n\t\t\tif (e === undefined) return undefined;\n\t\t\treturn e.displayUrl ?? e.url;\n\t\t},\n\t};\n};\n\n/**\n * Read the on-disk manifest, decode against the envelope schema, and\n * return a projection. Returns `undefined` on miss; pass\n * `{ required: true }` to throw `VitestManifestNotFoundError`.\n *\n * Precedence ladder (highest → lowest):\n *   1. `env.DEVSTACK_MANIFEST_PATH`\n *   2. `opts.manifestPath`\n *   3. walk-up from `opts.cwd` looking for\n *      `<runtimeRoot>/stacks/<stack>/manifest.json`\n */\nexport const loadStackContext = (opts: LoadStackContextOptions = {}): StackContext | undefined => {\n\tconst env = opts.env ?? (process.env as Readonly<Record<string, string | undefined>>);\n\tconst stack = opts.stack ?? env[VITEST_ENV_VARS.STACK] ?? 'main';\n\tconst runtimeRoot =\n\t\topts.runtimeRoot ??\n\t\tenv[VITEST_ENV_VARS.RUNTIME_ROOT] ??\n\t\tenv[VITEST_ENV_VARS.RUNTIME_ROOT_LEGACY] ??\n\t\t'.devstack';\n\n\ttry {\n\t\tconst ctx = readStackContextRuntime({\n\t\t\t...(opts.cwd !== undefined ? { cwd: opts.cwd } : {}),\n\t\t\tstack,\n\t\t\tstateDir: runtimeRoot,\n\t\t\tenv,\n\t\t\t...(opts.manifestPath !== undefined ? { manifestPath: opts.manifestPath } : {}),\n\t\t});\n\t\treturn project(ctx);\n\t} catch (err) {\n\t\tif (err instanceof ManifestDiscoveryError) {\n\t\t\tif (opts.required === true) {\n\t\t\t\tthrow new VitestManifestNotFoundError({\n\t\t\t\t\tmessage: `no devstack manifest found for stack '${stack}' under '${runtimeRoot}'`,\n\t\t\t\t\tsearchedFrom: opts.cwd ?? process.cwd(),\n\t\t\t\t\tstack,\n\t\t\t\t\tstateDir: runtimeRoot,\n\t\t\t\t\trecovery: `run \\`devstack up\\` (or set DEVSTACK_MANIFEST_PATH to an existing file)`,\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\t\tif (err instanceof ManifestShapeError) {\n\t\t\t// The runtime tags both decode-failure and version-mismatch as\n\t\t\t// `phase: 'parse' | 'shape' | 'version'`. The vitest error\n\t\t\t// union exposes `parse` and `shape`; map `version` onto\n\t\t\t// `shape` with a recovery hint that names the version-bump\n\t\t\t// recipe.\n\t\t\tconst phase: 'parse' | 'shape' = err.phase === 'parse' ? 'parse' : 'shape';\n\t\t\tthrow new VitestManifestShapeError({\n\t\t\t\tphase,\n\t\t\t\tpath: err.path,\n\t\t\t\tmessage: err.message,\n\t\t\t\trecovery:\n\t\t\t\t\terr.phase === 'parse'\n\t\t\t\t\t\t? `rm ${err.path} && devstack apply  # regenerate from the registries`\n\t\t\t\t\t\t: `rm -rf <runtimeRoot>/stacks/<stack>/manifest.json && devstack apply  # regenerate`,\n\t\t\t\tcause: err,\n\t\t\t});\n\t\t}\n\t\tthrow err;\n\t}\n};\n"],"mappings":";;;;;AAmEA,MAAM,WAAW,QAA2C;CAC3D,MAAM,WAA6B,iCAAiC,IAAI;AACxE,QAAO;EACN,cAAc,IAAI;EAClB,UAAU;EACV,UAAU,SAAS;EACnB,WAAW,SAAS,IAAI,UAAU,OAAO,KAAK,EAAE;EAChD,kBAAkB,SAAS;GAC1B,MAAM,IAAI,IAAI,UAAU,OAAO,KAAK;AACpC,OAAI,MAAM,KAAA,EAAW,QAAO,KAAA;AAC5B,UAAO,EAAE,cAAc,EAAE;;EAE1B;;;;;;;;;;;;;AAcF,MAAa,oBAAoB,OAAgC,EAAE,KAA+B;CACjG,MAAM,MAAM,KAAK,OAAQ,QAAQ;CACjC,MAAM,QAAQ,KAAK,SAAS,IAAI,gBAAgB,UAAU;CAC1D,MAAM,cACL,KAAK,eACL,IAAI,gBAAgB,iBACpB,IAAI,gBAAgB,wBACpB;AAED,KAAI;AAQH,SAAO,QAPKA,iBAAwB;GACnC,GAAI,KAAK,QAAQ,KAAA,IAAY,EAAE,KAAK,KAAK,KAAK,GAAG,EAAE;GACnD;GACA,UAAU;GACV;GACA,GAAI,KAAK,iBAAiB,KAAA,IAAY,EAAE,cAAc,KAAK,cAAc,GAAG,EAAE;GAC9E,CACiB,CAAC;UACX,KAAK;AACb,MAAI,eAAe,wBAAwB;AAC1C,OAAI,KAAK,aAAa,KACrB,OAAM,IAAI,4BAA4B;IACrC,SAAS,yCAAyC,MAAM,WAAW,YAAY;IAC/E,cAAc,KAAK,OAAO,QAAQ,KAAK;IACvC;IACA,UAAU;IACV,UAAU;IACV,CAAC;AAEH;;AAED,MAAI,eAAe,mBAOlB,OAAM,IAAI,yBAAyB;GAClC,OAFgC,IAAI,UAAU,UAAU,UAAU;GAGlE,MAAM,IAAI;GACV,SAAS,IAAI;GACb,UACC,IAAI,UAAU,UACX,MAAM,IAAI,KAAK,wDACf;GACJ,OAAO;GACP,CAAC;AAEH,QAAM"}

package/dist/cli/main.d.mts

@@ -0,0 +1,5 @@
+//#region src/cli/main.d.ts
+declare const runCli: (argv?: ReadonlyArray<string>) => Promise<void>;
+//#endregion
+export { runCli };
+//# sourceMappingURL=main.d.mts.map

package/dist/cli/main.mjs

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+import { StackPathsService } from "../substrate/runtime/paths.mjs";
+import { appName, chainId, stackName } from "../substrate/brand.mjs";
+import { claim, heartbeatFiber, release } from "../substrate/runtime/cross-process/roster.mjs";
+import { readStackEngine } from "../api/define-devstack.mjs";
+import { makeProjectionRef } from "../substrate/runtime/projection/state-ref.mjs";
+import { persistProjectionChanges, readProjectionSnapshot, writeProjectionSnapshot } from "../substrate/runtime/projection/persisted.mjs";
+import { buildSubstrateLayers, superviseStackEffect } from "../substrate/runtime/run.mjs";
+import { commandChannelPaths, makeCommandChannelPublisher, makeCommandChannelSubscriber } from "../substrate/runtime/cross-process/command-channel/channel.mjs";
+import { SnapshotOrchestratorService } from "../orchestrators/snapshot/service.mjs";
+import { buildProductionOrchestratorSinks, buildProductionPostAcquireHook, layerProductionOrchestrators } from "../orchestrators/runtime-composition.mjs";
+import { extendBuiltInPluginContext, layerBuiltInPluginRuntime } from "../runtime/built-in-plugin-layers.mjs";
+import { resolveAppName, resolveStackName } from "../api/inference-network.mjs";
+import { ExitCode } from "../surfaces/cli/sysexits.mjs";
+import { CliConfigInvalidError, CliConfigNotFoundError, CliSupervisorLiveError } from "../surfaces/cli/errors.mjs";
+import { removeRouterDispatchFilesForStack } from "../orchestrators/router/cleanup.mjs";
+import { probeSupervisorPresence } from "../surfaces/cli/commands/supervisor-presence.mjs";
+import { defaultProbes } from "../surfaces/cli/commands/doctor-probes.mjs";
+import { dispatch } from "../surfaces/cli/index.mjs";
+import { nodeConfirmPrompt } from "../surfaces/cli/commands/confirm-node.mjs";
+import { makeTuiSurface } from "../surfaces/tui/index.mjs";
+import { makeSnapshotReader } from "./snapshot-reader.mjs";
+import { makeQueueCommandPublisher, resolveUpRendererMode } from "./up-lifecycle.mjs";
+import { makeDirectPruneDeps } from "./prune-direct.mjs";
+import { Cause, Effect, Exit, FileSystem, Layer, Logger, Queue, Stream, SubscriptionRef } from "effect";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/cli/main.ts
+const DEFAULT_CONFIG_PATH = "./devstack.config.ts";
+const LIVE_APPLY_ACK_TIMEOUT_MILLIS = 600 * 1e3;
+const stackRootFor = (runtimeRoot, stack) => resolve(runtimeRoot, "stacks", stack);
+const rosterPathsFor = (stackRoot) => ({
+	stackLockFile: resolve(stackRoot, "stack.lock"),
+	rosterFile: resolve(stackRoot, "roster.json")
+});
+const ENGINE_COMMAND_TAGS = new Set([
+	"stack.start",
+	"stack.stop",
+	"stack.restart",
+	"apply.requested",
+	"codegen.requested",
+	"snapshot.capture",
+	"snapshot.restore",
+	"snapshot.list",
+	"snapshot.delete",
+	"wipe.requested",
+	"prune.requested",
+	"advance-clock.requested",
+	"shutdown.requested",
+	"shutdown.hardKillRequested",
+	"selective-restart.requested"
+]);
+const hasString = (value, key) => typeof value[key] === "string";
+const isEngineCommand = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	if (typeof record.tag !== "string" || !ENGINE_COMMAND_TAGS.has(record.tag)) return false;
+	switch (record.tag) {
+		case "snapshot.restore":
+		case "snapshot.delete": return hasString(record, "snapshotId");
+		case "advance-clock.requested": return typeof record.toMillis === "number";
+		case "shutdown.hardKillRequested": return (record.signal === "SIGINT" || record.signal === "SIGTERM") && typeof record.exitCode === "number" && typeof record.at === "number";
+		case "selective-restart.requested": return hasString(record, "pluginKey");
+		case "apply.requested": return record.pluginKey === void 0 || typeof record.pluginKey === "string";
+		case "snapshot.capture": return (record.snapshotId === void 0 || typeof record.snapshotId === "string") && (record.name === void 0 || typeof record.name === "string");
+		default: return true;
+	}
+};
+const findCliSupervisorLiveError = (cause) => {
+	for (const reason of cause.reasons) {
+		if (!Cause.isFailReason(reason)) continue;
+		const error = reason.error;
+		if (error instanceof CliSupervisorLiveError) return error;
+		if (typeof error === "object" && error !== null && error._tag === "CliSupervisorLiveError") return error;
+	}
+	return null;
+};
+const resolveConfigPath = (configPath) => {
+	const target = configPath ?? DEFAULT_CONFIG_PATH;
+	const explicit = isAbsolute(target) ? target : resolve(process.cwd(), target);
+	if (existsSync(explicit)) return explicit;
+	if (configPath !== void 0 && configPath !== DEFAULT_CONFIG_PATH) return null;
+	let dir = process.cwd();
+	for (;;) {
+		const candidate = resolve(dir, "devstack.config.ts");
+		if (existsSync(candidate)) return candidate;
+		const parent = resolve(dir, "..");
+		if (parent === dir) return null;
+		dir = parent;
+	}
+};
+const validateStackModule = (resolvedConfigPath, mod) => {
+	const def = mod.default;
+	if (def === null || typeof def !== "object" || def._tag !== "Stack") throw new CliConfigInvalidError({ message: `config at ${resolvedConfigPath} does not default-export a Stack value (got _tag=${String(def?._tag)})` });
+	let stack;
+	try {
+		stack = readStackEngine(def);
+	} catch (cause) {
+		throw new CliConfigInvalidError({ message: `config at ${resolvedConfigPath} default-exported an invalid Stack handle: ${cause instanceof Error ? cause.message : String(cause)}` });
+	}
+	return {
+		stack,
+		resolvedConfigPath
+	};
+};
+const makeConfigLoader = () => ({ load: (configPath) => Effect.gen(function* () {
+	const abs = resolveConfigPath(configPath);
+	if (abs === null) {
+		const attempted = configPath !== void 0 ? resolve(process.cwd(), configPath) : resolve(process.cwd(), DEFAULT_CONFIG_PATH);
+		return yield* Effect.fail(new CliConfigNotFoundError({
+			message: `devstack config not found at ${attempted}`,
+			searchedPaths: [attempted]
+		}));
+	}
+	const url = pathToFileURL(abs).href;
+	const mod = yield* Effect.tryPromise({
+		try: () => import(url),
+		catch: (cause) => new CliConfigInvalidError({
+			message: `failed to import ${abs}: ${cause instanceof Error ? cause.message : String(cause)}`,
+			cause
+		})
+	});
+	return yield* Effect.try({
+		try: () => validateStackModule(abs, mod),
+		catch: (cause) => cause instanceof CliConfigInvalidError ? cause : new CliConfigInvalidError({
+			message: `invalid config at ${abs}`,
+			cause
+		})
+	});
+}) });
+/** Resolve identity from flags + env. App and stack fall through the
+*  shared cwd/package metadata resolver before their defaults. */
+const resolveIdentity = (params) => {
+	const cwd = params.cwd ?? process.cwd();
+	const app = resolveAppName({
+		explicit: params.app,
+		cwd
+	});
+	const runtimeRoot = resolve(params.stateDir ?? process.env.DEVSTACK_STATE_DIR ?? resolve(process.env.HOME ?? process.cwd(), ".devstack"));
+	const stacksRoot = resolve(runtimeRoot, "stacks");
+	const stack = resolveStackName({
+		explicit: params.stack,
+		cwd
+	});
+	const network = params.network ?? process.env.DEVSTACK_NETWORK ?? "sui:local";
+	const stackRoot = resolve(stacksRoot, stack);
+	return {
+		app,
+		stack,
+		network,
+		runtimeRoot,
+		stacksRoot,
+		stackRoot,
+		rosterFile: resolve(stackRoot, "roster.json")
+	};
+};
+const projectionStatusReader = (identity) => ({ readState: (_app, _stack) => Effect.sync(() => readProjectionSnapshot(identity.stackRoot)) });
+const commandResultFromProcess = () => ({ exitCode: typeof process.exitCode === "number" ? process.exitCode : 0 });
+const buildDirectDeps = (identity) => {
+	const loader = makeConfigLoader();
+	return {
+		up: { run: (flags) => runUpLive(flags.configPath, identity, {
+			renderer: flags.renderer,
+			stdoutIsTty: Boolean(process.stdout.isTTY)
+		}).pipe(Effect.map(() => commandResultFromProcess())) },
+		apply: { run: (flags) => runApplyLive(flags.configPath, identity).pipe(Effect.map(() => commandResultFromProcess())) },
+		status: { reader: projectionStatusReader(identity) },
+		snapshot: makeDirectSnapshotDeps(identity),
+		prune: makeDirectPruneDeps({ runtimeRoot: identity.runtimeRoot }),
+		doctor: { probes: defaultProbes({
+			stateDir: identity.runtimeRoot,
+			appRoot: identity.stacksRoot
+		}) },
+		config: { loader },
+		wipe: {
+			wipe: () => runWipeDirect(identity),
+			confirm: nodeConfirmPrompt
+		}
+	};
+};
+const makeSnapshotCommandHandler = (params) => {
+	const provideFileSystem = (effect) => effect.pipe(Effect.provideService(FileSystem.FileSystem, params.fs));
+	return (cmd, handlerCtx) => {
+		switch (cmd.tag) {
+			case "snapshot.capture": return provideFileSystem(params.snapshot.capture({
+				id: cmd.snapshotId,
+				label: cmd.name,
+				onProgress: (progress) => handlerCtx.publish({
+					tag: "snapshot.captureProgress",
+					...cmd.snapshotId === void 0 ? {} : { snapshotId: cmd.snapshotId },
+					...cmd.name === void 0 ? {} : { name: cmd.name },
+					phase: progress.phase,
+					...progress.detail === void 0 ? {} : { detail: progress.detail },
+					...progress.pausedContainers === void 0 ? {} : { pausedContainers: progress.pausedContainers },
+					...progress.totalContainers === void 0 ? {} : { totalContainers: progress.totalContainers },
+					at: Date.now()
+				})
+			})).pipe(Effect.map((meta) => [{
+				tag: "snapshot.captured",
+				snapshotId: meta.id,
+				...meta.label === null ? {} : { name: meta.label },
+				at: Date.now()
+			}]));
+			case "snapshot.restore": return provideFileSystem(params.snapshot.restore({ id: cmd.snapshotId })).pipe(Effect.map((meta) => [{
+				tag: "snapshot.restored",
+				snapshotId: meta.id,
+				at: Date.now()
+			}]));
+			case "snapshot.list": return provideFileSystem(params.snapshot.list).pipe(Effect.as([]));
+			case "snapshot.delete": return provideFileSystem(params.snapshot.delete(cmd.snapshotId)).pipe(Effect.as([]));
+			case "wipe.requested": return provideFileSystem(params.snapshot.wipe({})).pipe(Effect.as([]));
+			case "prune.requested": return provideFileSystem(params.snapshot.prune({})).pipe(Effect.as([]));
+			default: return Effect.succeed([]);
+		}
+	};
+};
+const installLiveSupervisorRoster = (params) => Effect.gen(function* () {
+	const paths = rosterPathsFor(params.stackRoot);
+	if (!(yield* claim(paths)).soleHolder) {
+		yield* release(paths).pipe(Effect.catch(() => Effect.void));
+		return yield* Effect.fail(new CliSupervisorLiveError({
+			app: params.app,
+			stack: params.stack,
+			hint: "use `devstack apply` from another shell, or choose a different --stack name"
+		}));
+	}
+	yield* Effect.addFinalizer(() => release(paths).pipe(Effect.catch(() => Effect.void)));
+	yield* Effect.forkScoped(heartbeatFiber(paths));
+});
+const installCommandChannelBridge = (params) => Effect.gen(function* () {
+	const subscriber = yield* makeCommandChannelSubscriber(commandChannelPaths(params.stackRoot), { fromOffset: "current" });
+	yield* Effect.forkScoped(subscriber.commands.pipe(Stream.runForEach((record) => Effect.gen(function* () {
+		if (!isEngineCommand(record.command)) {
+			yield* subscriber.fail(record.id, "invalid command", "command payload did not match EngineCommand").pipe(Effect.catch(() => Effect.void));
+			return;
+		}
+		yield* params.handle.runCommand(record.command).pipe(Effect.andThen(subscriber.ack(record.id)), Effect.catchCause((cause) => subscriber.fail(record.id, "command failed", Cause.pretty(cause)).pipe(Effect.catch(() => Effect.void))));
+	})), Effect.catchCause((cause) => Effect.sync(() => {
+		process.stderr.write(`command channel failed: ${Cause.pretty(cause)}\n`);
+	}))));
+	return { publishEvent: (event) => subscriber.publishEvent(event).pipe(Effect.catch(() => Effect.void)) };
+});
+/**
+* Run `devstack up`. Wires the substrate Layer stack, supervisor,
+* attached renderer, and in-process TUI command queue. The Effect runs
+* as the outer Node fiber so SIGINT reaches scope finalizers.
+*/
+const runUpLive = (configPath, identity, options) => {
+	const loader = makeConfigLoader();
+	return Effect.gen(function* () {
+		const loaded = yield* loader.load(configPath).pipe(Effect.catch((err) => Effect.sync(() => {
+			process.stderr.write(`error: ${err.message}\n`);
+			process.exitCode = err._tag === "CliConfigNotFoundError" ? 66 : 78;
+			return null;
+		})));
+		if (loaded === null) return;
+		const stack = loaded.stack;
+		const identityValue = {
+			app: appName(identity.app),
+			stack: stackName(stack.options.stackName ?? identity.stack),
+			chain: chainId(identity.network)
+		};
+		const appRoot = dirname(loaded.resolvedConfigPath);
+		const rendererMode = resolveUpRendererMode({
+			cliRenderer: options.renderer,
+			stackRenderer: stack.options.renderer,
+			stdoutIsTty: options.stdoutIsTty
+		});
+		const substrateLayers = layerProductionOrchestrators({ codegen: {
+			appRoot,
+			outputDir: stack.options.codegen?.outputDir,
+			stackSubdir: stack.options.codegen?.stackSubdir ?? null
+		} }).pipe(Layer.provideMerge(buildSubstrateLayers(identityValue, identity.runtimeRoot)));
+		yield* Effect.gen(function* () {
+			const state = yield* makeProjectionRef();
+			const snapshotCommandHandler = makeSnapshotCommandHandler({
+				snapshot: yield* SnapshotOrchestratorService,
+				fs: yield* FileSystem.FileSystem
+			});
+			const orchestratorSinks = yield* buildProductionOrchestratorSinks();
+			const postAcquireHook = yield* buildProductionPostAcquireHook({ extras: stack.options.extras });
+			yield* superviseStackEffect({
+				_tag: "Stack",
+				members: stack.members,
+				options: stack.options
+			}, identityValue, state, {
+				orchestratorSinks,
+				commandHandler: snapshotCommandHandler,
+				postAcquireHook,
+				extendContext: extendBuiltInPluginContext,
+				beforeInitialAcquire: (handle) => Effect.gen(function* () {
+					const stackPaths = yield* StackPathsService;
+					const commandChannel = yield* installCommandChannelBridge({
+						stackRoot: stackPaths.stackRoot,
+						handle
+					});
+					yield* installLiveSupervisorRoster({
+						stackRoot: stackPaths.stackRoot,
+						app: String(identityValue.app),
+						stack: String(identityValue.stack)
+					});
+					const rendererEvents = yield* Queue.unbounded();
+					const renderer = makeTuiSurface({
+						mode: rendererMode,
+						publishCommand: makeQueueCommandPublisher(handle.commands)
+					});
+					yield* Effect.addFinalizer(() => renderer.flush.pipe(Effect.catch(() => Effect.void)));
+					yield* Effect.forkScoped(renderer.mount(handle.state, Stream.fromQueue(rendererEvents)).pipe(Effect.catch((cause) => Effect.sync(() => {
+						process.stderr.write(`renderer failed: ${cause.detail ?? String(cause)}\n`);
+					}))));
+					yield* Effect.forkScoped(persistProjectionChanges(stackPaths.stackRoot, handle.state));
+					yield* Effect.forkScoped(Stream.fromQueue(handle.events).pipe(Stream.runForEach((event) => Effect.gen(function* () {
+						yield* Queue.offer(rendererEvents, event);
+						yield* commandChannel.publishEvent(event);
+					}))));
+				})
+			}).pipe(Effect.provide(layerBuiltInPluginRuntime(orchestratorSinks)));
+		}).pipe(Effect.provide(substrateLayers), Effect.provide(Logger.layer([])), Effect.matchCauseEffect({
+			onFailure: (cause) => Effect.sync(() => {
+				const live = findCliSupervisorLiveError(cause);
+				if (live !== null) {
+					process.stderr.write(`error: supervisor live for ${live.app}/${live.stack}\n`);
+					if (live.hint !== void 0) process.stderr.write(`hint: ${live.hint}\n`);
+					process.exitCode = ExitCode.SUPERVISOR_LIVE;
+					return;
+				}
+				process.stderr.write(`\nerror: stack failed\n${Cause.pretty(cause)}\n`);
+				process.exitCode = 1;
+			}),
+			onSuccess: () => Effect.sync(() => {
+				process.exitCode ??= 0;
+			})
+		}));
+	});
+};
+const runApplyAgainstLiveSupervisor = (identity, identityValue) => Effect.gen(function* () {
+	const stackRoot = stackRootFor(identity.runtimeRoot, String(identityValue.stack));
+	if (!(yield* probeSupervisorPresence(resolve(stackRoot, "roster.json")).pipe(Effect.catch(() => Effect.succeed({
+		live: false,
+		pid: null,
+		hostname: null
+	})))).live) return false;
+	const exit = yield* Effect.exit(Effect.gen(function* () {
+		const publisher = yield* makeCommandChannelPublisher(commandChannelPaths(stackRoot));
+		const published = yield* publisher.publish({ tag: "apply.requested" });
+		const reply = yield* publisher.awaitCompletion(published.id, { timeoutMillis: LIVE_APPLY_ACK_TIMEOUT_MILLIS });
+		if (!reply.ok) return yield* Effect.fail(reply.message);
+	}));
+	if (Exit.isFailure(exit)) {
+		process.stderr.write(`\nerror: live stack apply failed\n${Cause.pretty(exit.cause)}\n`);
+		process.exitCode = 1;
+		return true;
+	}
+	process.exitCode ??= 0;
+	return true;
+});
+const runApplyLive = (configPath, identity) => {
+	const loader = makeConfigLoader();
+	return Effect.gen(function* () {
+		const loaded = yield* loader.load(configPath).pipe(Effect.matchEffect({
+			onFailure: (err) => Effect.gen(function* () {
+				process.stderr.write(`error: ${err.message}\n`);
+				process.exitCode = err._tag === "CliConfigNotFoundError" ? 66 : 78;
+				return yield* Effect.fail("config-load-failed");
+			}),
+			onSuccess: (v) => Effect.succeed(v)
+		}));
+		const stack = loaded.stack;
+		const identityValue = {
+			app: appName(identity.app),
+			stack: stackName(stack.options.stackName ?? identity.stack),
+			chain: chainId(identity.network)
+		};
+		if (yield* runApplyAgainstLiveSupervisor(identity, identityValue)) return;
+		const substrateLayers = layerProductionOrchestrators({ codegen: {
+			appRoot: dirname(loaded.resolvedConfigPath),
+			outputDir: stack.options.codegen?.outputDir,
+			stackSubdir: stack.options.codegen?.stackSubdir ?? null
+		} }).pipe(Layer.provideMerge(buildSubstrateLayers(identityValue, identity.runtimeRoot)));
+		yield* Effect.gen(function* () {
+			const state = yield* makeProjectionRef();
+			const orchestratorSinks = yield* buildProductionOrchestratorSinks();
+			const postAcquireHook = yield* buildProductionPostAcquireHook({ extras: stack.options.extras });
+			yield* superviseStackEffect({
+				_tag: "Stack",
+				members: stack.members,
+				options: stack.options
+			}, identityValue, state, {
+				orchestratorSinks,
+				postAcquireHook,
+				lifetime: "one-shot",
+				extendContext: extendBuiltInPluginContext
+			}).pipe(Effect.provide(layerBuiltInPluginRuntime(orchestratorSinks)));
+			yield* writeProjectionSnapshot((yield* StackPathsService).stackRoot, yield* SubscriptionRef.get(state));
+		}).pipe(Effect.provide(substrateLayers), Effect.provide(Logger.layer([Logger.consolePretty()])), Effect.matchCauseEffect({
+			onFailure: (cause) => Effect.sync(() => {
+				process.stderr.write(`\nerror: stack apply failed\n${Cause.pretty(cause)}\n`);
+				process.exitCode = 1;
+			}),
+			onSuccess: () => Effect.sync(() => {
+				process.exitCode ??= 0;
+			})
+		}));
+	}).pipe(Effect.catch(() => Effect.void));
+};
+const snapshotIdentityParticipants = (meta) => Object.entries(meta.identity).map(([plugin, value]) => ({
+	plugin,
+	liveIdentity: Effect.succeed({ [plugin]: value })
+}));
+const identityValueFor = (identity, stack) => ({
+	app: appName(identity.app),
+	stack: stackName(stack?.options.stackName ?? identity.stack),
+	chain: chainId(identity.network)
+});
+const directSnapshotLayers = (identity) => layerProductionOrchestrators().pipe(Layer.provideMerge(buildSubstrateLayers(identityValueFor(identity), identity.runtimeRoot)));
+const provideFileSystem = (fs, effect) => effect.pipe(Effect.provideService(FileSystem.FileSystem, fs));
+const ensureNoLiveSupervisor = (identity, hint) => Effect.gen(function* () {
+	if ((yield* probeSupervisorPresence(identity.rosterFile).pipe(Effect.catch(() => Effect.succeed({
+		live: false,
+		pid: null,
+		hostname: null
+	})))).live) return yield* Effect.fail(new CliSupervisorLiveError({
+		app: identity.app,
+		stack: identity.stack,
+		hint
+	}));
+});
+const runSnapshotRestoreDirect = (identity, snapshotId) => {
+	const restored = Effect.gen(function* () {
+		const snapshot = yield* SnapshotOrchestratorService;
+		const fs = yield* FileSystem.FileSystem;
+		const meta = (yield* provideFileSystem(fs, snapshot.list)).find((entry) => entry.id === snapshotId)?.metadata ?? null;
+		const participants = meta === null ? [] : snapshotIdentityParticipants(meta);
+		yield* provideFileSystem(fs, snapshot.restore({
+			id: snapshotId,
+			participants
+		}));
+	}).pipe(Effect.provide(directSnapshotLayers(identity)), Effect.provide(Logger.layer([Logger.consolePretty()])));
+	return ensureNoLiveSupervisor(identity, "shut down the attached `devstack up` session before restoring a snapshot").pipe(Effect.andThen(restored));
+};
+const runSnapshotDeleteDirect = (identity, snapshotId) => {
+	return Effect.gen(function* () {
+		const snapshot = yield* SnapshotOrchestratorService;
+		yield* provideFileSystem(yield* FileSystem.FileSystem, snapshot.delete(snapshotId));
+	}).pipe(Effect.provide(directSnapshotLayers(identity)), Effect.provide(Logger.layer([Logger.consolePretty()])));
+};
+const runSnapshotCaptureDirect = (identity, args) => {
+	const loader = makeConfigLoader();
+	return Effect.gen(function* () {
+		const loaded = yield* loader.load(args.configPath);
+		const stack = loaded.stack;
+		const identityValue = identityValueFor(identity, stack);
+		const substrateLayers = layerProductionOrchestrators({ codegen: {
+			appRoot: dirname(loaded.resolvedConfigPath),
+			outputDir: stack.options.codegen?.outputDir,
+			stackSubdir: stack.options.codegen?.stackSubdir ?? null
+		} }).pipe(Layer.provideMerge(buildSubstrateLayers(identityValue, identity.runtimeRoot)));
+		return yield* Effect.gen(function* () {
+			const state = yield* makeProjectionRef();
+			const snapshot = yield* SnapshotOrchestratorService;
+			const fs = yield* FileSystem.FileSystem;
+			const orchestratorSinks = yield* buildProductionOrchestratorSinks();
+			const postAcquireHook = yield* buildProductionPostAcquireHook({ extras: stack.options.extras });
+			let captureExit = Exit.succeed(void 0);
+			const capturedMeta = { current: null };
+			yield* superviseStackEffect({
+				_tag: "Stack",
+				members: stack.members,
+				options: stack.options
+			}, identityValue, state, {
+				orchestratorSinks,
+				postAcquireHook,
+				lifetime: "one-shot",
+				extendContext: extendBuiltInPluginContext,
+				withinScope: () => provideFileSystem(fs, snapshot.capture({
+					id: args.snapshotId,
+					label: args.name
+				})).pipe(Effect.tap((meta) => Effect.sync(() => {
+					capturedMeta.current = meta;
+				})), Effect.asVoid, Effect.exit, Effect.tap((exit) => Effect.sync(() => {
+					captureExit = exit;
+				})), Effect.asVoid)
+			}).pipe(Effect.provide(layerBuiltInPluginRuntime(orchestratorSinks)));
+			if (Exit.isFailure(captureExit)) yield* Effect.failCause(captureExit.cause);
+			if (capturedMeta.current === null) return yield* Effect.die("snapshot capture completed without metadata");
+			const meta = capturedMeta.current;
+			yield* writeProjectionSnapshot((yield* StackPathsService).stackRoot, yield* SubscriptionRef.get(state));
+			return {
+				snapshotId: meta.id,
+				name: meta.label ?? meta.id
+			};
+		}).pipe(Effect.provide(substrateLayers), Effect.provide(Logger.layer([Logger.consolePretty()])));
+	});
+};
+const makeDirectSnapshotDeps = (identity) => ({
+	reader: makeSnapshotReader(identity),
+	capture: (args) => runSnapshotCaptureDirect(identity, args),
+	restore: (snapshotId) => runSnapshotRestoreDirect(identity, snapshotId),
+	delete: (snapshotId) => runSnapshotDeleteDirect(identity, snapshotId),
+	confirm: nodeConfirmPrompt
+});
+const runWipeDirect = (identity) => Effect.gen(function* () {
+	yield* ensureNoLiveSupervisor(identity, "shut down the attached `devstack up` session first");
+	return yield* Effect.gen(function* () {
+		const snapshot = yield* SnapshotOrchestratorService;
+		yield* provideFileSystem(yield* FileSystem.FileSystem, snapshot.wipe({}));
+		yield* removeRouterDispatchFilesForStack({
+			runtimeRoot: identity.runtimeRoot,
+			app: identity.app,
+			stack: identity.stack
+		});
+	}).pipe(Effect.provide(directSnapshotLayers(identity)), Effect.provide(Logger.layer([Logger.consolePretty()])));
+});
+const identityInputsFromArgv = (argv, env) => {
+	let app = env.DEVSTACK_APP;
+	let stack = env.DEVSTACK_STACK;
+	let network = env.DEVSTACK_NETWORK;
+	let stateDir = env.DEVSTACK_STATE_DIR;
+	let configPath = env.DEVSTACK_CONFIG;
+	for (let i = 0; i < argv.length; i += 1) {
+		const token = argv[i];
+		const readValue = (name) => {
+			if (token.startsWith(`--${name}=`)) return token.slice(name.length + 3);
+			if (token === `--${name}`) return argv[i + 1];
+		};
+		app = readValue("app") ?? app;
+		stack = readValue("stack") ?? stack;
+		network = readValue("network") ?? network;
+		stateDir = readValue("state-dir") ?? stateDir;
+		configPath = readValue("config") ?? configPath;
+	}
+	return {
+		app,
+		stack,
+		network,
+		stateDir,
+		configPath
+	};
+};
+const identityCwdFromConfig = (configPath) => {
+	const resolved = resolveConfigPath(configPath);
+	return resolved === null ? process.cwd() : dirname(resolved);
+};
+const runCli = async (argv = process.argv.slice(2)) => {
+	const stdinIsTty = Boolean(process.stdin.isTTY);
+	const env = { ...process.env };
+	const identityInputs = identityInputsFromArgv(argv, env);
+	const identity = resolveIdentity({
+		app: identityInputs.app,
+		stack: identityInputs.stack,
+		network: identityInputs.network,
+		stateDir: identityInputs.stateDir,
+		cwd: identityCwdFromConfig(identityInputs.configPath)
+	});
+	const deps = buildDirectDeps(identity);
+	await Effect.runPromise(dispatch(deps, {
+		argv,
+		env: {
+			...env,
+			DEVSTACK_APP: identity.app,
+			DEVSTACK_STACK: identity.stack,
+			DEVSTACK_STATE_DIR: identity.runtimeRoot
+		},
+		stdinIsTty
+	}));
+};
+const isMainEntrypoint = () => {
+	const argvPath = process.argv[1];
+	if (argvPath === void 0) return false;
+	try {
+		return realpathSync(argvPath) === realpathSync(fileURLToPath(import.meta.url));
+	} catch {
+		return import.meta.url === pathToFileURL(argvPath).href;
+	}
+};
+if (isMainEntrypoint()) runCli().catch((err) => {
+	process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}\n`);
+	process.exitCode = 1;
+}).then(() => {
+	process.exit(process.exitCode ?? 0);
+});
+//#endregion
+export { runCli };
+
+//# sourceMappingURL=main.mjs.map