@prisma/composer-cli 0.25.0-dev.5 → 0.26.0-dev.1

package/dist/family.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"family.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/family.d.mts"],"mappings":";;;;;cAKc;UACJ;;;;;;WAMC;WACA,aAAa;;iBAEP,kBAAkB,MAAM,kBAAkB;;;;;;;;;;;;iBAY1C,eAAe,yBAAyB,MAAM,aAAa,MAAM,iBAAiB,QAAQ,cAAc;;;cAG3G,iBAAiB,cAAc;;;;;;;;KAQxC,gBAAA;;iBAEY,cAAc,OAAO,gBAAgB"}
+{"version":3,"file":"family.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/family.d.mts"],"mappings":";;;;;cAKc,iBAAiB,cAAc;;;;;;;;KAQxC,gBAAA;;iBAEY,cAAc,OAAO,gBAAgB"}

package/dist/family.mjs

@@ -1,64 +1,8 @@
-import { i as checkComposerConfig, s as sectionMissing, t as notOk$1 } from "./result-D9vIrN7i.mjs";
-import { n as executorLoadFailure, t as executionDiagnostics } from "./shared-BAIiDgXa-DYP7EOSk.mjs";
-import { t as alchemyCommandLine } from "./run-alchemy-pANK8XNX-T_pHNDBo.mjs";
-import spawn from "cross-spawn";
-import { EnvironmentCredentialManager, createCli, defineCommand, defineCommandFamily, defineConfigSection, defineSessionCommand, exitWithChildStatus, flag, loadConfig, positional } from "@prisma/cli-engine";
+import { i as sectionMissing, t as checkComposerConfig } from "./composer-config-CY9fET8H-KpGjlYgO.mjs";
+import { a as devWithDeps, i as deployWithDeps, o as executionDiagnostics, t as alchemyCommandLine } from "./run-alchemy-BEvB2sYQ-BgV2deuO.mjs";
+import { defineCommand, defineCommandFamily, defineConfigSection, defineSessionCommand, exitWithChildStatus, flag, positional } from "@prisma/cli-engine";
 import { CliStructuredError, notOk, ok } from "@prisma/cli-engine/protocol";
