@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2-dev.49

package/dist/cli2.js

@@ -1,136 +0,0 @@
-import { CliError } from "./errors.js";
-import { attachCommandDescriptor } from "./shell/command-meta.js";
-import { createShellUi } from "./shell/ui.js";
-import { addCompactGlobalFlags } from "./shell/global-flags.js";
-import { configureRuntimeCommand, createCommandContext } from "./shell/runtime.js";
-import { formatUnexpectedError, unexpectedErrorFeedbackCommand, writeHumanError, writeJsonError, writeJsonSuccess, writeJsonUnexpectedError } from "./shell/output.js";
-import { createAgentCommand } from "./commands/agent/index.js";
-import "./shell/prompt.js";
-import { createAppCommand } from "./commands/app/index.js";
-import { createAuthCommand } from "./commands/auth/index.js";
-import { createBranchCommand } from "./commands/branch/index.js";
-import { createBucketCommand } from "./commands/bucket/index.js";
-import { createBuildCommand } from "./commands/build/index.js";
-import { createDatabaseCommand } from "./commands/database/index.js";
-import { getCliName, getCliVersion } from "./lib/version.js";
-import { createFeedbackCommand } from "./commands/feedback/index.js";
-import { createGitCommand } from "./commands/git/index.js";
-import { createInitCommand } from "./commands/init/index.js";
-import { createProjectCommand } from "./commands/project/index.js";
-import { runVersion } from "./controllers/version.js";
-import { createVersionCommand } from "./commands/version/index.js";
-import { maybeWriteCachedUpdateNotification } from "./update-check.js";
-import process from "node:process";
-import { Command, CommanderError, Option } from "commander";
-//#region src/cli.ts
-async function runCli(options = {}) {
-	const runtime = resolveRuntime(options);
-	const program = createProgram(runtime);
-	process.exitCode = 0;
-	try {
-		await maybeWriteCachedUpdateNotification(runtime);
-		if (runtime.argv.includes("--version")) return await handleVersionFlag(runtime);
-		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
-		if (bareHelpCommand) {
-			runtime.stderr.write(bareHelpCommand.helpInformation());
-			return 0;
-		}
-		await program.parseAsync(runtime.argv, { from: "user" });
-		return process.exitCode ?? 0;
-	} catch (error) {
-		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
-		if (runtime.argv.includes("--json")) {
-			writeJsonUnexpectedError({
-				stdout: runtime.stdout,
-				stderr: runtime.stderr
-			}, runtime.argv, error);
-			return 1;
-		}
-		const quiet = runtime.argv.includes("--quiet") || runtime.argv.includes("-q");
-		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace"), quiet ? void 0 : unexpectedErrorFeedbackCommand(runtime.argv, error)));
-		return 1;
-	} finally {
-		runtime.stdin;
-	}
-}
-function createProgram(runtime) {
-	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
-	addCompactGlobalFlags(program);
-	program.addOption(new Option("--version", "Print the CLI version and exit."));
-	program.name("prisma").showSuggestionAfterError();
-	program.addCommand(createVersionCommand(runtime));
-	program.addCommand(createInitCommand(runtime));
-	program.addCommand(createFeedbackCommand(runtime));
-	program.addCommand(createAgentCommand(runtime));
-	program.addCommand(createAuthCommand(runtime));
-	program.addCommand(createProjectCommand(runtime));
-	program.addCommand(createGitCommand(runtime));
-	program.addCommand(createBranchCommand(runtime));
-	program.addCommand(createBuildCommand(runtime));
-	program.addCommand(createDatabaseCommand(runtime));
-	program.addCommand(createBucketCommand(runtime));
-	program.addCommand(createAppCommand(runtime));
-	return program;
-}
-async function handleVersionFlag(runtime) {
-	const wantsJson = runtime.argv.includes("--json");
-	const output = {
-		stdout: runtime.stdout,
-		stderr: runtime.stderr
-	};
-	try {
-		if (wantsJson) {
-			const success = await runVersion(await createCommandContext(runtime, buildVersionFlagFlags(runtime)));
-			writeJsonSuccess(output, {
-				command: success.command,
-				result: { version: success.result.cli.version },
-				warnings: success.warnings,
-				nextSteps: success.nextSteps
-			});
-			return 0;
-		}
-		const versionLine = `${getCliName()} ${getCliVersion()}`;
-		runtime.stdout.write(`${versionLine}\n`);
-		return 0;
-	} catch (error) {
-		if (error instanceof CliError) {
-			if (wantsJson) writeJsonError(output, "version", error);
-			else writeHumanError(output, createShellUi(runtime, buildVersionFlagFlags(runtime)), error, { trace: false });
-			return error.exitCode;
-		}
-		throw error;
-	}
-}
-function buildVersionFlagFlags(runtime) {
-	return {
-		json: runtime.argv.includes("--json"),
-		quiet: false,
-		verbose: false,
-		trace: false,
-		yes: false,
-		interactive: void 0,
-		color: void 0
-	};
-}
-function resolveBareHelpCommand(program, argv) {
-	if (argv.length === 0) return program;
-	if (argv.length !== 1) return null;
-	const candidate = program.commands.find((command) => command.name() === argv[0]) ?? null;
-	if (!candidate) return null;
-	if (candidate.commands.length === 0) return null;
-	return candidate;
-}
-function resolveRuntime(options) {
-	return {
-		argv: options.argv ?? process.argv.slice(2),
-		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
-		env: options.env ?? process.env,
-		signal: options.signal ?? new AbortController().signal,
-		stdin: options.stdin ?? process.stdin,
-		stdout: options.stdout ?? process.stdout,
-		stderr: options.stderr ?? process.stderr,
-		stateDir: options.stateDir
-	};
-}
-//#endregion
-export { runCli };

