@looma/prisma-cli 0.1.1

package/README.md

@@ -0,0 +1,39 @@
+# Prisma CLI Prototype
+
+Prototype npm distribution for the Compute-focused Prisma CLI work in this repo.
+
+Install:
+
+```bash
+pnpm add -D @looma/prisma-cli
+```
+
+Basic flow:
+
+```bash
+pnpm prisma-cli auth login
+pnpm prisma-cli app deploy
+```
+
+Notes:
+
+- the official Prisma ORM package still owns the `prisma` executable
+- this prototype intentionally exposes `prisma-cli` so both CLIs can coexist in one app
+- the canonical command shape is still `app deploy`, not `deploy`
+- `prisma.config.ts` is project-only in this prototype and will be created as a plain object export when needed
+
+If you want future-shaped local ergonomics in a test app, add:
+
+```json
+{
+  "scripts": {
+    "prisma": "prisma-cli"
+  }
+}
+```
+
+Then run:
+
+```bash
+pnpm prisma app deploy
+```

package/dist/adapters/config.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { copyFile, mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import { updateConfig } from "c12/update";
+//#region src/adapters/config.ts
+const PROJECT_FIELD_PATTERN = /project\s*:\s*["']([^"']+)["']/;
+async function readLinkedProjectId(cwd) {
+	const configPath = path.join(cwd, "prisma.config.ts");
+	try {
+		return (await readFile(configPath, "utf8")).match(PROJECT_FIELD_PATTERN)?.[1] ?? null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+var UnsafeConfigWriteError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsafeConfigWriteError";
+	}
+};
+async function assertLinkedProjectIdWritable(cwd) {
+	const tempDir = await mkdtemp(path.join(os.tmpdir(), "prisma-cli-config-"));
+	const sourceConfigPath = path.join(cwd, "prisma.config.ts");
+	const tempConfigPath = path.join(tempDir, "prisma.config.ts");
+	try {
+		try {
+			await copyFile(sourceConfigPath, tempConfigPath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await applyLinkedProjectIdUpdate(tempDir, "proj_preflight");
+	} catch (error) {
+		throw toUnsafeConfigWriteError(error);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function writeLinkedProjectId(cwd, projectId) {
+	try {
+		await applyLinkedProjectIdUpdate(cwd, projectId);
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			await mkdir(cwd, { recursive: true });
+			await applyLinkedProjectIdUpdate(cwd, projectId);
+			return;
+		}
+		throw toUnsafeConfigWriteError(error);
+	}
+}
+async function applyLinkedProjectIdUpdate(cwd, projectId) {
+	await updateConfig({
+		cwd,
+		configFile: "prisma.config",
+		onUpdate(config) {
+			config.project = projectId;
+		},
+		onCreate() {
+			return renderProjectConfig(projectId);
+		}
+	});
+}
+function renderProjectConfig(projectId) {
+	return `export default {\n  project: "${projectId}",\n};\n`;
+}
+function toUnsafeConfigWriteError(error) {
+	if (error instanceof UnsafeConfigWriteError) return error;
+	return new UnsafeConfigWriteError("The existing prisma.config.ts file could not be updated safely.");
+}
+//#endregion
+export { UnsafeConfigWriteError, assertLinkedProjectIdWritable, readLinkedProjectId, writeLinkedProjectId };

package/dist/adapters/local-state.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/adapters/local-state.ts
+const DEFAULT_STATE = {
+	auth: null,
+	environment: { active: "local" },
+	app: {
+		selectedByProject: {},
+		knownLiveDeploymentByProject: {}
+	}
+};
+const DEFAULT_STATE_FILE_NAME = "state.json";
+function resolveLocalStateFilePath(stateDir) {
+	return path.join(stateDir, DEFAULT_STATE_FILE_NAME);
+}
+var LocalStateStore = class {
+	stateFilePath;
+	constructor(stateDir) {
+		this.stateFilePath = resolveLocalStateFilePath(stateDir);
+	}
+	async read() {
+		try {
+			const raw = await readFile(this.stateFilePath, "utf8");
+			const parsed = JSON.parse(raw);
+			return {
+				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
+				environment: { active: parsed.environment?.active ?? DEFAULT_STATE.environment.active },
+				app: {
+					selectedByProject: parsed.app?.selectedByProject ?? {},
+					knownLiveDeploymentByProject: parsed.app?.knownLiveDeploymentByProject ?? {}
+				}
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return structuredClone(DEFAULT_STATE);
+			throw error;
+		}
+	}
+	async write(state) {
+		await mkdir(path.dirname(this.stateFilePath), { recursive: true });
+		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	}
+	async setAuthSession(session) {
+		const state = await this.read();
+		state.auth = session;
+		await this.write(state);
+		return state;
+	}
+	async clearAuthSession() {
+		const state = await this.read();
+		state.auth = null;
+		await this.write(state);
+		return state;
+	}
+	async setActiveEnvironment(active) {
+		const state = await this.read();
+		state.environment.active = active;
+		await this.write(state);
+		return state;
+	}
+	async readSelectedApp(projectId) {
+		return (await this.read()).app.selectedByProject[projectId] ?? null;
+	}
+	async setSelectedApp(projectId, app) {
+		const state = await this.read();
+		state.app.selectedByProject[projectId] = app;
+		await this.write(state);
+		return state;
+	}
+	async clearSelectedApp(projectId, appId) {
+		const state = await this.read();
+		const selectedApp = state.app.selectedByProject[projectId];
+		if (!selectedApp || selectedApp.id !== appId) return state;
+		delete state.app.selectedByProject[projectId];
+		await this.write(state);
+		return state;
+	}
+	async readKnownLiveDeployment(projectId, appId) {
+		return (await this.read()).app.knownLiveDeploymentByProject[projectId]?.[appId] ?? null;
+	}
+	async setKnownLiveDeployment(projectId, appId, deploymentId) {
+		const state = await this.read();
+		state.app.knownLiveDeploymentByProject[projectId] ??= {};
+		state.app.knownLiveDeploymentByProject[projectId][appId] = deploymentId;
+		await this.write(state);
+		return state;
+	}
+	async clearKnownLiveDeployment(projectId, appId) {
+		const state = await this.read();
+		const projectDeployments = state.app.knownLiveDeploymentByProject[projectId];
+		if (!projectDeployments || !(appId in projectDeployments)) return state;
+		delete projectDeployments[appId];
+		if (Object.keys(projectDeployments).length === 0) delete state.app.knownLiveDeploymentByProject[projectId];
+		await this.write(state);
+		return state;
+	}
+};
+//#endregion
+export { LocalStateStore };

package/dist/adapters/mock-api.js

@@ -0,0 +1,57 @@
+import { readFile } from "node:fs/promises";
+//#region src/adapters/mock-api.ts
+var MockApi = class MockApi {
+	data;
+	constructor(data) {
+		this.data = data;
+	}
+	static async load(fixturePath) {
+		const raw = await readFile(fixturePath, "utf8");
+		return new MockApi(JSON.parse(raw));
+	}
+	listProviders() {
+		return this.data.providers;
+	}
+	getProvider(providerId) {
+		return this.data.providers.find((provider) => provider.id === providerId);
+	}
+	listUsersForProvider(providerId) {
+		return this.data.users.filter((user) => user.providerIds.includes(providerId));
+	}
+	getUser(userId) {
+		return this.data.users.find((user) => user.id === userId);
+	}
+	getUserForProvider(providerId, userId) {
+		return this.listUsersForProvider(providerId).find((user) => user.id === userId);
+	}
+	listUserWorkspaces(userId) {
+		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
+		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
+	}
+	getWorkspace(workspaceId) {
+		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
+	}
+	getUserWorkspace(userId, workspaceId) {
+		return this.listUserWorkspaces(userId).find((workspace) => workspace.id === workspaceId);
+	}
+	listProjectsForWorkspace(workspaceId) {
+		return this.data.projects.filter((project) => project.workspaceId === workspaceId);
+	}
+	getProject(projectId) {
+		return this.data.projects.find((project) => project.id === projectId);
+	}
+	getProjectForWorkspace(workspaceId, projectId) {
+		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
+	}
+	listEnvironmentsForProject(projectId) {
+		return this.data.environments.filter((environment) => environment.projectId === projectId);
+	}
+	getEnvironmentForProject(projectId, name) {
+		return this.listEnvironmentsForProject(projectId).find((environment) => environment.name === name);
+	}
+	getDeployment(deploymentId) {
+		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
+	}
+};
+//#endregion
+export { MockApi };

package/dist/adapters/token-storage.js

@@ -0,0 +1,43 @@
+import { getAuthFilePath } from "../lib/auth/client.js";
+import { CredentialsStore } from "@prisma/credentials-store";
+//#region src/adapters/token-storage.ts
+function findLatestValidTokens(allCredentials) {
+	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
+		const credential = allCredentials[i];
+		if (!credential) continue;
+		if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) continue;
+		return {
+			workspaceId: credential.workspaceId,
+			accessToken: credential.token,
+			refreshToken: credential.refreshToken
+		};
+	}
+	return null;
+}
+var FileTokenStorage = class {
+	credentialsStore;
+	constructor(env = process.env) {
+		this.credentialsStore = new CredentialsStore(getAuthFilePath(env));
+	}
+	async getTokens() {
+		try {
+			return findLatestValidTokens(await this.credentialsStore.getCredentials());
+		} catch {
+			return null;
+		}
+	}
+	async setTokens(tokens) {
+		await this.credentialsStore.storeCredentials({
+			workspaceId: tokens.workspaceId,
+			token: tokens.accessToken,
+			refreshToken: tokens.refreshToken
+		});
+	}
+	async clearTokens() {
+		const tokens = findLatestValidTokens(await this.credentialsStore.getCredentials());
+		if (!tokens) return;
+		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+	}
+};
+//#endregion
+export { FileTokenStorage };

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCli } from "./cli2.js";
+import process from "node:process";
+//#region src/bin.ts
+runCli().then((exitCode) => {
+	process.exitCode = exitCode;
+});
+//#endregion
+export {};

package/dist/cli2.js

@@ -0,0 +1,59 @@
+import { attachCommandDescriptor } from "./shell/command-meta.js";
+import { configureRuntimeCommand } from "./shell/runtime.js";
+import "./shell/prompt.js";
+import { createAppCommand } from "./commands/app/index.js";
+import { createAuthCommand } from "./commands/auth/index.js";
+import { createEnvCommand } from "./commands/env/index.js";
+import { createProjectCommand } from "./commands/project/index.js";
+import process from "node:process";
+import { Command, CommanderError } from "commander";
+//#region src/cli.ts
+async function runCli(options = {}) {
+	const runtime = resolveRuntime(options);
+	const program = createProgram(runtime);
+	process.exitCode = 0;
+	try {
+		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
+		if (bareHelpCommand) {
+			runtime.stderr.write(bareHelpCommand.helpInformation());
+			return 0;
+		}
+		await program.parseAsync(runtime.argv, { from: "user" });
+		return process.exitCode ?? 0;
+	} catch (error) {
+		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
+		const message = error instanceof Error ? error.stack ?? error.message : String(error);
+		runtime.stderr.write(`${message}\n`);
+		return 1;
+	} finally {
+		runtime.stdin;
+	}
+}
+function createProgram(runtime) {
+	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
+	program.name("prisma").showSuggestionAfterError();
+	program.addCommand(createAuthCommand(runtime));
+	program.addCommand(createEnvCommand(runtime));
+	program.addCommand(createProjectCommand(runtime));
+	program.addCommand(createAppCommand(runtime));
+	return program;
+}
+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;
+}
+function resolveRuntime(options) {
+	return {
+		argv: options.argv ?? process.argv.slice(2),
+		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
+		env: options.env ?? process.env,
+		stdin: options.stdin ?? process.stdin,
+		stdout: options.stdout ?? process.stdout,
+		stderr: options.stderr ?? process.stderr,
+		fixturePath: options.fixturePath,
+		stateDir: options.stateDir
+	};
+}
+//#endregion
+export { runCli };

package/dist/commands/app/index.js

@@ -0,0 +1,178 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runAppBuild, runAppDeploy, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy } from "../../controllers/app.js";
+import { renderAppBuild, renderAppDeploy, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy } from "../../presenters/app.js";
+import { runCommand } 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");
+	app.addCommand(createBuildCommand(runtime));
+	app.addCommand(createRunCommand(runtime));
+	app.addCommand(createDeployCommand(runtime));
+	app.addCommand(createShowCommand(runtime));
+	app.addCommand(createOpenCommand(runtime));
+	app.addCommand(createLogsCommand(runtime));
+	app.addCommand(createListDeploysCommand(runtime));
+	app.addCommand(createShowDeployCommand(runtime));
+	app.addCommand(createPromoteCommand(runtime));
+	app.addCommand(createRollbackCommand(runtime));
+	app.addCommand(createRemoveCommand(runtime));
+	return app;
+}
+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"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const entry = options.entry;
+		const buildType = options.buildType;
+		await runCommand(runtime, "app.build", options, (context) => runAppBuild(context, entry, buildType), {
+			renderHuman: (context, descriptor, result) => renderAppBuild(context, descriptor, result),
+			renderJson: (result) => serializeAppBuild(result)
+		});
+	});
+	return command;
+}
+function createRunCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("run"), runtime), "app.run");
+	command.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto runs")).addOption(new Option("--build-type <type>", "Local framework type").choices([
+		"auto",
+		"bun",
+		"nextjs"
+	]).default("auto")).addOption(new Option("--port <port>", "Local port"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const entry = options.entry;
+		const buildType = options.buildType;
+		const port = options.port;
+		await runCommand(runtime, "app.run", options, (context) => runAppRun(context, entry, buildType, port), {
+			renderHuman: (context, descriptor, result) => renderAppRun(context, descriptor, result),
+			renderJson: (result) => serializeAppRun(result)
+		});
+	});
+	return command;
+}
+function createDeployCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
+			renderJson: (result) => serializeAppDeploy(result)
+		});
+	});
+	return command;
+}
+function createShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
+			renderJson: (result) => serializeAppShow(result)
+		});
+	});
+	return command;
+}
+function createOpenCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
+			renderJson: (result) => serializeAppOpen(result)
+		});
+	});
+	return command;
+}
+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"));
+	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: () => [] });
+	});
+	return command;
+}
+function createListDeploysCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-deploys"), runtime), "app.list-deploys");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppListDeploys(context, descriptor, result),
+			renderJson: (result) => serializeAppListDeploys(result)
+		});
+	});
+	return command;
+}
+function createShowDeployCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show-deploy"), runtime), "app.show-deploy");
+	command.argument("<deployment>", "Deployment id");
+	addGlobalFlags(command);
+	command.action(async (deploymentId, options) => {
+		await runCommand(runtime, "app.show-deploy", options, (context) => runAppShowDeploy(context, deploymentId), {
+			renderHuman: (context, descriptor, result) => renderAppShowDeploy(context, descriptor, result),
+			renderJson: (result) => serializeAppShowDeploy(result)
+		});
+	});
+	return command;
+}
+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"));
+	addGlobalFlags(command);
+	command.action(async (deploymentId, options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName), {
+			renderHuman: (context, descriptor, result) => renderAppPromote(context, descriptor, result),
+			renderJson: (result) => serializeAppPromote(result)
+		});
+	});
+	return command;
+}
+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"));
+	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), {
+			renderHuman: (context, descriptor, result) => renderAppRollback(context, descriptor, result),
+			renderJson: (result) => serializeAppRollback(result)
+		});
+	});
+	return command;
+}
+function createRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.remove");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppRemove(context, descriptor, result),
+			renderJson: (result) => serializeAppRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createAppCommand };

