@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/cli.js

@@ -1,9 +1,24 @@
 #!/usr/bin/env node
+import { runUpdateDiscoveryWorker } from "./shell/update-check.js";
 import { runCli } from "./cli2.js";
 import process from "node:process";
 //#region src/bin.ts
-runCli().then((exitCode) => {
-	process.exitCode = exitCode;
-});
+if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") {
+	await runUpdateDiscoveryWorker();
+	process.exitCode = 0;
+} else {
+	const controller = new AbortController();
+	const abortCli = () => {
+		if (!controller.signal.aborted) controller.abort(new DOMException("Command canceled", "AbortError"));
+	};
+	process.once("SIGINT", abortCli);
+	process.once("SIGTERM", abortCli);
+	try {
+		process.exitCode = await runCli({ signal: controller.signal });
+	} finally {
+		process.off("SIGINT", abortCli);
+		process.off("SIGTERM", abortCli);
+	}
+}
 //#endregion
 export {};

package/dist/cli2.js

@@ -1,18 +1,22 @@
 import { CliError } from "./shell/errors.js";
-import { createShellUi } from "./shell/ui.js";
-import { writeHumanError, writeJsonError, writeJsonSuccess } from "./shell/output.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, writeHumanError, writeJsonError, writeJsonSuccess } 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 { createBuildCommand } from "./commands/build/index.js";
+import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
 import { runVersion } from "./controllers/version.js";
 import { createVersionCommand } from "./commands/version/index.js";
+import { maybeWriteCachedUpdateNotification } from "./shell/update-check.js";
 import process from "node:process";
 import { Command, CommanderError, Option } from "commander";
 //#region src/cli.ts
@@ -21,6 +25,7 @@ async function runCli(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) {
@@ -31,8 +36,7 @@ async function runCli(options = {}) {
 		return process.exitCode ?? 0;
 	} catch (error) {
 		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
-		const message = error instanceof Error ? error.stack ?? error.message : String(error);
-		runtime.stderr.write(`${message}\n`);
+		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace")));
 		return 1;
 	} finally {
 		runtime.stdin;
@@ -44,10 +48,13 @@ function createProgram(runtime) {
 	program.addOption(new Option("--version", "Print the CLI version and exit."));
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createVersionCommand(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(createAppCommand(runtime));
 	return program;
 }
@@ -104,6 +111,7 @@ function resolveRuntime(options) {
 		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,

package/dist/commands/agent/index.js

@@ -0,0 +1,60 @@
+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,11 +1,13 @@
+import { usageError } from "../../shell/errors.js";
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { PREVIEW_BUILD_TYPES } from "../../lib/app/preview-build.js";
-import { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy } from "../../controllers/app.js";
-import { renderAppBuild, renderAppDeploy, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy } from "../../presenters/app.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");
@@ -26,12 +28,16 @@ function createAppCommand(runtime) {
 }
 function createBuildCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "app.build");
-	command.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([...PREVIEW_BUILD_TYPES]).default("auto"));
+	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 (options) => {
+	command.action(async (configTarget, options) => {
 		const entry = options.entry;
 		const buildType = options.buildType;
-		await runCommand(runtime, "app.build", options, (context) => runAppBuild(context, entry, 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)
 		});
@@ -40,17 +46,18 @@ function createBuildCommand(runtime) {
 }
 function createRunCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("run"), runtime), "app.run");
-	command.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto runs")).addOption(new Option("--build-type <type>", "Local framework type").choices([
-		"auto",
-		"bun",
-		"nextjs"
-	]).default("auto")).addOption(new Option("--port <port>", "Local port"));
+	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 (options) => {
+	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, entry, buildType, 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)
 		});