package/dist/command-arguments.js

@@ -1,12 +0,0 @@
-//#region src/command-arguments.ts
-function formatCommandArgument(value) {
-	return /^[A-Za-z0-9._/-]+$/.test(value) && !value.startsWith("-") ? value : `'${value.replace(/'/g, "'\\''")}'`;
-}
-function formatShellCommand(command) {
-	return command.map(formatShellCommandWord).join(" ");
-}
-function formatShellCommandWord(value) {
-	return /^[A-Za-z0-9_./:@=-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
-}
-//#endregion
-export { formatCommandArgument, formatShellCommand };

package/dist/commands/agent/index.js

@@ -1,60 +0,0 @@
-import { runAgentInstall, runAgentStatus } from "../../controllers/agent.js";
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { renderAgentInstall, renderAgentStatus, serializeAgentInstall, serializeAgentStatus } from "../../presenters/agent.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { Command, Option } from "commander";
-//#region src/commands/agent/index.ts
-function createAgentCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("agent"), runtime), "agent");
-	addCompactGlobalFlags(command);
-	command.addCommand(createAgentInstallCommand(runtime));
-	command.addCommand(createAgentUpdateCommand(runtime));
-	command.addCommand(createAgentStatusCommand(runtime));
-	return command;
-}
-function createAgentInstallCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("install"), runtime), "agent.install");
-	addAgentInstallOptions(command);
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "agent.install", options, (context) => runAgentInstall(context, options, "install"), {
-			renderHuman: (context, descriptor, result) => renderAgentInstall(context, descriptor, result),
-			renderJson: (result) => serializeAgentInstall(result)
-		});
-	});
-	return command;
-}
-function createAgentUpdateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "agent.update");
-	addAgentInstallOptions(command);
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "agent.update", options, (context) => runAgentInstall(context, options, "update"), {
-			renderHuman: (context, descriptor, result) => renderAgentInstall(context, descriptor, result),
-			renderJson: (result) => serializeAgentInstall(result)
-		});
-	});
-	return command;
-}
-function createAgentStatusCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("status"), runtime), "agent.status");
-	command.addOption(new Option("--global", "Check globally installed Prisma skills instead of project skills"));
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "agent.status", options, (context) => runAgentStatus(context, options), {
-			renderHuman: (context, descriptor, result) => renderAgentStatus(context, descriptor, result),
-			renderJson: (result) => serializeAgentStatus(result)
-		});
-	});
-	return command;
-}
-function addAgentInstallOptions(command) {
-	command.addOption(new Option("--agent <agent>", "Agent target for Prisma skills; repeat for multiple agents").argParser(collectValues)).addOption(new Option("--all-agents", "Install Prisma skills for every agent supported by the skills CLI")).addOption(new Option("--skill <skill>", "Prisma skill to install; repeat for multiple skills").argParser(collectValues)).addOption(new Option("--global", "Install skills into the user directory instead of the project")).addOption(new Option("--copy", "Ask the skills CLI to copy files instead of symlinking them")).addOption(new Option("--dry-run", "Show changes without writing files"));
-}
-function collectValues(value, previous) {
-	return [...previous ?? [], value];
-}
-//#endregion
-export { createAgentCommand };

