@prisma/cli 3.0.0-alpha.3 → 3.0.0-alpha.4

package/dist/adapters/git.js

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/adapters/git.ts
+const execFileAsync = promisify(execFile);
+async function readGitOriginRemote(cwd) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"config",
+			"--get",
+			"remote.origin.url"
+		], {
+			cwd,
+			timeout: 5e3
+		});
+		const remote = stdout.trim();
+		return remote.length > 0 ? remote : null;
+	} catch {
+		return null;
+	}
+}
+function parseGitHubRepositoryUrl(value) {
+	const input = value.trim();
+	const shorthand = input.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/);
+	if (shorthand) return toGitHubRepositoryReference(shorthand[1], shorthand[2]);
+	let parsed;
+	try {
+		parsed = new URL(input);
+	} catch {
+		return null;
+	}
+	if (parsed.hostname !== "github.com") return null;
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:" && parsed.protocol !== "ssh:") return null;
+	const parts = parsed.pathname.split("/").filter(Boolean);
+	if (parts.length !== 2) return null;
+	const [owner, rawName] = parts;
+	return toGitHubRepositoryReference(owner, rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName);
+}
+function toGitHubRepositoryReference(owner, name) {
+	if (!owner || !name || owner.includes("/") || name.includes("/")) return null;
+	return {
+		provider: "github",
+		owner,
+		name,
+		fullName: `${owner}/${name}`,
+		url: `https://github.com/${owner}/${name}`
+	};
+}
+//#endregion
+export { parseGitHubRepositoryUrl, readGitOriginRemote };

package/dist/adapters/local-state.js

@@ -3,6 +3,11 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 //#region src/adapters/local-state.ts
 const DEFAULT_STATE = {
 	auth: null,
+	project: {
+		rememberedByWorkspace: {},
+		lastResolved: null,
+		repositoryConnectionsByProject: {}
+	},
 	branch: { active: "preview" },
 	app: {
 		selectedByProject: {},
@@ -24,6 +29,11 @@ var LocalStateStore = class {
 			const parsed = JSON.parse(raw);
 			return {
 				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
+				project: {
+					rememberedByWorkspace: parsed.project?.rememberedByWorkspace ?? {},
+					lastResolved: parsed.project?.lastResolved ?? null,
+					repositoryConnectionsByProject: parsed.project?.repositoryConnectionsByProject ?? {}
+				},
 				branch: { active: parsed.branch?.active ?? DEFAULT_STATE.branch.active },
 				app: {
 					selectedByProject: parsed.app?.selectedByProject ?? {},
@@ -57,6 +67,34 @@ var LocalStateStore = class {
 		await this.write(state);
 		return state;
 	}
+	async readRememberedProject(workspaceId) {
+		return (await this.read()).project.rememberedByWorkspace[workspaceId] ?? null;
+	}
+	async readLastResolvedProject() {
+		return (await this.read()).project.lastResolved;
+	}
+	async setRememberedProject(project) {
+		const state = await this.read();
+		state.project.rememberedByWorkspace[project.workspaceId] = project;
+		state.project.lastResolved = project;
+		await this.write(state);
+		return state;
+	}
+	async readRepositoryConnection(projectId) {
+		return (await this.read()).project.repositoryConnectionsByProject[projectId] ?? null;
+	}
+	async setRepositoryConnection(projectId, connection) {
+		const state = await this.read();
+		state.project.repositoryConnectionsByProject[projectId] = connection;
+		await this.write(state);
+		return state;
+	}
+	async clearRepositoryConnection(projectId) {
+		const state = await this.read();
+		delete state.project.repositoryConnectionsByProject[projectId];
+		await this.write(state);
+		return state;
+	}
 	async readSelectedApp(projectId) {
 		return (await this.read()).app.selectedByProject[projectId] ?? null;
 	}

package/dist/cli2.js

@@ -5,6 +5,7 @@ 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 { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import process from "node:process";
 import { Command, CommanderError } from "commander";
@@ -35,8 +36,9 @@ function createProgram(runtime) {
 	addCompactGlobalFlags(program);
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createAuthCommand(runtime));
-	program.addCommand(createBranchCommand(runtime));
 	program.addCommand(createProjectCommand(runtime));
+	program.addCommand(createGitCommand(runtime));
+	program.addCommand(createBranchCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }

package/dist/commands/app/index.js

@@ -60,7 +60,7 @@ 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("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Deploy build type").choices([...PREVIEW_BUILD_TYPES]).default("auto")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Deploy build type").choices([...PREVIEW_BUILD_TYPES]).default("auto")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -68,7 +68,9 @@ function createDeployCommand(runtime) {
 		const buildType = options.buildType;
 		const httpPort = options.httpPort;
 		const envAssignments = options.env;
+		const projectRef = options.project;
 		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
+			projectRef,
 			entrypoint: entry,
 			buildType,
 			httpPort,
@@ -82,12 +84,13 @@ function createDeployCommand(runtime) {
 }
 function createUpdateEnvCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update-env"), runtime), "app.update-env");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const envAssignments = options.env;
-		await runCommand(runtime, "app.update-env", options, (context) => runAppUpdateEnv(context, appName, envAssignments), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.update-env", options, (context) => runAppUpdateEnv(context, appName, envAssignments, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppUpdateEnv(context, descriptor, result),
 			renderJson: (result) => serializeAppUpdateEnv(result)
 		});
@@ -96,11 +99,12 @@ function createUpdateEnvCommand(runtime) {
 }
 function createListEnvCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-env"), runtime), "app.list-env");
-	command.addOption(new Option("--app <name>", "App name"));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.list-env", options, (context) => runAppListEnv(context, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.list-env", options, (context) => runAppListEnv(context, appName, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppListEnv(context, descriptor, result),
 			renderJson: (result) => serializeAppListEnv(result)
 		});
@@ -109,11 +113,12 @@ function createListEnvCommand(runtime) {
 }
 function createShowCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
-	command.addOption(new Option("--app <name>", "App name"));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
 			renderJson: (result) => serializeAppShow(result)
 		});
@@ -122,11 +127,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"));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
 			renderJson: (result) => serializeAppOpen(result)
 		});