package/dist/commands/auth/index.js

@@ -0,0 +1,42 @@
+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 { runAuthLogin, runAuthLogout, runAuthWhoAmI } from "../../controllers/auth.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");
+	auth.addCommand(createAuthLoginCommand(runtime));
+	auth.addCommand(createAuthLogoutCommand(runtime));
+	auth.addCommand(createAuthWhoAmICommand(runtime));
+	return auth;
+}
+function createAuthLoginCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("login"), runtime), "auth.login");
+	command.addOption(new Option("--provider <provider>").hideHelp()).addOption(new Option("--user <id>").hideHelp()).addOption(new Option("--workspace <id>").hideHelp());
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "auth.login", options, (context) => runAuthLogin(context, options), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.login", result) });
+	});
+	return command;
+}
+function createAuthLogoutCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logout"), runtime), "auth.logout");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "auth.logout", options, (context) => runAuthLogout(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.logout", result) });
+	});
+	return command;
+}
+function createAuthWhoAmICommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("whoami"), runtime), "auth.whoami");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "auth.whoami", options, (context) => runAuthWhoAmI(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.whoami", result) });
+	});
+	return command;
+}
+//#endregion
+export { createAuthCommand };

package/dist/commands/env/index.js

@@ -0,0 +1,51 @@
+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 { runEnvList, runEnvShow, runEnvUse } from "../../controllers/env.js";
+import { renderEnvList, renderEnvShow, renderEnvUse, serializeEnvList, serializeEnvShow } from "../../presenters/env.js";
+import { Command } from "commander";
+//#region src/commands/env/index.ts
+function createEnvCommand(runtime) {
+	const env = attachCommandDescriptor(configureRuntimeCommand(new Command("env"), runtime), "env");
+	env.addCommand(createEnvListCommand(runtime));
+	env.addCommand(createEnvShowCommand(runtime));
+	env.addCommand(createEnvUseCommand(runtime));
+	return env;
+}
+function createEnvListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "env.list");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "env.list", options, (context) => runEnvList(context), {
+			renderHuman: (context, descriptor, result) => renderEnvList(context, descriptor, result),
+			renderJson: (result) => serializeEnvList(result)
+		});
+	});
+	return command;
+}
+function createEnvShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "env.show");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "env.show", options, (context) => runEnvShow(context), {
+			renderHuman: (context, descriptor, result) => renderEnvShow(context, descriptor, result),
+			renderJson: (result) => serializeEnvShow(result)
+		});
+	});
+	return command;
+}
+function createEnvUseCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "env.use");
+	command.argument("[name]", "Environment name");
+	addGlobalFlags(command);
+	command.action(async (environmentName, options) => {
+		await runCommand(runtime, "env.use", options, (context) => runEnvUse(context, environmentName), {
+			renderHuman: (context, descriptor, result) => renderEnvUse(context, descriptor, result),
+			renderJson: (result) => serializeEnvShow(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createEnvCommand };