package/dist/commands/app/index.js

@@ -1,350 +0,0 @@
-import { usageError } from "../../errors.js";
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runCommand, runStreamingCommand } from "../../shell/command-runner.js";
-import { APP_BUILD_TYPES } from "../../lib/app/build.js";
-import { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy } from "../../controllers/app.js";
-import { isAppDeployAllResult, renderAppBuild, renderAppDeploy, renderAppDeployAll, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDeployAll, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy } from "../../presenters/app.js";
-import { Command, Option } from "commander";
-import { FRAMEWORK_KEYS, LOCAL_DEV_BUILD_TYPES } from "@prisma/compute-sdk/config";
-//#region src/commands/app/index.ts
-function createAppCommand(runtime) {
-	const app = attachCommandDescriptor(configureRuntimeCommand(new Command("app"), runtime), "app");
-	addCompactGlobalFlags(app);
-	app.addCommand(createBuildCommand(runtime));
-	app.addCommand(createRunCommand(runtime));
-	app.addCommand(createDeployCommand(runtime));
-	app.addCommand(createShowCommand(runtime));
-	app.addCommand(createOpenCommand(runtime));
-	app.addCommand(createDomainCommand(runtime));
-	app.addCommand(createLogsCommand(runtime));
-	app.addCommand(createListDeploysCommand(runtime));
-	app.addCommand(createShowDeployCommand(runtime));
-	app.addCommand(createPromoteCommand(runtime));
-	app.addCommand(createRollbackCommand(runtime));
-	app.addCommand(createRemoveCommand(runtime));
-	return app;
-}
-function createBuildCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "app.build");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([...APP_BUILD_TYPES]).default("auto"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const entry = options.entry;
-		const buildType = options.buildType;
-		await runCommand(runtime, "app.build", options, (context) => runAppBuild(context, {
-			entrypoint: entry,
-			buildType,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppBuild(context, descriptor, result),
-			renderJson: (result) => serializeAppBuild(result)
-		});
-	});
-	return command;
-}
-function createRunCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("run"), runtime), "app.run");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto runs")).addOption(new Option("--build-type <type>", "Local framework type").choices(["auto", ...LOCAL_DEV_BUILD_TYPES]).default("auto")).addOption(new Option("--port <port>", "Local port"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const entry = options.entry;
-		const buildType = options.buildType;
-		const port = options.port;
-		await runCommand(runtime, "app.run", options, (context) => runAppRun(context, {
-			entrypoint: entry,
-			buildType,
-			port,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppRun(context, descriptor, result),
-			renderJson: (result) => serializeAppRun(result)
-		});
-	});
-	return command;
-}
-function createDeployCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([...FRAMEWORK_KEYS])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--region <region>", "Region for a newly created app; existing apps keep their region")).addOption(new Option("--env <name=value|file>", "Environment variable assignment or dotenv file").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire a Prisma Postgres database for this deploy target")).addOption(new Option("--no-db", "Skip database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production")).addOption(new Option("--no-promote", "Build the new deployment without promoting it to live (promote later with app promote <id>)"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const entry = options.entry;
-		const branchName = options.branch;
-		const framework = options.framework;
-		const httpPort = options.httpPort;
-		const region = options.region;
-		const envAssignments = options.env;
-		const projectRef = options.project;
-		const createProjectName = options.createProject;
-		const prod = options.prod;
-		const noPromote = options.promote === false;
-		const db = options.db;
-		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
-		await runCommand(runtime, "app.deploy", options, (context) => {
-			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests database setup, while --no-db disables it.", "Pass exactly one database setup flag.", ["prisma-cli app deploy --db", "prisma-cli app deploy --no-db"], "app");
-			return runAppDeploy(context, appName, {
-				projectRef,
-				createProjectName,
-				branchName,
-				entrypoint: entry,
-				framework,
-				httpPort,
-				region,
-				envAssignments,
-				prod: prod === true,
-				noPromote,
-				db,
-				configTarget
-			});
-		}, {
-			renderHuman: (context, descriptor, result) => isAppDeployAllResult(result) ? renderAppDeployAll(context, descriptor, result) : renderAppDeploy(context, descriptor, result),
-			renderJson: (result) => isAppDeployAllResult(result) ? serializeAppDeployAll(result) : serializeAppDeploy(result)
-		});
-	});
-	return command;
-}
-function hasFlag(argv, flag) {
-	return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
-}
-function createShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
-			renderJson: (result) => serializeAppShow(result)
-		});
-	});
-	return command;
-}
-function createOpenCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
-			renderJson: (result) => serializeAppOpen(result)
-		});
-	});
-	return command;
-}
-function createDomainCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("domain"), runtime), "app.domain");
-	addCompactGlobalFlags(command);
-	command.addCommand(createDomainAddCommand(runtime));
-	command.addCommand(createDomainShowCommand(runtime));
-	command.addCommand(createDomainRemoveCommand(runtime));
-	command.addCommand(createDomainRetryCommand(runtime));
-	command.addCommand(createDomainWaitCommand(runtime));
-	return command;
-}
-function addDomainTargetOptions(command) {
-	return command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <name>", "Branch name"));
-}
-function createDomainAddCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "app.domain.add");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.add", options, (context) => runAppDomainAdd(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainAdd(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainAdd(result)
-		});
-	});
-	return command;
-}
-function createDomainShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.domain.show");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.show", options, (context) => runAppDomainShow(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainShow(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainShow(result)
-		});
-	});
-	return command;
-}
-function createDomainRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.domain.remove");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.remove", options, (context) => runAppDomainRemove(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainRemove(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainRemove(result)
-		});
-	});
-	return command;
-}
-function createDomainRetryCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("retry"), runtime), "app.domain.retry");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.retry", options, (context) => runAppDomainRetry(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainRetry(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainRetry(result)
-		});
-	});
-	return command;
-}
-function createDomainWaitCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("wait"), runtime), "app.domain.wait");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	command.addOption(new Option("--timeout <duration>", "Maximum time to wait").default("15m"));
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const timeout = options.timeout;
-		await runStreamingCommand(runtime, "app.domain.wait", options, (context) => runAppDomainWait(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			timeout,
-			configTarget
-		}));
-	});
-	return command;
-}
-function createLogsCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "app.logs");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--deployment <id>", "Deployment id"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const deploymentId = options.deployment;
-		const projectRef = options.project;
-		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId, projectRef, configTarget));
-	});
-	return command;
-}
-function collectRepeatableValues(value, previous) {
-	return [...previous ?? [], value];
-}
-function createListDeploysCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-deploys"), runtime), "app.list-deploys");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppListDeploys(context, descriptor, result),
-			renderJson: (result) => serializeAppListDeploys(result)
-		});
-	});
-	return command;
-}
-function createShowDeployCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show-deploy"), runtime), "app.show-deploy");
-	command.argument("<deployment>", "Deployment id");
-	addGlobalFlags(command);
-	command.action(async (deploymentId, options) => {
-		await runCommand(runtime, "app.show-deploy", options, (context) => runAppShowDeploy(context, deploymentId), {
-			renderHuman: (context, descriptor, result) => renderAppShowDeploy(context, descriptor, result),
-			renderJson: (result) => serializeAppShowDeploy(result)
-		});
-	});
-	return command;
-}
-function createPromoteCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("promote"), runtime), "app.promote");
-	command.argument("<deployment>", "Deployment id");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (deploymentId, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppPromote(context, descriptor, result),
-			renderJson: (result) => serializeAppPromote(result)
-		});
-	});
-	return command;
-}
-function createRollbackCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rollback"), runtime), "app.rollback");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--to <deployment>", "Deployment id"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const deploymentId = options.to;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.rollback", options, (context) => runAppRollback(context, appName, deploymentId, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppRollback(context, descriptor, result),
-			renderJson: (result) => serializeAppRollback(result)
-		});
-	});
-	return command;
-}
-function createRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.remove");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <name>", "Branch name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef, configTarget, branchName), {
-			renderHuman: (context, descriptor, result) => renderAppRemove(context, descriptor, result),
-			renderJson: (result) => serializeAppRemove(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createAppCommand };