@@ -135,12 +141,13 @@ function createOpenCommand(runtime) {
 }
 function createLogsCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "app.logs");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--deployment <id>", "Deployment id"));
+	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"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const deploymentId = options.deployment;
-		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId));
+		const projectRef = options.project;
+		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId, projectRef));
 	});
 	return command;
 }
@@ -149,11 +156,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"));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppListDeploys(context, descriptor, result),
 			renderJson: (result) => serializeAppListDeploys(result)
 		});
@@ -175,11 +183,12 @@ function createShowDeployCommand(runtime) {
 function createPromoteCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("promote"), runtime), "app.promote");
 	command.argument("<deployment>", "Deployment id");
-	command.addOption(new Option("--app <name>", "App name"));
+	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) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppPromote(context, descriptor, result),
 			renderJson: (result) => serializeAppPromote(result)
 		});
@@ -188,12 +197,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("--to <deployment>", "Deployment id"));
+	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"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const deploymentId = options.to;
-		await runCommand(runtime, "app.rollback", options, (context) => runAppRollback(context, appName, deploymentId), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.rollback", options, (context) => runAppRollback(context, appName, deploymentId, projectRef), {
 			renderHuman: (context, descriptor, result) => renderAppRollback(context, descriptor, result),
 			renderJson: (result) => serializeAppRollback(result)
 		});
@@ -202,11 +212,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"));
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName), {
+		const projectRef = options.project;
+		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef), {
 			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 { runCommand } from "../../shell/command-runner.js";
 import { runAuthLogin, runAuthLogout, runAuthWhoAmI } from "../../controllers/auth.js";
+import { runCommand } from "../../shell/command-runner.js";
 import { renderAuthSuccess } from "../../presenters/auth.js";
 import { Command, Option } from "commander";
 //#region src/commands/auth/index.ts

package/dist/commands/env.js

@@ -8,7 +8,7 @@ import { Command, Option } from "commander";
 //#region src/commands/env.ts
 function createEnvCommand(runtime) {
 	const env = attachCommandDescriptor(configureRuntimeCommand(new Command("env"), runtime), "project.env");
-	env.description("Manage environment variables for the linked project.");
+	env.description("Manage environment variables for the active project");
 	env.addCommand(createEnvAddCommand(runtime));
 	env.addCommand(createEnvUpdateCommand(runtime));
 	env.addCommand(createEnvListCommand(runtime));
@@ -17,11 +17,15 @@ function createEnvCommand(runtime) {
 }
 function createEnvAddCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
-	command.argument("<assignment>", "Variable assignment in KEY=VALUE form").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	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("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
-		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, { roleName }), {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
+			roleName,
+			projectRef
+		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
 			renderJson: (result) => serializeEnvAdd(result)
 		});
@@ -30,11 +34,15 @@ function createEnvAddCommand(runtime) {
 }
 function createEnvUpdateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
-	command.argument("<assignment>", "Variable assignment in KEY=VALUE form").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	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("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
-		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, { roleName }), {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
+			roleName,
+			projectRef
+		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
 			renderJson: (result) => serializeEnvUpdate(result)
 		});