@@ -59,45 +66,56 @@ function createRunCommand(runtime) {
 }
 function createDeployCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.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([
-		"nextjs",
-		"hono",
-		"tanstack-start",
-		"bun"
-	])).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("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	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 (options) => {
+	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;
-		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
-			projectRef,
-			createProjectName,
-			branchName,
-			entrypoint: entry,
-			framework,
-			httpPort,
-			envAssignments
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
-			renderJson: (result) => serializeAppDeploy(result)
+		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.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	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 (options) => {
+	command.action(async (configTarget, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef), {
+		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef, configTarget), {
 			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
 			renderJson: (result) => serializeAppShow(result)
 		});
@@ -106,12 +124,12 @@ function createShowCommand(runtime) {
 }
 function createOpenCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	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 (options) => {
+	command.action(async (configTarget, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef), {
+		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef, configTarget), {
 			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
 			renderJson: (result) => serializeAppOpen(result)
 		});
@@ -134,16 +152,18 @@ function addDomainTargetOptions(command) {
 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, options) => {
+	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
+			branchName,
+			configTarget
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDomainAdd(context, descriptor, result),
 			renderJson: (result) => serializeAppDomainAdd(result)
@@ -154,16 +174,18 @@ function createDomainAddCommand(runtime) {
 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, options) => {
+	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
+			branchName,
+			configTarget
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDomainShow(context, descriptor, result),
 			renderJson: (result) => serializeAppDomainShow(result)
@@ -174,16 +196,18 @@ function createDomainShowCommand(runtime) {
 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, options) => {
+	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
+			branchName,
+			configTarget
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDomainRemove(context, descriptor, result),
 			renderJson: (result) => serializeAppDomainRemove(result)
@@ -194,16 +218,18 @@ function createDomainRemoveCommand(runtime) {
 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, options) => {
+	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
+			branchName,
+			configTarget
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDomainRetry(context, descriptor, result),
 			renderJson: (result) => serializeAppDomainRetry(result)
@@ -214,10 +240,11 @@ function createDomainRetryCommand(runtime) {
 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, options) => {
+	command.action(async (hostname, configTarget, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
 		const branchName = options.branch;
@@ -226,20 +253,21 @@ function createDomainWaitCommand(runtime) {
 			appName,
 			projectRef,
 			branchName,
-			timeout
+			timeout,
+			configTarget
 		}));
 	});
 	return command;
 }
 function createLogsCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "app.logs");
-	command.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"));
+	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 (options) => {
+	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));
+		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId, projectRef, configTarget));
 	});
 	return command;
 }
@@ -248,12 +276,12 @@ function collectRepeatableValues(value, previous) {
 }
 function createListDeploysCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-deploys"), runtime), "app.list-deploys");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	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 (options) => {
+	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), {
+		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)
 		});
@@ -275,12 +303,13 @@ function createShowDeployCommand(runtime) {
 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, options) => {
+	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), {
+		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)
 		});
@@ -289,13 +318,13 @@ function createPromoteCommand(runtime) {
 }
 function createRollbackCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rollback"), runtime), "app.rollback");
-	command.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"));
+	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 (options) => {
+	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), {
+		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)
 		});
@@ -304,12 +333,12 @@ function createRollbackCommand(runtime) {
 }
 function createRemoveCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.remove");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	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 (options) => {
+	command.action(async (configTarget, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef), {
+		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef, configTarget), {
 			renderHuman: (context, descriptor, result) => renderAppRemove(context, descriptor, result),
 			renderJson: (result) => serializeAppRemove(result)
 		});

package/dist/commands/auth/index.js

@@ -1,9 +1,9 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runAuthLogin, runAuthLogout, runAuthWhoAmI } from "../../controllers/auth.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { renderAuthSuccess } from "../../presenters/auth.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) {
@@ -12,6 +12,7 @@ function createAuthCommand(runtime) {
 	auth.addCommand(createAuthLoginCommand(runtime));
 	auth.addCommand(createAuthLogoutCommand(runtime));
 	auth.addCommand(createAuthWhoAmICommand(runtime));
+	auth.addCommand(createAuthWorkspaceCommand(runtime));
 	return auth;
 }
 function createAuthLoginCommand(runtime) {
@@ -25,8 +26,17 @@ function createAuthLoginCommand(runtime) {
 }
 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;
@@ -39,5 +49,48 @@ function createAuthWhoAmICommand(runtime) {
 	});
 	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 };

package/dist/commands/branch/index.js

@@ -2,16 +2,14 @@ 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 { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
-import { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow } from "../../presenters/branch.js";
+import { runBranchList } from "../../controllers/branch.js";
+import { renderBranchList, serializeBranchList } from "../../presenters/branch.js";
 import { Command } from "commander";
 //#region src/commands/branch/index.ts
 function createBranchCommand(runtime) {
 	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
 	addCompactGlobalFlags(branch);
 	branch.addCommand(createBranchListCommand(runtime));
-	branch.addCommand(createBranchShowCommand(runtime));
-	branch.addCommand(createBranchUseCommand(runtime));
 	return branch;
 }
 function createBranchListCommand(runtime) {
@@ -25,28 +23,5 @@ function createBranchListCommand(runtime) {
 	});
 	return command;
 }
-function createBranchShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "branch.show");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "branch.show", options, (context) => runBranchShow(context), {
-			renderHuman: (context, descriptor, result) => renderBranchShow(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
-function createBranchUseCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "branch.use");
-	command.argument("[name]", "Branch name");
-	addGlobalFlags(command);
-	command.action(async (branchName, options) => {
-		await runCommand(runtime, "branch.use", options, (context) => runBranchUse(context, branchName), {
-			renderHuman: (context, descriptor, result) => renderBranchUse(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
 //#endregion
 export { createBranchCommand };