@prisma/cli 3.0.0-alpha.0 → 3.0.0-alpha.10

package/README.md

@@ -18,22 +18,7 @@ pnpm prisma-cli app list-env
 ```
 
 The package exposes `prisma-cli` so it can coexist with the existing `prisma`
-executable. If you want local project scripts that use the future command shape,
-add:
-
-```json
-{
-  "scripts": {
-    "prisma": "prisma-cli"
-  }
-}
-```
-
-Then run:
-
-```bash
-pnpm prisma app deploy
-```
+executable.
 
 Notes:
 

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

@@ -1,8 +1,13 @@
-import path from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
 //#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

@@ -1,18 +1,27 @@
+import { CliError } from "./shell/errors.js";
+import { createShellUi } from "./shell/ui.js";
+import { writeHumanError, writeJsonError, writeJsonSuccess } from "./shell/output.js";
 import { attachCommandDescriptor } from "./shell/command-meta.js";
-import { configureRuntimeCommand } from "./shell/runtime.js";
+import { addCompactGlobalFlags } from "./shell/global-flags.js";
+import { configureRuntimeCommand, createCommandContext } from "./shell/runtime.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 { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
+import { getCliName, getCliVersion } from "./lib/version.js";
+import { runVersion } from "./controllers/version.js";
+import { createVersionCommand } from "./commands/version/index.js";
 import process from "node:process";
-import { Command, CommanderError } from "commander";
+import { Command, CommanderError, Option } from "commander";
 //#region src/cli.ts
 async function runCli(options = {}) {
 	const runtime = resolveRuntime(options);
 	const program = createProgram(runtime);
 	process.exitCode = 0;
 	try {
+		if (runtime.argv.includes("--version")) return await handleVersionFlag(runtime);
 		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
 		if (bareHelpCommand) {
 			runtime.stderr.write(bareHelpCommand.helpInformation());
@@ -31,17 +40,64 @@ async function runCli(options = {}) {
 }
 function createProgram(runtime) {
 	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
+	addCompactGlobalFlags(program);
+	program.addOption(new Option("--version", "Print the CLI version and exit."));
 	program.name("prisma").showSuggestionAfterError();
+	program.addCommand(createVersionCommand(runtime));
 	program.addCommand(createAuthCommand(runtime));
-	program.addCommand(createBranchCommand(runtime));
 	program.addCommand(createProjectCommand(runtime));
+	program.addCommand(createGitCommand(runtime));
+	program.addCommand(createBranchCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }
+async function handleVersionFlag(runtime) {
+	const wantsJson = runtime.argv.includes("--json");
+	const output = {
+		stdout: runtime.stdout,
+		stderr: runtime.stderr
+	};
+	try {
+		if (wantsJson) {
+			const success = await runVersion(await createCommandContext(runtime, buildVersionFlagFlags(runtime)));
+			writeJsonSuccess(output, {
+				command: success.command,
+				result: { version: success.result.cli.version },
+				warnings: success.warnings,
+				nextSteps: success.nextSteps
+			});
+			return 0;
+		}
+		const versionLine = `${getCliName()} ${getCliVersion()}`;
+		runtime.stdout.write(`${versionLine}\n`);
+		return 0;
+	} catch (error) {
+		if (error instanceof CliError) {
+			if (wantsJson) writeJsonError(output, "version", error);
+			else writeHumanError(output, createShellUi(runtime, buildVersionFlagFlags(runtime)), error, { trace: false });
+			return error.exitCode;
+		}
+		throw error;
+	}
+}
+function buildVersionFlagFlags(runtime) {
+	return {
+		json: runtime.argv.includes("--json"),
+		quiet: false,
+		verbose: false,
+		trace: false,
+		yes: false,
+		interactive: void 0,
+		color: void 0
+	};
+}
 function resolveBareHelpCommand(program, argv) {
 	if (argv.length === 0) return program;
 	if (argv.length !== 1) return null;
-	return program.commands.find((command) => command.name() === argv[0]) ?? null;
+	const candidate = program.commands.find((command) => command.name() === argv[0]) ?? null;
+	if (!candidate) return null;
+	if (candidate.commands.length === 0) return null;
+	return candidate;
 }
 function resolveRuntime(options) {
 	return {

package/dist/commands/app/index.js

@@ -1,13 +1,15 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { PREVIEW_BUILD_TYPES } from "../../lib/app/preview-build.js";
 import { runAppBuild, runAppDeploy, runAppListDeploys, runAppListEnv, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy, runAppUpdateEnv } from "../../controllers/app.js";
 import { renderAppBuild, renderAppDeploy, renderAppListDeploys, renderAppListEnv, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, renderAppUpdateEnv, serializeAppBuild, serializeAppDeploy, serializeAppListDeploys, serializeAppListEnv, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy, serializeAppUpdateEnv } from "../../presenters/app.js";
-import { runCommand } from "../../shell/command-runner.js";
+import { runCommand, runStreamingCommand } from "../../shell/command-runner.js";
 import { Command, Option } from "commander";
 //#region src/commands/app/index.ts
 function createAppCommand(runtime) {
 	const app = attachCommandDescriptor(configureRuntimeCommand(new Command("app"), runtime), "app");
+	addCompactGlobalFlags(app);
 	app.addCommand(createBuildCommand(runtime));
 	app.addCommand(createRunCommand(runtime));
 	app.addCommand(createDeployCommand(runtime));
@@ -25,11 +27,7 @@ function createAppCommand(runtime) {
 }
 function createBuildCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "app.build");
-	command.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([
-		"auto",
-		"bun",
-		"nextjs"
-	]).default("auto"));
+	command.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([...PREVIEW_BUILD_TYPES]).default("auto"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const entry = options.entry;
@@ -62,21 +60,27 @@ 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([
-		"auto",
-		"bun",
-		"nextjs"
-	]).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("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
+		"nextjs",
+		"hono",
+		"tanstack-start"
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Legacy deploy build type").choices([...PREVIEW_BUILD_TYPES]).default("auto").hideHelp()).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;
 		const entry = options.entry;
 		const buildType = options.buildType;
+		const branchName = options.branch;
+		const framework = options.framework;
 		const httpPort = options.httpPort;
 		const envAssignments = options.env;
+		const projectRef = options.project;
 		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
+			projectRef,
+			branchName,
 			entrypoint: entry,
 			buildType,
+			framework,
 			httpPort,
 			envAssignments
 		}), {
@@ -88,12 +92,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)
 		});
@@ -102,11 +107,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)
 		});
@@ -115,11 +121,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)
 		});
@@ -128,11 +135,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)
 		});
@@ -141,12 +149,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 runCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId), { renderHuman: () => [] });
+		const projectRef = options.project;
+		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId, projectRef));
 	});
 	return command;
 }
@@ -155,11 +164,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)
 		});
@@ -181,11 +191,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)
 		});
@@ -194,12 +205,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)
 		});
@@ -208,11 +220,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,13 +1,14 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.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
 function createAuthCommand(runtime) {
 	const auth = attachCommandDescriptor(configureRuntimeCommand(new Command("auth"), runtime), "auth");
+	addCompactGlobalFlags(auth);
 	auth.addCommand(createAuthLoginCommand(runtime));
 	auth.addCommand(createAuthLogoutCommand(runtime));
 	auth.addCommand(createAuthWhoAmICommand(runtime));

package/dist/commands/branch/index.js

@@ -1,5 +1,5 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
 import { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
@@ -8,6 +8,7 @@ import { Command } from "commander";
 //#region src/commands/branch/index.ts
 function createBranchCommand(runtime) {
 	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
+	addCompactGlobalFlags(branch);
 	branch.addCommand(createBranchListCommand(runtime));
 	branch.addCommand(createBranchShowCommand(runtime));
 	branch.addCommand(createBranchUseCommand(runtime));

package/dist/commands/env.js

@@ -0,0 +1,87 @@
+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 { runEnvAdd, runEnvList, runEnvRm, runEnvUpdate } from "../controllers/app-env.js";
+import { renderEnvAdd, renderEnvList, renderEnvRm, renderEnvUpdate, serializeEnvAdd, serializeEnvList, serializeEnvRm, serializeEnvUpdate } from "../presenters/app-env.js";
+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 active project");
+	env.addCommand(createEnvAddCommand(runtime));
+	env.addCommand(createEnvUpdateCommand(runtime));
+	env.addCommand(createEnvListCommand(runtime));
+	env.addCommand(createEnvRmCommand(runtime));
+	return env;
+}
+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("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (assignment, options) => {
+		const roleName = options.role;
+		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)
+		});
+	});
+	return command;
+}
+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("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (assignment, options) => {
+		const roleName = options.role;
+		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)
+		});
+	});
+	return command;
+}
+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"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const roleName = options.role;
+		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)
+		});
+	});
+	return command;
+}
+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"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (key, options) => {
+		const roleName = options.role;
+		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)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createEnvCommand };

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,16 +1,18 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.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
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
+	addCompactGlobalFlags(project);
 	project.addCommand(createProjectListCommand(runtime));
 	project.addCommand(createProjectShowCommand(runtime));
-	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
 function createProjectListCommand(runtime) {
@@ -26,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;
 }