@@ -43,11 +51,15 @@ function createEnvUpdateCommand(runtime) {
 }
 function createEnvListCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "project.env.list");
-	command.addOption(new Option("--role <role>", "Project template scope").choices(["production", "preview"]));
+	command.addOption(new Option("--role <role>", "Project template scope").choices(["production", "preview"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const roleName = options.role;
-		await runCommand(runtime, "project.env.list", options, (context) => runEnvList(context, { roleName }), {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.env.list", options, (context) => runEnvList(context, {
+			roleName,
+			projectRef
+		}), {
 			renderHuman: (context, descriptor, result) => renderEnvList(context, descriptor, result),
 			renderJson: (result) => serializeEnvList(result)
 		});
@@ -56,11 +68,15 @@ function createEnvListCommand(runtime) {
 }
 function createEnvRmCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rm"), runtime), "project.env.rm");
-	command.argument("<key>", "Variable key to remove").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	command.argument("<key>", "Variable key to remove").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (key, options) => {
 		const roleName = options.role;
-		await runCommand(runtime, "project.env.rm", options, (context) => runEnvRm(context, key, { roleName }), {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.env.rm", options, (context) => runEnvRm(context, key, {
+			roleName,
+			projectRef
+		}), {
 			renderHuman: (context, descriptor, result) => renderEnvRm(context, descriptor, result),
 			renderJson: (result) => serializeEnvRm(result)
 		});

package/dist/commands/git/index.js

@@ -0,0 +1,36 @@
+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 { renderGitConnect, renderGitDisconnect } from "../../presenters/project.js";
+import { Command } from "commander";
+//#region src/commands/git/index.ts
+function createGitCommand(runtime) {
+	const git = attachCommandDescriptor(configureRuntimeCommand(new Command("git"), runtime), "git");
+	addCompactGlobalFlags(git);
+	git.addCommand(createGitConnectCommand(runtime));
+	git.addCommand(createGitDisconnectCommand(runtime));
+	return git;
+}
+function createGitConnectCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("connect"), runtime), "git.connect");
+	command.argument("[git-url]", "GitHub repository URL");
+	command.option("--project <id-or-name>", "Project id or name");
+	addGlobalFlags(command);
+	command.action(async (gitUrl, options) => {
+		await runCommand(runtime, "git.connect", options, (context) => runGitConnect(context, gitUrl, { project: typeof options.project === "string" ? options.project : void 0 }), { renderHuman: (context, descriptor, result) => renderGitConnect(context, descriptor, result) });
+	});
+	return command;
+}
+function createGitDisconnectCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("disconnect"), runtime), "git.disconnect");
+	command.option("--project <id-or-name>", "Project id or name");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "git.disconnect", options, (context) => runGitDisconnect(context, { project: typeof options.project === "string" ? options.project : void 0 }), { renderHuman: (context, descriptor, result) => renderGitDisconnect(context, descriptor, result) });
+	});
+	return command;
+}
+//#endregion
+export { createGitCommand };

