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

package/dist/adapters/token-storage.js

@@ -1,9 +1,22 @@
 import { getAuthFilePath } from "../lib/auth/client.js";
-import fs from "node:fs/promises";
 import path from "node:path";
-import { CredentialsStore } from "@prisma/credentials-store";
+import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
+import { CredentialsStore } from "@prisma/credentials-store";
 //#region src/adapters/token-storage.ts
+const REFRESH_LOCK_RETRY_MS = 100;
+const REFRESH_LOCK_STALE_MS = 3e4;
+const REFRESH_LOCK_WAIT_TIMEOUT_MS = 25e3;
+const EMPTY_AUTH_CONTEXT = {
+	activeWorkspaceId: null,
+	workspaces: {}
+};
+const UNKNOWN_WORKSPACE_NAME = "Unknown workspace";
+function getAuthContextFilePath(authFilePath) {
+	const extension = path.extname(authFilePath);
+	if (!extension) return `${authFilePath}.context.json`;
+	return `${authFilePath.slice(0, -extension.length)}.context${extension}`;
+}
 function findLatestValidTokens(allCredentials) {
 	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
 		const credential = allCredentials[i];
@@ -17,6 +30,18 @@ function findLatestValidTokens(allCredentials) {
 	}
 	return null;
 }
+function storedCredentialToTokens(credential) {
+	if (!credential) return null;
+	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) return null;
+	return {
+		workspaceId: credential.workspaceId,
+		accessToken: credential.token,
+		refreshToken: credential.refreshToken
+	};
+}
+function findTokensForWorkspace(allCredentials, workspaceId) {
+	return storedCredentialToTokens(allCredentials.find((credential) => credential?.workspaceId === workspaceId)) ?? null;
+}
 function tokensEqual(a, b) {
 	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
 }