package/dist/commands/auth/index.js

@@ -1,95 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { runAuthLogin, runAuthLogout, runAuthWhoAmI, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceUse } from "../../controllers/auth.js";
-import { renderAuthSuccess, renderAuthWorkspaceList, renderAuthWorkspaceLogout, renderAuthWorkspaceUse, serializeAuthWorkspaceList, serializeAuthWorkspaceLogout, serializeAuthWorkspaceUse } from "../../presenters/auth.js";
-import { Command, Option } from "commander";
-//#region src/commands/auth/index.ts
-function createAuthCommand(runtime) {
-	const auth = attachCommandDescriptor(configureRuntimeCommand(new Command("auth"), runtime), "auth");
-	addCompactGlobalFlags(auth);
-	auth.addCommand(createAuthLoginCommand(runtime));
-	auth.addCommand(createAuthLogoutCommand(runtime));
-	auth.addCommand(createAuthWhoAmICommand(runtime));
-	auth.addCommand(createAuthWorkspaceCommand(runtime));
-	return auth;
-}
-function createAuthLoginCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("login"), runtime), "auth.login");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.login", options, (context) => runAuthLogin(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.login", result) });
-	});
-	return command;
-}
-function createAuthLogoutCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logout"), runtime), "auth.logout");
-	command.addOption(new Option("--workspace <id-or-name>", "Remove one stored OAuth workspace session"));
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const logoutOptions = options;
-		if (logoutOptions.workspace?.trim()) {
-			await runCommand(runtime, "auth.workspace.logout", options, (context) => runAuthWorkspaceLogout(context, logoutOptions.workspace), {
-				renderHuman: (context, descriptor, result) => renderAuthWorkspaceLogout(context, descriptor, result),
-				renderJson: (result) => serializeAuthWorkspaceLogout(result)
-			});
-			return;
-		}
-		await runCommand(runtime, "auth.logout", options, (context) => runAuthLogout(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.logout", result) });
-	});
-	return command;
-}
-function createAuthWhoAmICommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("whoami"), runtime), "auth.whoami");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.whoami", options, (context) => runAuthWhoAmI(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.whoami", result) });
-	});
-	return command;
-}
-function createAuthWorkspaceCommand(runtime) {
-	const workspace = attachCommandDescriptor(configureRuntimeCommand(new Command("workspace"), runtime), "auth.workspace");
-	addCompactGlobalFlags(workspace);
-	workspace.addCommand(createAuthWorkspaceListCommand(runtime));
-	workspace.addCommand(createAuthWorkspaceUseCommand(runtime));
-	workspace.addCommand(createAuthWorkspaceLogoutCommand(runtime));
-	return workspace;
-}
-function createAuthWorkspaceListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "auth.workspace.list");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.workspace.list", options, (context) => runAuthWorkspaceList(context), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceList(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceList(result)
-		});
-	});
-	return command;
-}
-function createAuthWorkspaceLogoutCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logout"), runtime), "auth.workspace.logout");
-	command.argument("<id-or-name>", "Workspace id or exact name");
-	addGlobalFlags(command);
-	command.action(async (workspaceRef, options) => {
-		await runCommand(runtime, "auth.workspace.logout", options, (context) => runAuthWorkspaceLogout(context, typeof workspaceRef === "string" ? workspaceRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceLogout(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceLogout(result)
-		});
-	});
-	return command;
-}
-function createAuthWorkspaceUseCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "auth.workspace.use");
-	command.argument("[id-or-name]", "Workspace id or exact name");
-	addGlobalFlags(command);
-	command.action(async (workspaceRef, options) => {
-		await runCommand(runtime, "auth.workspace.use", options, (context) => runAuthWorkspaceUse(context, typeof workspaceRef === "string" ? workspaceRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceUse(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceUse(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createAuthCommand };