-//#region ../../0-framework/3-tooling/cli/dist/log-BS2_AjVM.mjs
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function deployWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-deploy-destroy-CF6DR7sA-DGs5poBA.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("deploy", error));
-	}
-	return executor.executeDeploy(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function destroyWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-deploy-destroy-CF6DR7sA-DGs5poBA.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("destroy", error));
-	}
-	return executor.executeDestroy(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function devWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-dev-DAIUT0es-DTdnJdOi.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("dev", error));
-	}
-	return executor.executeDev(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's LogRunDeps,
-* unit tests). Deliberately NOT re-exported through `./control` — the seam
-* mirrors internal types and is not part of the published surface. */
-async function logWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-log-PLs9-Qn3-BUBx5KmY.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("log", error));
-	}
-	return executor.executeLog(input, deps, cwd);
-}
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/engine-cli-Cxpb67l7.mjs
+//#region ../../0-framework/3-tooling/cli/dist/family.mjs
 /**
 * The family boundary's error translation.
 *
@@ -141,7 +85,7 @@ function reproduceHint(failure) {
 	}];
 }
 /**
-* How a FAILED converge settles. `deploy`, `destroy` and `dev` all end this
+* How a FAILED converge settles. `deploy` and `dev` both end this
 * way and must not drift apart, so the decision lives here once rather than
 * inline in each handler.
 *
@@ -221,23 +165,6 @@ const composerSection = defineConfigSection({
 	merge: (_parent, child) => child
 });
 /**
-* `destroy`'s target, from its two mutually exclusive flags. Kept out of the
-* grammar because the engine's flag layer has no "exactly one of these"
-* construct — and because both wrong shapes need their own remedy, which a
-* generic arity error could not give.
-*/
-function targetOf(stage, production) {
-	if (stage !== void 0 && production) return notOk(new CliStructuredError("DEPLOY.TARGET_CONFLICT", "Pass either --stage <name> or --production to `destroy`, not both."));
-	if (stage === void 0 && !production) return notOk(new CliStructuredError("DEPLOY.TARGET_MISSING", "`destroy` requires an explicit target.", { nextActions: [{
-		kind: "user-choice",
-		label: "Pass --stage <name> to tear down a branch environment, or --production to tear down the production environment."
-	}] }));
-	return ok(stage !== void 0 ? {
-		kind: "stage",
-		stage
-	} : { kind: "production" });
-}
-/**
 * The workspace the in-process leg acts in, from the engine's credential
 * read. Handlers never decode a token and never read PRISMA_WORKSPACE_ID:
 * whether the credential came from a stored session or the environment, the
@@ -252,156 +179,6 @@ async function workspaceIdOf(ctx) {
 	return (await ctx.activeCredential())?.workspaceId;
 }
 /**
-* `destroy <entry>` — deploy's mirror: same derivation, alchemy destroy.
-*
-* No confirmation prompt, matching the CLI this replaces. The front door
-* cannot know what the child will tear down, so a consent step here would be
-* asking the user to approve a list nobody has computed yet; if destroy
-* deserves one it belongs in composer's own operation, not in the grammar.
-*/
-const createDestroyCommand = (operations) => defineCommand({
-	help: {
-		summary: "Tear down the application whose root node is <entry>'s default export.",
-		description: "Same derivation as deploy. Requires an explicit target: --stage <name> for a branch environment, or --production for the production environment.",
-		examples: ["{bin} destroy module.ts --stage feat-auth", "{bin} destroy module.ts --production"]
-	},
-	args: {
-		positionals: { entry: positional.string({
-			brief: "The file whose default export is the application root module, built with module(...).",
-			placeholder: "entry"
-		}) },
-		flags: {
-			name: flag.string({
-				brief: "Override the root node's name — the application name to tear down.",
-				placeholder: "name"
-			}),
-			stage: flag.string({
-				brief: "Tear down this branch environment.",
-				placeholder: "stage"
-			}),
-			production: flag.boolean({ brief: "Tear down the project-level production environment." })
-		}
-	},
-	needs: {
-		config: composerSection,
-		credentials: "child"
-	},
-	maySpawn: true,
-	handler: async (args, ctx) => {
-		const target = targetOf(args.flags.stage, args.flags.production);
-		if (!target.ok) return target;
-		const alchemy = convergeSpawn(ctx);
-		return settleConverge(await operations.destroy({
-			entry: args.positionals.entry,
-			config: ctx.config,
-			name: args.flags.name,
-			target: target.value,
-			cwd: ctx.cwd,
-			onEvent: (event) => {
-				if (event.kind !== "no-local-deploy-state") return;
-				ctx.report({
-					kind: "message",
-					severity: "warn",
-					text: `No prior deploy state under ${event.cwd} — if you deployed from a different directory, run destroy from there; otherwise this is a no-op.`
-				});
-			}
-		}, operationDeps({
-			alchemy,
-			workspaceId: await workspaceIdOf(ctx),
-			client: ctx.api
-		})), ctx, () => ctx.present({ data: void 0 }, {
-			human: () => [{
-				kind: "summary",
-				status: "ok",
-				text: "Destroyed."
-			}],
-			stdout: () => [],
-			json: () => void 0,
-			next: () => []
-		}));
-	}
-});
-/**
-* `log <entry> [address]` — a session command that tails the merged logs of
-* the app running locally on this machine.
-*
-* It reads the LOCAL dev-emulator daemon, not the platform's logs surface, so
-* it is credential-free. It hands the terminal to nothing, which is why it
-* does not declare `maySpawn` and keeps json support: the log lines ARE its
-* json surface.
-*
-* Windows is refused inside the operation itself (LOG.PLATFORM_UNSUPPORTED),
-* which is why nothing here reads the platform.
-*/
-/** An empty screen reads as broken, so show a little recent history before going live. */
-const DEFAULT_TAIL = 20;
-const createLogCommand = (operations) => defineSessionCommand({
-	help: {
-		summary: "Tail the merged logs of the locally-running application whose root node is <entry>'s default export.",
-		examples: ["{bin} log module.ts", "{bin} log module.ts catalog.service"]
-	},
-	args: {
-		positionals: {
-			entry: positional.string({
-				brief: "The file whose default export is the application root module, built with module(...).",
-				placeholder: "entry"
-			}),
-			address: positional.optionalString({
-				brief: "Only this service's lines, by its dotted address (catalog.service); every service when absent.",
-				placeholder: "address"
-			})
-		},
-		flags: {
-			name: flag.string({
-				brief: "Override the root node's name — the dev instance's application name.",
-				placeholder: "name"
-			}),
-			tail: flag.number({
-				brief: `How many trailing history lines to show before live output (default ${String(DEFAULT_TAIL)}).`,
-				placeholder: "lines",
-				default: DEFAULT_TAIL
-			})
-		}
-	},
-	needs: { config: composerSection },
-	handler: async (args, ctx) => {
-		const reportLogEvent = (event) => {
-			ctx.report({
-				kind: "message",
-				severity: "warn",
-				text: event.kind === "stream-failed" ? `Stream failed: ${event.message}` : `Falling behind — dropped the ${String(event.count)} oldest lines.`
-			});
-		};
-		const result = await operations.log({
-			entry: args.positionals.entry,
-			config: ctx.config,
-			name: args.flags.name,
-			address: args.positionals.address,
-			tail: args.flags.tail ?? DEFAULT_TAIL,
-			cwd: ctx.cwd,
-			signal: ctx.signal,
-			onEvent: reportLogEvent
-		}, {});
-		if (!result.ok) return notOk(toEngineError(result.failure));
-		const attached = result.value;
-		if (attached.services.length === 0) {
-			ctx.report({
-				kind: "message",
-				severity: "warn",
-				text: `No running services for "${attached.appName}" — start it first with \`dev ${args.positionals.entry}\`.`
-			});
-			return ok(void 0);
-		}
-		for await (const { service, line } of attached.lines) ctx.report({
-			kind: "output",
-			source: service,
-			channel: "data",
-			line: `[${service}] ${line}`
-		});
-		return ok(void 0);
-	}
-});
-/**
 * `deploy <entry>` — a result command that hands the terminal to alchemy.
 *
 * `--production` is gone. It was accepted and then always errored ("only
@@ -655,16 +432,14 @@ const createDevCommand = (operations) => defineSessionCommand({
 	}
 });
 /**
-* Composer's `CommandFamily` — the unit the engine mounts, whether the process
-* is composer's own CLI or the `prisma` bin.
+* Composer's `CommandFamily`: the unit the `prisma` bin mounts.
 *
 * This module and everything it reaches statically must stay free of alchemy
 * and of effect VALUE imports: the `prisma` bin imports the family directly,
 * so anything in this static graph loads on `prisma --version`. The mechanism
 * that holds it is the existing lazy boundary inside the operation modules —
-* `operations/deploy.ts`, `destroy.ts`, `dev.ts` and `log.ts` each `await
-* import()` their executor, and it is the executors that reach the provider
-* tree. Importing the operations here is therefore free; importing an
+* `operations/deploy.ts` and `dev.ts` each `await import()` their executor,
+* and it is the executors that reach the provider tree. Importing the operations here is therefore free; importing an
 * executor, or flattening one of those dynamic imports, is not.
 * scripts/check-family-static-graph.mjs enforces this against BUILT output,
 * where type-only imports have already been erased.
@@ -673,16 +448,12 @@ const createDevCommand = (operations) => defineSessionCommand({
 * mount this family against the test double and exercise real grammar, real
 * arg validation and real handlers with no alchemy behind them.
 *
-* The family ships `deploy` and `dev` only: `destroy` and `log` were retired
-* from the family surface (2026-08-21 PM review), so hosts mounting the family
-* — the `prisma` bin — never see them. They remain first-class commands of
-* composer's own bin, mounted on top of the family in engine-cli.ts.
+* The family ships `deploy` and `dev` only. `destroy` and `log` are
+* programmatic operations in `@prisma/composer/control`, not commands.
 */
 const realOperations = {
 	deploy: deployWithDeps,
-	destroy: destroyWithDeps,
-	dev: devWithDeps,
-	log: logWithDeps
+	dev: devWithDeps
 };
 /** The `prisma` CLI's error reference; the engine appends `/<CODE>` to it for every error envelope. */
 const CLI_DOCS_BASE = "https://www.prisma.io/docs/cli/error-reference/";
