@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/auth/workspaces.js

@@ -0,0 +1,171 @@
+import { CLIENT_ID, UNUSED_REDIRECT_URI, getApiBaseUrl } from "./client.js";
+import { FileTokenStorage, WorkspaceSelectionError } from "./token-storage.js";
+import { readAuthState } from "./operations.js";
+import { workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceSwitchUnavailableError } from "./errors.js";
+import { createManagementApiSdk } from "@prisma/management-api-sdk";
+import { SERVICE_TOKEN_ENV_VAR } from "@prisma/cli-engine";
+//#region src/auth/workspaces.ts
+async function listAuthWorkspaces(context) {
+	const rawServiceToken = context.env[SERVICE_TOKEN_ENV_VAR];
+	const storage = new FileTokenStorage(context.env, context.signal);
+	const localWorkspaces = await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	if (rawServiceToken !== void 0) {
+		const authState = await readAuthState(context.env, context.signal);
+		return {
+			authSource: authState.authenticated ? "service_token" : "none",
+			activeWorkspace: authState.workspace,
+			workspaces: [...authState.workspace ? [{
+				...authState.workspace,
+				credentialWorkspaceId: null,
+				active: true,
+				source: "service_token",
+				switchable: false,
+				lastSeenAt: null
+			}] : [], ...localWorkspaces.map((workspace) => ({
+				...toAuthWorkspace(workspace),
+				credentialWorkspaceId: workspace.credentialWorkspaceId,
+				active: false,
+				source: "oauth",
+				switchable: false,
+				lastSeenAt: workspace.lastSeenAt
+			}))]
+		};
+	}
+	const active = localWorkspaces.find((workspace) => workspace.active) ?? null;
+	return {
+		authSource: localWorkspaces.length > 0 ? "oauth" : "none",
+		activeWorkspace: active ? toAuthWorkspace(active) : null,
+		workspaces: localWorkspaces.map((workspace) => ({
+			...toAuthWorkspace(workspace),
+			credentialWorkspaceId: workspace.credentialWorkspaceId,
+			active: workspace.active,
+			source: "oauth",
+			switchable: true,
+			lastSeenAt: workspace.lastSeenAt
+		}))
+	};
+}
+async function switchAuthWorkspace(context, workspaceRef) {
+	if (context.env[SERVICE_TOKEN_ENV_VAR] !== void 0) throw workspaceSwitchUnavailableError();
+	const storage = new FileTokenStorage(context.env, context.signal);
+	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	try {
+		const result = await storage.useWorkspace(workspaceRef);
+		return {
+			previousWorkspace: result.previous ? toAuthWorkspace(result.previous) : null,
+			workspace: toAuthWorkspace(result.selected)
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function logoutAuthWorkspace(context, workspaceRef) {
+	const storage = new FileTokenStorage(context.env, context.signal);
+	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	try {
+		const result = await storage.logoutWorkspace(workspaceRef);
+		return {
+			workspace: toAuthWorkspace(result.workspace),
+			wasActive: result.wasActive,
+			activeWorkspace: result.activeWorkspace ? toAuthWorkspace(result.activeWorkspace) : null
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function hydrateLocalAuthWorkspaces(context, storage, workspaces) {
+	const candidates = workspaces.filter(needsWorkspaceMetadataHydration);
+	if (candidates.length === 0) return workspaces;
+	const tokensByCredentialWorkspaceId = new Map((await storage.listWorkspaceTokens()).map((tokens) => [tokens.workspaceId, tokens]));
+	let nextWorkspaces = workspaces;
+	for (const workspace of candidates) {
+		const tokens = tokensByCredentialWorkspaceId.get(workspace.credentialWorkspaceId);
+		if (!tokens) continue;
+		const resolved = await resolveOAuthWorkspaceMetadata(context, tokens);
+		if (!resolved) continue;
+		await rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved);
+		nextWorkspaces = nextWorkspaces.map((candidate) => candidate.credentialWorkspaceId === workspace.credentialWorkspaceId ? {
+			...candidate,
+			id: resolved.id,
+			name: resolved.name,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		} : candidate);
+	}
+	return nextWorkspaces;
+}
+async function rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved) {
+	try {
+		await storage.rememberWorkspace(tokens.workspaceId, resolved);
+	} catch {
+		context.signal?.throwIfAborted();
+	}
+}
+function needsWorkspaceMetadataHydration(workspace) {
+	return workspace.id === workspace.credentialWorkspaceId || workspace.name === "Unknown workspace" || workspace.name === workspace.credentialWorkspaceId;
+}
+async function resolveOAuthWorkspaceMetadata(context, tokens) {
+	const sdk = createManagementApiSdk({
+		clientId: CLIENT_ID,
+		redirectUri: UNUSED_REDIRECT_URI,
+		tokenStorage: createSingleWorkspaceTokenStorage(new FileTokenStorage(context.env, context.signal, { activateOnSetTokens: false }), tokens),
+		apiBaseUrl: getApiBaseUrl(context.env)
+	});
+	try {
+		const { data } = await sdk.client.GET("/v1/workspaces/{id}", {
+			params: { path: { id: tokens.workspaceId } },
+			signal: context.signal
+		});
+		const id = stringOrNull(data?.data?.id) ?? tokens.workspaceId;
+		const name = stringOrNull(data?.data?.name) ?? id;
+		if (id === tokens.workspaceId && name === tokens.workspaceId) return null;
+		return {
+			id,
+			name
+		};
+	} catch {
+		context.signal?.throwIfAborted();
+		return null;
+	}
+}
+function createSingleWorkspaceTokenStorage(storage, initialTokens) {
+	let currentTokens = initialTokens;
+	return {
+		getTokens: async () => currentTokens,
+		setTokens: async (tokens) => {
+			currentTokens = tokens;
+			await storage.setTokens(tokens);
+		},
+		clearTokens: async () => {
+			const tokens = currentTokens;
+			currentTokens = null;
+			if (tokens) await storage.clearTokensIfCurrent(tokens);
+		}
+	};
+}
+function stringOrNull(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function toAuthWorkspace(workspace) {
+	return {
+		id: workspace.id,
+		name: workspace.name
+	};
+}
+//#endregion
+export { listAuthWorkspaces, logoutAuthWorkspace, switchAuthWorkspace };

package/dist/cli-command.js

@@ -0,0 +1,14 @@
+//#region src/cli-command.ts
+const PRISMA_CLI_PACKAGE_NAME = "@prisma/cli";
+const PRISMA_CLI_PACKAGE_SPEC = `${PRISMA_CLI_PACKAGE_NAME}@latest`;
+const DEFAULT_PRISMA_CLI_PACKAGE_RUNNER = ["npx", "-y"];
+const PRISMA_CLI_BINARY = "prisma-cli";
+function formatPrismaCliCommand(args, options = {}) {
+	return [...getPrismaCliCommandPrefix(options), ...args].join(" ");
+}
+function getPrismaCliCommandPrefix({ invocation = "package", packageRunner = DEFAULT_PRISMA_CLI_PACKAGE_RUNNER }) {
+	if (invocation === "binary") return [PRISMA_CLI_BINARY];
+	return [...packageRunner, PRISMA_CLI_PACKAGE_SPEC];
+}
+//#endregion
+export { DEFAULT_PRISMA_CLI_PACKAGE_RUNNER, PRISMA_CLI_BINARY, PRISMA_CLI_PACKAGE_NAME, PRISMA_CLI_PACKAGE_SPEC, formatPrismaCliCommand };

package/dist/cli-name.js

@@ -0,0 +1,12 @@
+//#region src/cli-name.ts
+/**
+* The CLI's user-facing identity, in one place. The npm package is
+* "@prisma/cli" but the binary on PATH is "prisma-cli" (the S1
+* convention) — every user-facing command string and notice consumes
+* this constant rather than restating the name.
+*/
+const CLI_NAME = "prisma-cli";
+/** The CLI docs page (also the update-check fallback instruction URL). */
+const CLI_DOCS_URL = "https://www.prisma.io/docs/orm/tools/prisma-cli";
+//#endregion
+export { CLI_DOCS_URL, CLI_NAME };

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runUpdateDiscoveryWorker } from "./shell/update-check.js";
+import { runUpdateDiscoveryWorker } from "./update-check.js";
 import { runCli } from "./cli2.js";
 import process from "node:process";
 //#region src/bin.ts

package/dist/cli2.js

@@ -1,20 +1,25 @@
-import { CliError } from "./shell/errors.js";
-import "./shell/prompt.js";
+import { CliError } from "./errors.js";
 import { attachCommandDescriptor } from "./shell/command-meta.js";
-import { addCompactGlobalFlags } from "./shell/global-flags.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 { 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 { 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 { maybeWriteCachedUpdateNotification } from "./update-check.js";
 import process from "node:process";
 import { Command, CommanderError, Option } from "commander";
 //#region src/cli.ts
@@ -34,7 +39,15 @@ async function runCli(options = {}) {
 		return process.exitCode ?? 0;
 	} catch (error) {
 		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
-		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace")));
+		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;
@@ -46,11 +59,16 @@ function createProgram(runtime) {
 	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;
 }
@@ -111,7 +129,6 @@ function resolveRuntime(options) {
 		stdin: options.stdin ?? process.stdin,
 		stdout: options.stdout ?? process.stdout,
 		stderr: options.stderr ?? process.stderr,
-		fixturePath: options.fixturePath,
 		stateDir: options.stateDir
 	};
 }

package/dist/command-arguments.js

@@ -0,0 +1,12 @@
+//#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

@@ -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,11 @@
-import { usageError } from "../../shell/errors.js";
-import { APP_BUILD_TYPES } from "../../lib/app/build.js";
+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 { runCommand, runStreamingCommand } from "../../shell/command-runner.js";
 import { Command, Option } from "commander";
 import { FRAMEWORK_KEYS, LOCAL_DEV_BUILD_TYPES } from "@prisma/compute-sdk/config";
 //#region src/commands/app/index.ts
@@ -66,7 +66,7 @@ function createRunCommand(runtime) {
 }
 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("--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"));
+	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;
@@ -74,10 +74,12 @@ function createDeployCommand(runtime) {
 		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) => {
@@ -89,8 +91,10 @@ function createDeployCommand(runtime) {
 				entrypoint: entry,
 				framework,
 				httpPort,
+				region,
 				envAssignments,
 				prod: prod === true,
+				noPromote,
 				db,
 				configTarget
 			});
@@ -329,12 +333,13 @@ function createRollbackCommand(runtime) {
 }
 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"));
+	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;
-		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef, configTarget), {
+		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)
 		});