@@ -36,25 +61,45 @@ function sleep(ms, signal) {
 }
 var FileTokenStorage = class {
 	credentialsStore;
+	authFilePath;
+	contextFilePath;
 	lockFilePath;
-	constructor(env = process.env, signal) {
+	constructor(env = process.env, signal, options = {}) {
 		this.signal = signal;
+		this.options = options;
 		const authFilePath = getAuthFilePath(env);
+		this.authFilePath = authFilePath;
+		this.contextFilePath = getAuthContextFilePath(authFilePath);
 		this.credentialsStore = new CredentialsStore(authFilePath);
 		this.lockFilePath = `${authFilePath}.lock`;
 	}
 	async getTokens() {
 		this.signal?.throwIfAborted();
 		try {
-			const all = await this.credentialsStore.getCredentials();
-			this.signal?.throwIfAborted();
-			return findLatestValidTokens(all);
-		} catch (error) {
+			const credentials = await this.readCredentialsFromDisk();
+			if (this.options.pinnedWorkspaceId) return findTokensForWorkspace(credentials, this.options.pinnedWorkspaceId);
+			const context = await this.readAuthContext();
+			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
+			const latest = findLatestValidTokens(credentials);
+			if (!latest) return null;
+			if (!context.exists) {
+				await this.setActiveWorkspaceId(latest.workspaceId);
+				return latest;
+			}
+			return null;
+		} catch (_error) {
 			if (this.signal?.aborted) throw this.signal.reason;
 			return null;
 		}
 	}
 	async setTokens(tokens) {
+		if (this.options.lockSetTokens === false) {
+			await this.setTokensUnlocked(tokens);
+			return;
+		}
+		await this.withRefreshLock(() => this.setTokensUnlocked(tokens));
+	}
+	async setTokensUnlocked(tokens) {
 		this.signal?.throwIfAborted();
 		await this.credentialsStore.storeCredentials({
 			workspaceId: tokens.workspaceId,
@@ -62,20 +107,140 @@ var FileTokenStorage = class {
 			refreshToken: tokens.refreshToken
 		});
 		this.signal?.throwIfAborted();
+		await this.rememberWorkspaceUnlocked(tokens.workspaceId, {
+			id: tokens.workspaceId,
+			name: tokens.workspaceId
+		});
+		await this.maybeActivateWorkspaceId(tokens.workspaceId);
 	}
 	async clearTokens() {
+		await this.withRefreshLock(() => this.clearTokensUnlocked());
+	}
+	async clearTokensUnlocked() {
 		this.signal?.throwIfAborted();
-		const all = await this.credentialsStore.getCredentials();
+		await fs.mkdir(path.dirname(this.authFilePath), { recursive: true });
 		this.signal?.throwIfAborted();
-		const tokens = findLatestValidTokens(all);
-		if (!tokens) return;
-		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+		await fs.writeFile(this.authFilePath, `${JSON.stringify({ tokens: [] }, null, 2)}\n`, {
+			encoding: "utf8",
+			signal: this.signal
+		});
+		await this.clearAuthContext();
+		await this.credentialsStore.reloadCredentialsFromDisk();
 		this.signal?.throwIfAborted();
 	}
 	async clearTokensIfCurrent(tokens) {
 		this.signal?.throwIfAborted();
 		if (!tokensEqual(await this.getTokens(), tokens)) return;
-		await this.clearTokens();
+		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+		await this.removeRememberedWorkspace(tokens.workspaceId, { preserveActivePointer: true });
+		this.signal?.throwIfAborted();
+	}
+	async listWorkspaces() {
+		this.signal?.throwIfAborted();
+		const credentials = await this.readCredentialsFromDisk();
+		const context = await this.ensureMigratedAuthContext(credentials);
+		return this.workspacesFromState(credentials, context);
+	}
+	workspacesFromState(credentials, context) {
+		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
+			const cached = context.state.workspaces[tokens.workspaceId];
+			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
+			const name = typeof cached?.name === "string" && cached.name.trim().length > 0 ? workspaceDisplayName(cached.name.trim(), tokens.workspaceId) : UNKNOWN_WORKSPACE_NAME;
+			const lastSeenAt = typeof cached?.lastSeenAt === "string" && cached.lastSeenAt.trim().length > 0 ? cached.lastSeenAt.trim() : null;
+			return {
+				id,
+				name,
+				credentialWorkspaceId: tokens.workspaceId,
+				active: context.state.activeWorkspaceId === tokens.workspaceId,
+				lastSeenAt
+			};
+		});
+	}
+	async listWorkspaceTokens() {
+		this.signal?.throwIfAborted();
+		return (await this.readCredentialsFromDisk()).map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null);
+	}
+	async useWorkspace(workspaceRef) {
+		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
+	}
+	/**
+	* Resolve a workspace ref (id, credential workspace id, or cached name)
+	* against the locally stored sessions without changing the active
+	* workspace. Read-only counterpart of useWorkspace: it reads the auth
+	* context as-is and never runs the legacy-state migration, so it writes
+	* nothing.
+	*/
+	async resolveWorkspace(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		this.signal?.throwIfAborted();
+		const credentials = await this.readCredentialsFromDisk();
+		const context = await this.readAuthContext();
+		const matches = this.workspacesFromState(credentials, context).filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		return matches[0];
+	}
+	async useWorkspaceUnlocked(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		const workspaces = await this.listWorkspaces();
+		const context = await this.readAuthContext();
+		const previous = workspaces.find((workspace) => workspace.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null;
+		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		const selected = matches[0];
+		await this.setActiveWorkspaceId(selected.credentialWorkspaceId);
+		return {
+			previous,
+			selected
+		};
+	}
+	async logoutWorkspace(workspaceRef) {
+		return this.withRefreshLock(() => this.logoutWorkspaceUnlocked(workspaceRef));
+	}
+	async logoutWorkspaceUnlocked(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		const workspaces = await this.listWorkspaces();
+		const context = await this.readAuthContext();
+		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		const workspace = matches[0];
+		const wasActive = context.state.activeWorkspaceId === workspace.credentialWorkspaceId;
+		await this.credentialsStore.deleteCredentials(workspace.credentialWorkspaceId);
+		this.signal?.throwIfAborted();
+		const remainingWorkspaces = workspaces.filter((candidate) => candidate.credentialWorkspaceId !== workspace.credentialWorkspaceId);
+		if (remainingWorkspaces.length === 0) {
+			await this.clearAuthContext();
+			return {
+				workspace,
+				wasActive,
+				activeWorkspace: null
+			};
+		}
+		delete context.state.workspaces[workspace.credentialWorkspaceId];
+		if (wasActive) context.state.activeWorkspaceId = null;
+		await this.writeAuthContext(context.state);
+		return {
+			workspace,
+			wasActive,
+			activeWorkspace: context.state.activeWorkspaceId === null ? null : remainingWorkspaces.find((candidate) => candidate.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null
+		};
+	}
+	async rememberWorkspace(credentialWorkspaceId, workspace) {
+		await this.withRefreshLock(() => this.rememberWorkspaceUnlocked(credentialWorkspaceId, workspace));
+	}
+	async rememberWorkspaceUnlocked(credentialWorkspaceId, workspace) {
+		const context = await this.readAuthContext();
+		context.state.workspaces[credentialWorkspaceId] = {
+			id: workspace.id,
+			name: workspace.name,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.writeAuthContext(context.state);
 	}
 	async withRefreshLock(fn) {
 		const lockId = await this.acquireRefreshLock();
@@ -87,34 +252,48 @@ var FileTokenStorage = class {
 	}
 	async acquireRefreshLock() {
 		const lockId = randomUUID();
+		const startedAt = Date.now();
+		const retryMs = this.options.lockRetryMs ?? REFRESH_LOCK_RETRY_MS;
+		const waitTimeoutMs = this.options.lockWaitTimeoutMs ?? REFRESH_LOCK_WAIT_TIMEOUT_MS;
 		this.signal?.throwIfAborted();
 		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
 		while (true) {
 			this.signal?.throwIfAborted();
-			let lockFileCreated = false;
+			if (await this.tryCreateRefreshLock(lockId)) return lockId;
+			if (await this.releaseStaleRefreshLock()) continue;
+			this.throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs);
+			await sleep(retryMs, this.signal);
+		}
+	}
+	async tryCreateRefreshLock(lockId) {
+		let lockFileCreated = false;
+		try {
+			const handle = await fs.open(this.lockFilePath, "wx");
+			lockFileCreated = true;
 			try {
-				const handle = await fs.open(this.lockFilePath, "wx");
-				lockFileCreated = true;
-				try {
-					this.signal?.throwIfAborted();
-					await handle.writeFile(lockId, { encoding: "utf8" });
-					this.signal?.throwIfAborted();
-				} finally {
-					await handle.close();
-				}
-				return lockId;
-			} catch (error) {
-				if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
-				if (error.code !== "EEXIST") throw error;
-				const staleLockId = await this.getStaleRefreshLockId();
-				if (staleLockId) {
-					await this.releaseRefreshLock(staleLockId);
-					continue;
-				}
-				await sleep(100, this.signal);
+				this.signal?.throwIfAborted();
+				await handle.writeFile(lockId, { encoding: "utf8" });
+				this.signal?.throwIfAborted();
+			} finally {
+				await handle.close();
 			}
+			return true;
+		} catch (error) {
+			if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
+			if (error.code === "EEXIST") return false;
+			throw error;
 		}
 	}
+	async releaseStaleRefreshLock() {
+		const staleLockId = await this.getStaleRefreshLockId();
+		if (!staleLockId) return false;
+		await this.releaseRefreshLock(staleLockId);
+		return true;
+	}
+	throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs) {
+		if (Date.now() - startedAt < waitTimeoutMs) return;
+		throw new RefreshLockTimeoutError(this.lockFilePath, waitTimeoutMs);
+	}
 	async getStaleRefreshLockId() {
 		this.signal?.throwIfAborted();
 		const lockId = await fs.readFile(this.lockFilePath, {
@@ -129,12 +308,134 @@ var FileTokenStorage = class {
 		const stats = await fs.stat(this.lockFilePath).catch(() => null);
 		this.signal?.throwIfAborted();
 		if (!stats) return null;
-		return Date.now() - stats.mtimeMs > 3e4 ? lockId : null;
+		const staleMs = this.options.lockStaleMs ?? REFRESH_LOCK_STALE_MS;
+		return Date.now() - stats.mtimeMs > staleMs ? lockId : null;
 	}
 	async releaseRefreshLock(lockId) {
 		if (await fs.readFile(this.lockFilePath, { encoding: "utf8" }).catch(() => null) !== lockId) return;
 		await fs.unlink(this.lockFilePath).catch(() => {});
 	}
+	async readCredentialsFromDisk() {
+		this.signal?.throwIfAborted();
+		await this.credentialsStore.reloadCredentialsFromDisk();
+		this.signal?.throwIfAborted();
+		return await this.credentialsStore.getCredentials();
+	}
+	async ensureMigratedAuthContext(credentials) {
+		const context = await this.readAuthContext();
+		if (context.state.activeWorkspaceId || context.exists) return context;
+		const latest = findLatestValidTokens(credentials);
+		if (!latest) return context;
+		context.state.activeWorkspaceId = latest.workspaceId;
+		context.state.workspaces[latest.workspaceId] ??= {
+			id: latest.workspaceId,
+			name: latest.workspaceId,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.writeAuthContext(context.state);
+		return {
+			exists: true,
+			state: context.state
+		};
+	}
+	async setActiveWorkspaceId(workspaceId) {
+		const context = await this.readAuthContext();
+		context.state.activeWorkspaceId = workspaceId;
+		context.state.workspaces[workspaceId] ??= {
+			id: workspaceId,
+			name: workspaceId,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.writeAuthContext(context.state);
+	}
+	async maybeActivateWorkspaceId(workspaceId) {
+		if (this.options.pinnedWorkspaceId) return;
+		const context = await this.readAuthContext();
+		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
+		context.state.activeWorkspaceId = workspaceId;
+		context.state.workspaces[workspaceId] ??= {
+			id: workspaceId,
+			name: workspaceId,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.writeAuthContext(context.state);
+	}
+	async removeRememberedWorkspace(workspaceId, options) {
+		const context = await this.readAuthContext();
+		delete context.state.workspaces[workspaceId];
+		if (!options.preserveActivePointer && context.state.activeWorkspaceId === workspaceId) context.state.activeWorkspaceId = null;
+		await this.writeAuthContext(context.state);
+	}
+	async readAuthContext() {
+		this.signal?.throwIfAborted();
+		const raw = await fs.readFile(this.contextFilePath, {
+			encoding: "utf8",
+			signal: this.signal
+		}).catch((error) => {
+			if (this.signal?.aborted) throw error;
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (raw === null) return {
+			exists: false,
+			state: structuredClone(EMPTY_AUTH_CONTEXT)
+		};
+		try {
+			const parsed = JSON.parse(raw);
+			return {
+				exists: true,
+				state: {
+					activeWorkspaceId: typeof parsed.activeWorkspaceId === "string" && parsed.activeWorkspaceId.trim().length > 0 ? parsed.activeWorkspaceId.trim() : null,
+					workspaces: parsed.workspaces && typeof parsed.workspaces === "object" && !Array.isArray(parsed.workspaces) ? parsed.workspaces : {}
+				}
+			};
+		} catch {
+			return {
+				exists: false,
+				state: structuredClone(EMPTY_AUTH_CONTEXT)
+			};
+		}
+	}
+	async writeAuthContext(state) {
+		this.signal?.throwIfAborted();
+		await fs.mkdir(path.dirname(this.contextFilePath), { recursive: true });
+		this.signal?.throwIfAborted();
+		await fs.writeFile(this.contextFilePath, `${JSON.stringify(state, null, 2)}\n`, {
+			encoding: "utf8",
+			signal: this.signal
+		});
+		this.signal?.throwIfAborted();
+	}
+	async clearAuthContext() {
+		await fs.unlink(this.contextFilePath).catch((error) => {
+			if (error.code === "ENOENT") return;
+			throw error;
+		});
+	}
+};
+var WorkspaceSelectionError = class extends Error {
+	constructor(reason, workspaceRef, matches = []) {
+		super(reason);
+		this.reason = reason;
+		this.workspaceRef = workspaceRef;
+		this.matches = matches;
+		this.name = "WorkspaceSelectionError";
+	}
 };
+var RefreshLockTimeoutError = class extends Error {
+	constructor(lockFilePath, waitTimeoutMs) {
+		super(`Timed out waiting ${waitTimeoutMs}ms for auth refresh lock at ${lockFilePath}`);
+		this.name = "RefreshLockTimeoutError";
+	}
+};
+function workspaceMatchesRef(workspace, ref) {
+	return workspace.credentialWorkspaceId === ref || workspace.id === ref || stripWorkspacePrefix(workspace.credentialWorkspaceId) === stripWorkspacePrefix(ref) || stripWorkspacePrefix(workspace.id) === stripWorkspacePrefix(ref) || workspace.name.toLowerCase() === ref.toLowerCase();
+}
+function stripWorkspacePrefix(value) {
+	return value.startsWith("wksp_") ? value.slice(5) : value;
+}
+function workspaceDisplayName(name, credentialWorkspaceId) {
+	return name === credentialWorkspaceId ? UNKNOWN_WORKSPACE_NAME : name;
+}
 //#endregion
-export { FileTokenStorage };
+export { FileTokenStorage, WorkspaceSelectionError };

package/dist/cli.js

@@ -3,22 +3,22 @@ import { runUpdateDiscoveryWorker } from "./shell/update-check.js";
 import { runCli } from "./cli2.js";
 import process from "node:process";
 //#region src/bin.ts
-if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") runUpdateDiscoveryWorker().then(() => {
+if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") {
+	await runUpdateDiscoveryWorker();
 	process.exitCode = 0;
-});
-else {
+} else {
 	const controller = new AbortController();
 	const abortCli = () => {
 		if (!controller.signal.aborted) controller.abort(new DOMException("Command canceled", "AbortError"));
 	};
 	process.once("SIGINT", abortCli);
 	process.once("SIGTERM", abortCli);
-	runCli({ signal: controller.signal }).then((exitCode) => {
-		process.exitCode = exitCode;
-	}).finally(() => {
+	try {
+		process.exitCode = await runCli({ signal: controller.signal });
+	} finally {
 		process.off("SIGINT", abortCli);
 		process.off("SIGTERM", abortCli);
-	});
+	}
 }
 //#endregion
 export {};

package/dist/cli2.js

@@ -1,16 +1,22 @@
 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 { createShellUi } from "./shell/ui.js";
 import { addCompactGlobalFlags } from "./shell/global-flags.js";
 import { configureRuntimeCommand, createCommandContext } from "./shell/runtime.js";
+import { formatUnexpectedError, unexpectedErrorFeedbackCommand, writeHumanError, writeJsonError, writeJsonSuccess, writeJsonUnexpectedError } from "./shell/output.js";
+import { createAgentCommand } from "./commands/agent/index.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 { createBucketCommand } from "./commands/bucket/index.js";
+import { createBuildCommand } from "./commands/build/index.js";
+import { createDatabaseCommand } from "./commands/database/index.js";
+import { getCliName, getCliVersion } from "./lib/version.js";
+import { createFeedbackCommand } from "./commands/feedback/index.js";
 import { createGitCommand } from "./commands/git/index.js";
+import { createInitCommand } from "./commands/init/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 { maybeWriteCachedUpdateNotification } from "./shell/update-check.js";
@@ -33,8 +39,15 @@ async function runCli(options = {}) {
 		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`);
+		if (runtime.argv.includes("--json")) {
+			writeJsonUnexpectedError({
+				stdout: runtime.stdout,
+				stderr: runtime.stderr
+			}, runtime.argv, error);
+			return 1;
+		}
+		const quiet = runtime.argv.includes("--quiet") || runtime.argv.includes("-q");
+		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace"), quiet ? void 0 : unexpectedErrorFeedbackCommand(runtime.argv, error)));
 		return 1;
 	} finally {
 		runtime.stdin;
@@ -46,10 +59,16 @@ function createProgram(runtime) {
 	program.addOption(new Option("--version", "Print the CLI version and exit."));
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createVersionCommand(runtime));
+	program.addCommand(createInitCommand(runtime));
+	program.addCommand(createFeedbackCommand(runtime));
+	program.addCommand(createAgentCommand(runtime));
 	program.addCommand(createAuthCommand(runtime));
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createBuildCommand(runtime));
+	program.addCommand(createDatabaseCommand(runtime));
+	program.addCommand(createBucketCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }

package/dist/commands/agent/index.js

@@ -0,0 +1,60 @@
+import { runAgentInstall, runAgentStatus } from "../../controllers/agent.js";
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { renderAgentInstall, renderAgentStatus, serializeAgentInstall, serializeAgentStatus } from "../../presenters/agent.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { Command, Option } from "commander";
+//#region src/commands/agent/index.ts
+function createAgentCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("agent"), runtime), "agent");
+	addCompactGlobalFlags(command);
+	command.addCommand(createAgentInstallCommand(runtime));
+	command.addCommand(createAgentUpdateCommand(runtime));
+	command.addCommand(createAgentStatusCommand(runtime));
+	return command;
+}
+function createAgentInstallCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("install"), runtime), "agent.install");
+	addAgentInstallOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "agent.install", options, (context) => runAgentInstall(context, options, "install"), {
+			renderHuman: (context, descriptor, result) => renderAgentInstall(context, descriptor, result),
+			renderJson: (result) => serializeAgentInstall(result)
+		});
+	});
+	return command;
+}
+function createAgentUpdateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "agent.update");
+	addAgentInstallOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "agent.update", options, (context) => runAgentInstall(context, options, "update"), {
+			renderHuman: (context, descriptor, result) => renderAgentInstall(context, descriptor, result),
+			renderJson: (result) => serializeAgentInstall(result)
+		});
+	});
+	return command;
+}
+function createAgentStatusCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("status"), runtime), "agent.status");
+	command.addOption(new Option("--global", "Check globally installed Prisma skills instead of project skills"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "agent.status", options, (context) => runAgentStatus(context, options), {
+			renderHuman: (context, descriptor, result) => renderAgentStatus(context, descriptor, result),
+			renderJson: (result) => serializeAgentStatus(result)
+		});
+	});
+	return command;
+}
+function addAgentInstallOptions(command) {
+	command.addOption(new Option("--agent <agent>", "Agent target for Prisma skills; repeat for multiple agents").argParser(collectValues)).addOption(new Option("--all-agents", "Install Prisma skills for every agent supported by the skills CLI")).addOption(new Option("--skill <skill>", "Prisma skill to install; repeat for multiple skills").argParser(collectValues)).addOption(new Option("--global", "Install skills into the user directory instead of the project")).addOption(new Option("--copy", "Ask the skills CLI to copy files instead of symlinking them")).addOption(new Option("--dry-run", "Show changes without writing files"));
+}
+function collectValues(value, previous) {
+	return [...previous ?? [], value];
+}
+//#endregion
+export { createAgentCommand };