package/dist/commands/project/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 { runProjectList, runProjectShow } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
-import { renderProjectLink, renderProjectList, renderProjectShow, serializeProjectList } from "../../presenters/project.js";
+import { renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
 import { Command } from "commander";
 //#region src/commands/project/index.ts
@@ -12,7 +12,6 @@ function createProjectCommand(runtime) {
 	addCompactGlobalFlags(project);
 	project.addCommand(createProjectListCommand(runtime));
 	project.addCommand(createProjectShowCommand(runtime));
-	project.addCommand(createProjectLinkCommand(runtime));
 	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
@@ -29,18 +28,14 @@ function createProjectListCommand(runtime) {
 }
 function createProjectShowCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "project.show");
+	command.option("--project <id-or-name>", "Project id or name");
 	addGlobalFlags(command);
 	command.action(async (options) => {
-		await runCommand(runtime, "project.show", options, (context) => runProjectShow(context), { renderHuman: (context, descriptor, result) => renderProjectShow(context, descriptor, result) });
-	});
-	return command;
-}
-function createProjectLinkCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("link"), runtime), "project.link");
-	command.argument("[project]", "Project id");
-	addGlobalFlags(command);
-	command.action(async (projectId, options) => {
-		await runCommand(runtime, "project.link", options, (context) => runProjectLink(context, projectId), { renderHuman: (context, descriptor, result) => renderProjectLink(context, descriptor, result) });
+		const projectRef = options.project;
+		await runCommand(runtime, "project.show", options, (context) => runProjectShow(context, projectRef), {
+			renderHuman: (context, descriptor, result) => renderProjectShow(context, descriptor, result),
+			renderJson: (result) => serializeProjectShow(result)
+		});
 	});
 	return command;
 }

package/dist/controllers/app-env.js

@@ -1,6 +1,9 @@
-import { readLinkedProjectId } from "../adapters/config.js";
-import { CliError, authRequiredError, usageError } from "../shell/errors.js";
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
+import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listRealWorkspaceProjects } from "./project.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
 //#region src/controllers/app-env.ts
 function defaultRoleScope() {
@@ -10,13 +13,13 @@ function defaultRoleScope() {
 	};
 }
 async function runEnvAdd(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "add");
+	const { key, value } = parseKeyValuePositional(rawAssignment, "add", context.runtime.env);
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "add"
 	});
 	if (!scope) throw usageError(`prisma-cli project env add requires --role`, "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
 	const resolved = resolveScopeToApi(scope);
 	if (await findVariableByNaturalKey(client, projectId, key, resolved)) throw new CliError({
 		code: "ENV_VARIABLE_ALREADY_EXISTS",
@@ -46,13 +49,13 @@ async function runEnvAdd(context, rawAssignment, flags) {
 	};
 }
 async function runEnvUpdate(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "update");
+	const { key, value } = parseKeyValuePositional(rawAssignment, "update", context.runtime.env);
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "update"
 	});
 	if (!scope) throw usageError(`prisma-cli project env update requires --role`, "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
 	const resolved = resolveScopeToApi(scope);
 	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
 	if (!existing) throw new CliError({
@@ -85,7 +88,7 @@ async function runEnvList(context, flags) {
 		requireExplicit: false,
 		command: "list"
 	}) ?? defaultRoleScope();
-	const { client, projectId } = await requireClientAndProject(context);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
 	const resolved = resolveScopeToApi(scope);
 	const variables = await listVariables(client, projectId, resolved);
 	return {
@@ -106,7 +109,7 @@ async function runEnvRm(context, key, flags) {
 		command: "rm"
 	});
 	if (!scope) throw usageError("prisma-cli project env rm requires --role", "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env rm ${key} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
 	const resolved = resolveScopeToApi(scope);
 	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
 	if (!existing) throw new CliError({
@@ -131,22 +134,21 @@ async function runEnvRm(context, key, flags) {
 		nextSteps: []
 	};
 }
-async function requireClientAndProject(context) {
-	const projectId = await readLinkedProjectId(context.runtime.cwd);
-	if (!projectId) throw new CliError({
-		code: "PROJECT_NOT_LINKED",
-		domain: "project",
-		summary: "Project link required",
-		why: "prisma-cli project env needs a linked project for the current repo.",
-		fix: "Run prisma project link before managing environment variables.",
-		exitCode: 1,
-		nextSteps: ["prisma project link"]
-	});
+async function requireClientAndProject(context, explicitProject) {
+	const authState = await requireAuthenticatedAuthState(context);
 	const client = await requireComputeAuth(context.runtime.env);
-	if (!client) throw authRequiredError(["prisma auth login"]);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	if (!authState.workspace) throw workspaceRequiredError();
 	return {
 		client,
-		projectId
+		projectId: (await resolveProjectTarget({
+			context,
+			workspace: authState.workspace,
+			explicitProject,
+			listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
+			prompt: createSelectPromptPort(context),
+			remember: true
+		})).project.id
 	};
 }
 function resolveScopeToApi(scope) {