@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/commands/database/index.js

@@ -0,0 +1,249 @@
+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 { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage } from "../../controllers/database.js";
+import { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage } from "../../presenters/database.js";
+import { Command, Option } from "commander";
+//#region src/commands/database/index.ts
+function createDatabaseCommand(runtime) {
+	const database = attachCommandDescriptor(configureRuntimeCommand(new Command("database"), runtime), "database");
+	addCompactGlobalFlags(database);
+	database.addCommand(createDatabaseListCommand(runtime));
+	database.addCommand(createDatabaseShowCommand(runtime));
+	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseUsageCommand(runtime));
+	database.addCommand(createDatabaseRestoreCommand(runtime));
+	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseBackupCommand(runtime));
+	database.addCommand(createDatabaseConnectionCommand(runtime));
+	return database;
+}
+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 createDatabaseListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.list", options, (context) => runDatabaseList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "database.show");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.show", options, (context) => runDatabaseShow(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseShow(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseShow(result)
+		});
+	});
+	return command;
+}
+function createDatabaseCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.create");
+	command.argument("<name>", "Database name").addOption(new Option("--region <region>", "Prisma Postgres region id"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const region = options.region;
+		await runCommand(runtime, "database.create", options, (context) => runDatabaseCreate(context, name, {
+			projectRef,
+			branchName,
+			region
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseUsageCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("usage"), runtime), "database.usage");
+	command.argument("<database>", "Database id or name").addOption(new Option("--from <iso-date>", "Start of the usage period")).addOption(new Option("--to <iso-date>", "End of the usage period"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const from = options.from;
+		const to = options.to;
+		await runCommand(runtime, "database.usage", options, (context) => runDatabaseUsage(context, databaseRef, {
+			projectRef,
+			branchName,
+			from,
+			to
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseUsage(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseUsage(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRestoreCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("restore"), runtime), "database.restore");
+	command.argument("<database>", "Target database id or name").addOption(new Option("--backup <backup-id>", "Backup to restore from")).addOption(new Option("--source-database <database>", "Database the backup belongs to (defaults to the target)")).addOption(new Option("--confirm <database-id>", "Exact target database id required to restore"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const backupId = options.backup;
+		const sourceDatabaseRef = options.sourceDatabase;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.restore", options, (context) => runDatabaseRestore(context, databaseRef, {
+			projectRef,
+			branchName,
+			backupId,
+			sourceDatabaseRef,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRestore(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRestore(result)
+		});
+	});
+	return command;
+}
+function createDatabaseBackupCommand(runtime) {
+	const backup = attachCommandDescriptor(configureRuntimeCommand(new Command("backup"), runtime), "database.backup");
+	addCompactGlobalFlags(backup);
+	backup.addCommand(createDatabaseBackupListCommand(runtime));
+	return backup;
+}
+function createDatabaseBackupListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.backup.list");
+	command.argument("<database>", "Database id or name").addOption(new Option("--limit <n>", "Maximum number of backups to return"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const limit = options.limit;
+		await runCommand(runtime, "database.backup.list", options, (context) => runDatabaseBackupList(context, databaseRef, {
+			projectRef,
+			branchName,
+			limit
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseBackupList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseBackupList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.remove");
+	command.argument("<database>", "Database id or name").addOption(new Option("--confirm <database-id>", "Exact database id required to remove"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.remove", options, (context) => runDatabaseRemove(context, databaseRef, {
+			projectRef,
+			branchName,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRemove(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCommand(runtime) {
+	const connection = attachCommandDescriptor(configureRuntimeCommand(new Command("connection"), runtime), "database.connection");
+	addCompactGlobalFlags(connection);
+	connection.addCommand(createDatabaseConnectionListCommand(runtime));
+	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRotateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
+	return connection;
+}
+function createDatabaseConnectionRotateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rotate"), runtime), "database.connection.rotate");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to rotate"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.rotate", options, (context) => runDatabaseConnectionRotate(context, connectionRef, { confirm }), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionRotateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRotate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRotate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.connection.list", options, (context) => runDatabaseConnectionList(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.connection.create");
+	command.argument("<database>", "Database id or name").addOption(new Option("--name <name>", "Connection name"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "database.connection.create", options, (context) => runDatabaseConnectionCreate(context, databaseRef, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.connection.remove");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.remove", options, (context) => runDatabaseConnectionRemove(context, connectionRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createDatabaseCommand };

package/dist/commands/env.js

@@ -17,16 +17,18 @@ function createEnvCommand(runtime) {
 }
 function createEnvAddCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
 			renderJson: (result) => serializeEnvAdd(result)
@@ -36,16 +38,18 @@ function createEnvAddCommand(runtime) {
 }
 function createEnvUpdateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
 			renderJson: (result) => serializeEnvUpdate(result)

package/dist/commands/feedback/index.js

@@ -0,0 +1,20 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runFeedback } from "../../controllers/feedback.js";
+import { renderFeedbackSuccess } from "../../presenters/feedback.js";
+import { Command, Option } from "commander";
+//#region src/commands/feedback/index.ts
+function createFeedbackCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("feedback"), runtime), "feedback");
+	command.argument("<message>", "Feedback text (up to 4000 characters)").addOption(new Option("--email <address>", "Contact email if you want a reply; feedback is anonymous without it"));
+	addGlobalFlags(command);
+	command.action(async (message, options) => {
+		const flags = options;
+		await runCommand(runtime, "feedback", options, (context) => runFeedback(context, message, { email: flags.email }), { renderHuman: (context, descriptor, result) => renderFeedbackSuccess(context, descriptor, result) });
+	});
+	return command;
+}
+//#endregion
+export { createFeedbackCommand };

package/dist/commands/git/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 { runGitConnect, runGitDisconnect } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
+import { runGitConnect, runGitDisconnect } from "../../controllers/project.js";
 import { renderGitConnect, renderGitDisconnect } from "../../presenters/project.js";
 import { Command } from "commander";
 //#region src/commands/git/index.ts

package/dist/commands/init/index.js

@@ -0,0 +1,33 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runInit } from "../../controllers/init.js";
+import { renderInit, serializeInit } from "../../presenters/init.js";
+import { Command, Option } from "commander";
+//#region src/commands/init/index.ts
+function createInitCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
+	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step")).addOption(new Option("--format <ts|json>", "Config file format: ts (default) writes prisma.compute.ts, json writes dependency-free prisma.compute.json; --format ts converts an existing prisma.compute.json"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const flags = options;
+		await runCommand(runtime, "init", options, (context) => runInit(context, {
+			framework: flags.framework,
+			entry: flags.entry,
+			httpPort: flags.httpPort,
+			region: flags.region,
+			name: flags.name,
+			link: flags.link,
+			project: flags.project,
+			install: flags.install,
+			format: flags.format
+		}), {
+			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
+			renderJson: (result) => serializeInit(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createInitCommand };

package/dist/commands/project/index.js

@@ -1,11 +1,11 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.js";
+import { runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer } from "../../controllers/project.js";
+import { renderProjectList, renderProjectRemove, renderProjectRename, renderProjectSetup, renderProjectShow, renderProjectTransfer, serializeProjectList, serializeProjectRemove, serializeProjectRename, serializeProjectSetup, serializeProjectShow, serializeProjectTransfer } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 //#region src/commands/project/index.ts
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
@@ -14,15 +14,64 @@ function createProjectCommand(runtime) {
 	project.addCommand(createProjectShowCommand(runtime));
 	project.addCommand(createProjectCreateCommand(runtime));
 	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createProjectRenameCommand(runtime));
+	project.addCommand(createProjectRemoveCommand(runtime));
+	project.addCommand(createProjectTransferCommand(runtime));
 	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
+function createProjectRenameCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rename"), runtime), "project.rename");
+	command.argument("<name>", "New project name").addOption(new Option("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.rename", options, (context) => runProjectRename(context, name, { project: projectRef }), {
+			renderHuman: (context, descriptor, result) => renderProjectRename(context, descriptor, result),
+			renderJson: (result) => serializeProjectRename(result)
+		});
+	});
+	return command;
+}
+function createProjectRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "project.remove");
+	command.argument("<project>", "Project id or name").addOption(new Option("--confirm <project-id>", "Exact project id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.remove", options, (context) => runProjectRemove(context, projectRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderProjectRemove(context, descriptor, result),
+			renderJson: (result) => serializeProjectRemove(result)
+		});
+	});
+	return command;
+}
+function createProjectTransferCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("transfer"), runtime), "project.transfer");
+	command.argument("<project>", "Project id or name").addOption(new Option("--to-workspace <id-or-name>", "Locally authenticated workspace to receive the project")).addOption(new Option("--recipient-token <token>", "Access token for the receiving workspace")).addOption(new Option("--confirm <project-id>", "Exact project id required to transfer"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const toWorkspace = options.toWorkspace;
+		const recipientToken = options.recipientToken;
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.transfer", options, (context) => runProjectTransfer(context, projectRef, {
+			toWorkspace,
+			recipientToken,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderProjectTransfer(context, descriptor, result),
+			renderJson: (result) => serializeProjectTransfer(result)
+		});
+	});
+	return command;
+}
 function createProjectCreateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
-	command.argument("<name>", "Project name");
+	command.argument("<name>", "Project name").addOption(new Option("--region <region>", "Prisma Compute region id"));
 	addGlobalFlags(command);
 	command.action(async (name, options) => {
-		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name)), {
+		const region = options.region;
+		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name), { region }), {
 			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
 			renderJson: (result) => serializeProjectSetup(result)
 		});

package/dist/controllers/agent-setup.js

@@ -0,0 +1,52 @@
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { PRISMA_AGENT_INSTALL_ARGS, PRISMA_COMPUTE_AGENT_SKILL } from "../lib/agent/constants.js";
+import { readPrismaAgentSetupStatus, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
+import { runAgentInstall } from "./agent.js";
+import { renderSummaryLine } from "../shell/ui.js";
+import { canPrompt } from "../shell/runtime.js";
+import { confirmPrompt } from "../shell/prompt.js";
+//#region src/controllers/agent-setup.ts
+/**
+* One-time interactive offer to install the Prisma Compute skill for the
+* project. Shared by the commands that establish a project setup (init,
+* deploy); the answer is remembered, so whichever command runs first asks.
+* Returns warnings; a failed install must not fail the calling command.
+*/
+async function maybePromptForAgentSetup(context, projectDir) {
+	if (!canPrompt(context) || context.flags.yes || context.flags.quiet) return [];
+	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
+		cwd: projectDir,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal,
+		requiredSkill: "prisma-compute"
+	}))) return [];
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		signal: context.runtime.signal,
+		message: "Install the Prisma Compute skill for this project?",
+		initialValue: true
+	})) {
+		await context.stateStore.setAgentSetupPromptDismissedAt((/* @__PURE__ */ new Date()).toISOString());
+		return [];
+	}
+	try {
+		await runAgentInstall(context, { skill: [PRISMA_COMPUTE_AGENT_SKILL] }, "install", { cwd: projectDir });
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "success", "Installed the Prisma Compute skill for this project.")}\n\n`);
+		return [];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Prisma skill install failed.";
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", `Skipped Prisma skill install: ${message}`)}\n\n`);
+		return [`The Prisma Compute skill was not installed. Run ${await resolvePrismaCliPackageCommand({
+			cwd: projectDir,
+			signal: context.runtime.signal,
+			args: [
+				...PRISMA_AGENT_INSTALL_ARGS,
+				"--skill",
+				PRISMA_COMPUTE_AGENT_SKILL
+			]
+		})} to try again.`];
+	}
+}
+//#endregion
+export { maybePromptForAgentSetup };