@prisma/cli 3.0.0-alpha.2 → 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

@@ -4,7 +4,7 @@ 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) {
@@ -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 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;
 }
@@ -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

@@ -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,9 +1,10 @@
 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
 function createProjectCommand(runtime) {
@@ -11,7 +12,7 @@ function createProjectCommand(runtime) {
 	addCompactGlobalFlags(project);
 	project.addCommand(createProjectListCommand(runtime));
 	project.addCommand(createProjectShowCommand(runtime));
-	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
 function createProjectListCommand(runtime) {
@@ -27,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;
 }