package/dist/commands/auth/index.js

@@ -1,8 +1,8 @@
 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, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceUse } from "../../controllers/auth.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
@@ -17,10 +17,9 @@ function createAuthCommand(runtime) {
 }
 function createAuthLoginCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("login"), runtime), "auth.login");
-	command.addOption(new Option("--provider <provider>").hideHelp()).addOption(new Option("--user <id>").hideHelp()).addOption(new Option("--workspace <id>").hideHelp());
 	addGlobalFlags(command);
 	command.action(async (options) => {
-		await runCommand(runtime, "auth.login", options, (context) => runAuthLogin(context, options), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.login", result) });
+		await runCommand(runtime, "auth.login", options, (context) => runAuthLogin(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.login", result) });
 	});
 	return command;
 }

package/dist/commands/bucket/index.js

@@ -0,0 +1,123 @@
+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 { runBucketCreate, runBucketDelete, runBucketKeyCreate, runBucketKeyDelete, runBucketKeyList, runBucketList } from "../../controllers/bucket.js";
+import { renderBucketCreate, renderBucketDelete, renderBucketKeyCreate, renderBucketKeyCreateStdout, renderBucketKeyDelete, renderBucketKeyList, renderBucketList, serializeBucketCreate, serializeBucketDelete, serializeBucketKeyCreate, serializeBucketKeyDelete, serializeBucketKeyList, serializeBucketList } from "../../presenters/bucket.js";
+import { Command, Option } from "commander";
+//#region src/commands/bucket/index.ts
+function createBucketCommand(runtime) {
+	const bucket = attachCommandDescriptor(configureRuntimeCommand(new Command("bucket"), runtime), "bucket");
+	addCompactGlobalFlags(bucket);
+	bucket.addCommand(createBucketListCommand(runtime));
+	bucket.addCommand(createBucketCreateCommand(runtime));
+	bucket.addCommand(createBucketDeleteCommand(runtime));
+	bucket.addCommand(createBucketKeyCommand(runtime));
+	return bucket;
+}
+function addProjectAndBranchOptions(command) {
+	return command.addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <git-name>", "Branch git name"));
+}
+function createBucketListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "bucket.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "bucket.list", options, (context) => runBucketList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderBucketList(context, descriptor, result),
+			renderJson: (result) => serializeBucketList(result)
+		});
+	});
+	return command;
+}
+function createBucketCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "bucket.create");
+	command.addOption(new Option("--name <name>", "Bucket display name (auto-generated if omitted)"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "bucket.create", options, (context) => runBucketCreate(context, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderHuman: (context, descriptor, result) => renderBucketCreate(context, descriptor, result),
+			renderJson: (result) => serializeBucketCreate(result)
+		});
+	});
+	return command;
+}
+function createBucketDeleteCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("delete"), runtime), "bucket.delete");
+	command.argument("<bucketId>", "Bucket id");
+	command.addOption(new Option("--confirm <bucket-id>", "Exact bucket id to confirm deletion"));
+	addGlobalFlags(command);
+	command.action(async (bucketId, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "bucket.delete", options, (context) => runBucketDelete(context, bucketId, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderBucketDelete(context, descriptor, result),
+			renderJson: (result) => serializeBucketDelete(result)
+		});
+	});
+	return command;
+}
+function createBucketKeyCommand(runtime) {
+	const key = attachCommandDescriptor(configureRuntimeCommand(new Command("key"), runtime), "bucket.key");
+	addCompactGlobalFlags(key);
+	key.addCommand(createBucketKeyListCommand(runtime));
+	key.addCommand(createBucketKeyCreateCommand(runtime));
+	key.addCommand(createBucketKeyDeleteCommand(runtime));
+	return key;
+}
+function createBucketKeyListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "bucket.key.list");
+	command.argument("<bucketId>", "Bucket id");
+	addGlobalFlags(command);
+	command.action(async (bucketId, options) => {
+		await runCommand(runtime, "bucket.key.list", options, (context) => runBucketKeyList(context, bucketId), {
+			renderHuman: (context, descriptor, result) => renderBucketKeyList(context, descriptor, result),
+			renderJson: (result) => serializeBucketKeyList(result)
+		});
+	});
+	return command;
+}
+function createBucketKeyCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "bucket.key.create");
+	command.argument("<bucketId>", "Bucket id").addOption(new Option("--role <role>", "Access role (default: read_write)").choices(["read", "read_write"])).addOption(new Option("--name <name>", "Key display name (auto-generated if omitted)"));
+	addGlobalFlags(command);
+	command.action(async (bucketId, options) => {
+		const role = options.role;
+		const name = options.name;
+		await runCommand(runtime, "bucket.key.create", options, (context) => runBucketKeyCreate(context, bucketId, {
+			role,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderBucketKeyCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderBucketKeyCreate(context, descriptor, result),
+			renderJson: (result) => serializeBucketKeyCreate(result)
+		});
+	});
+	return command;
+}
+function createBucketKeyDeleteCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("delete"), runtime), "bucket.key.delete");
+	command.argument("<bucketId>", "Bucket id").argument("<keyId>", "Key id");
+	addGlobalFlags(command);
+	command.action(async (bucketId, keyId, options) => {
+		await runCommand(runtime, "bucket.key.delete", options, (context) => runBucketKeyDelete(context, bucketId, keyId), {
+			renderHuman: (context, descriptor, result) => renderBucketKeyDelete(context, descriptor, result),
+			renderJson: (result) => serializeBucketKeyDelete(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createBucketCommand };

package/dist/commands/build/index.js

@@ -0,0 +1,29 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runStreamingCommand } from "../../shell/command-runner.js";
+import { runBuildLogs } from "../../controllers/build.js";
+import { Command, Option } from "commander";
+//#region src/commands/build/index.ts
+function createBuildCommand(runtime) {
+	const build = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "build");
+	addCompactGlobalFlags(build);
+	build.addCommand(createLogsCommand(runtime));
+	return build;
+}
+function createLogsCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "build.logs");
+	command.argument("<buildId>", "Build id from a git-push or Console deploy").addOption(new Option("--follow", "Keep the connection open and stream new logs as the build runs")).addOption(new Option("--cursor <cursor>", "Resume from a prior terminal cursor"));
+	addGlobalFlags(command);
+	command.action(async (buildId, options) => {
+		const follow = options.follow;
+		const cursor = options.cursor;
+		await runStreamingCommand(runtime, "build.logs", options, (context) => runBuildLogs(context, buildId, {
+			follow,
+			cursor
+		}), { emitJsonSuccessEvent: false });
+	});
+	return command;
+}
+//#endregion
+export { createBuildCommand };