@@ -697,227 +468,7 @@ function createComposerFamily(options = {}) {
 		docsBaseUrl: CLI_DOCS_BASE
 	});
 }
-/**
-* Everything environmental the engine needs, assembled from a host process.
-*
-* The engine takes no globals: streams, cwd, env, TTY-ness, exit and signal
-* subscription all arrive through `Runtime`, which is what lets a test drive a
-* whole run without touching `process`. Composing one is the substantive part
-* of hosting the engine — `createCli` and `Cli.run` are two calls.
-*
-* Credentials come from the engine's own environment-only manager, which
-* composes a session from PRISMA_SERVICE_TOKEN / PRISMA_WORKSPACE_ID and
-* refuses every mutation. That is the whole of composer's standalone auth
-* story: this CLI has no login flow and mounts no auth commands, so there is
-* nothing to store — the two variables ARE the credential.
-*/
-/** Where the management API lives. Matches the lowering client's default origin; the env var is the escape hatch for staging. */
-const DEFAULT_MANAGEMENT_API_BASE_URL = "https://api.prisma.io";
-const DEFAULT_AUTH_BASE_URL = "https://auth.prisma.io";
-/**
-* Starts the converge child: inherited stdio, this process's own group, no
-* `detached` and no new console — which is what lets the terminal deliver
-* Ctrl-C to the child natively instead of the CLI forwarding it. The engine
-* never imports node:child_process; this adapter is the whole of the host's
-* side of that seam.
-*/
-const spawnChild = (request) => {
-	const child = spawn(request.command, [...request.args], {
-		cwd: request.cwd,
-		stdio: "inherit",
-		env: request.env
-	});
-	return {
-		ended: new Promise((resolve, reject) => {
-			child.on("error", reject);
-			child.on("close", (exitCode, signal) => {
-				resolve({
-					exitCode,
-					signal
-				});
-			});
-		}),
-		kill: (signal) => {
-			child.kill(signal);
-		}
-	};
-};
-/**
-* The SDK's client construction config. The engine requires all four fields
-* whenever a credential manager is wired, but this host reaches none of the
-* login paths: an environment credential carries no refresh token, so nothing
-* ever refreshes and `clientId`/`redirectUri` are never read. They are
-* env-overridable rather than hard-coded so a staging run can point the whole
-* client somewhere else in one place.
-*/
-function clientConfig(env, apiBaseUrl) {
-	return {
-		clientId: env["PRISMA_CLIENT_ID"] ?? "prisma-composer-cli",
-		redirectUri: env["PRISMA_REDIRECT_URI"] ?? "http://127.0.0.1/callback",
-		apiBaseUrl,
-		authBaseUrl: env["PRISMA_AUTH_URL"] ?? DEFAULT_AUTH_BASE_URL
-	};
-}
-/**
-* What this process runs on, for `ctx.host`. Bun and Deno both announce
-* themselves in `versions`; nothing else does, so an absent marker means Node.
-*/
-function describeHost(host) {
-	const name = ["bun", "deno"].find((candidate) => host.versions[candidate] !== void 0) ?? "node";
-	return {
-		runtime: {
-			name,
-			version: host.versions[name] ?? host.version
-		},
-		platform: host.platform,
-		arch: host.arch
-	};
-}
-/**
-* Which package manager invoked us, read from the `npm_config_user_agent`
-* every major manager sets (`pnpm/10.27.0 npm/? node/v24.16.0 darwin arm64`).
-* `undefined` when the CLI was run directly rather than through a manager — a
-* normal case, not a failure, so nothing is inferred from the filesystem, and
-* the engine falls back to its own detection from the project at cwd.
-*/
-function detectPackageManager(env) {
-	const agent = env["npm_config_user_agent"];
-	if (agent === void 0) return void 0;
-	const name = agent.split("/")[0];
-	switch (name) {
-		case "npm":
-		case "pnpm":
-		case "yarn":
-		case "bun":
-		case "deno": return name;
-		default: return;
-	}
-}
-/**
-* The config loader arrives as a function rather than an already-loaded config
-* because the engine reads `prisma.config.ts` on demand — only when the command
-* it is about to run declares a config section, and with whatever file
-* `--config` named. A host that loaded the file up front would read it for runs
-* that never needed it, and would have nowhere to put `--config`.
-*
-* Nothing here answers "is this CI": the engine detects it from `env` itself,
-* and `isCIOverride` exists only for hosts where that detection cannot be
-* right — composer is not one.
-*/
-const nonEmpty = (value) => value !== void 0 && value.length > 0 ? value : void 0;
-function createRuntime(host, loadConfig) {
-	const env = host.env;
-	const apiBaseUrl = nonEmpty(env["PRISMA_API_URL"]) ?? nonEmpty(env["PRISMA_MANAGEMENT_API_URL"]) ?? DEFAULT_MANAGEMENT_API_BASE_URL;
-	const packageManager = detectPackageManager(env);
-	return {
-		stdout: host.stdout,
-		stderr: host.stderr,
-		stdin: host.stdin,
-		cwd: host.cwd(),
-		env,
-		isTty: {
-			stdin: host.stdin.isTTY === true,
-			stdout: host.stdout.isTTY === true,
-			stderr: host.stderr.isTTY === true
-		},
-		exit: (code) => host.exit(code),
-		onSignal: (cb) => {
-			const onSigint = () => {
-				cb("SIGINT");
-			};
-			const onSigterm = () => {
-				cb("SIGTERM");
-			};
-			host.on("SIGINT", onSigint);
-			host.on("SIGTERM", onSigterm);
-			return () => {
-				host.off("SIGINT", onSigint);
-				host.off("SIGTERM", onSigterm);
-			};
-		},
-		loadConfig,
-		credentialManager: new EnvironmentCredentialManager({ env }),
-		managementApiClientConfig: clientConfig(env, apiBaseUrl),
-		spawn: spawnChild,
-		managementApi: { baseUrl: apiBaseUrl },
-		...packageManager !== void 0 && { packageManager },
-		host: describeHost(host)
-	};
-}
-/**
-* Composer's own CLI, rebuilt as a thin composition of the family it
-* publishes: `createCli` over `createComposerFamily()`, `Cli.run` with a
-* Runtime. Grammar, help, arg validation, output framing, exit codes and
-* signal ownership all belong to the engine now — this module contributes the
-* family and the environment, and nothing else.
-*
-* Running composer's commands through the same path an external host uses is
-* the point: it is what proves the family works standalone before the `prisma`
-* bin mounts it.
-*
-* This IS composer's CLI. The clipanion shell it replaced, and the bespoke
-* runner that shelled out to alchemy, are gone; `bin.ts` is a call into here.
-*/
-const BINARY_NAME = "prisma-composer";
-/**
-* Composer's commands mount at the top level of its own CLI (`prisma-composer
-* deploy`). The bin mounts more than the family carries: `destroy` and `log`
-* were retired from the family (the surface the `prisma` bin mounts, per the
-* 2026-08-21 PM review) but stay first-class commands of `prisma-composer`
-* itself, so their definitions are mounted here on top of the family.
-*/
-function mountedTree(family, operations) {
-	return {
-		...family.commands,
-		destroy: createDestroyCommand(operations),
-		log: createLogCommand(operations)
-	};
-}
-/**
-* The ORM's slice of prisma.config.ts, declared so a config shared with the
-* unified `prisma` CLI loads here: the engine rejects any top-level key no
-* mounted family declares, and this bin does not mount the ORM family. The
-* value passes through unvalidated — the ORM CLI owns its section's shape,
-* and no composer command reads it.
-*/
-const foreignOrmSectionFamily = defineCommandFamily({
-	configSection: defineConfigSection({
-		name: "orm",
-		validate: (raw) => ({
-			ok: true,
-			value: raw,
-			diagnostics: []
-		})
-	}),
-	commands: {}
-});
-function createComposerCli(spec) {
-	const operations = spec.operations ?? realOperations;
-	const family = createComposerFamily({ operations });
-	return createCli({
-		name: BINARY_NAME,
-		version: spec.version,
-		commandFamilies: [family, foreignOrmSectionFamily],
-		groups: {},
-		commands: mountedTree(family, operations)
-	});
-}
-/**
-* Composes the Runtime and runs one invocation. Returns the exit code rather
-* than exiting, so the caller owns the process — a bin assigns it to
-* `process.exitCode` and lets the streams drain, as composer's CLI has always
-* done.
-*
-* `prisma.config.ts` is not read here. The loader goes in as a function, and the
-* engine calls it only when the command it is about to run declares a config
-* section, passing it the file `--config` named; the loader resolves that
-* against the host's cwd.
-*/
-function runComposerCli(argv, host, spec, hooks) {
-	const runtime = createRuntime(host, (requestedFile) => loadConfig(host.cwd(), requestedFile));
-	return createComposerCli(spec).run(argv, runtime, hooks);
-}
 //#endregion
-export { BINARY_NAME, composerSection, createComposerCli, createComposerFamily, realOperations, runComposerCli, toEngineError };
+export { composerSection, createComposerFamily, realOperations, toEngineError };
 
 //# sourceMappingURL=family.mjs.map