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

package/dist/cli2.js

@@ -1,20 +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 { addCompactGlobalFlags } from "./shell/global-flags.js";
-import { configureRuntimeCommand } from "./shell/runtime.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());
@@ -34,7 +41,9 @@ 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(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
@@ -42,10 +51,53 @@ function createProgram(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/version/index.js

@@ -0,0 +1,18 @@
+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 { runVersion } from "../../controllers/version.js";
+import { renderVersionSuccess } from "../../presenters/version.js";
+import { Command } from "commander";
+//#region src/commands/version/index.ts
+function createVersionCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("version"), runtime), "version");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "version", options, (context) => runVersion(context), { renderHuman: (context, descriptor, result) => renderVersionSuccess(context, descriptor, result) });
+	});
+	return command;
+}
+//#endregion
+export { createVersionCommand };

package/dist/controllers/app.js

@@ -829,7 +829,11 @@ async function resolveProjectContext(context, client, provider, explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
 		createProject: options?.allowCreate ? async (name) => {
 			const project = await provider.createProject({ name }).catch((error) => {
-				throw deployFailedError("Failed to create project for first deploy", error, ["prisma-cli app deploy"]);
+				throw createProjectOnFirstDeployError({
+					error,
+					inferredName: name,
+					workspaceName: authState.workspace.name
+				});
 			});
 			return {
 				id: project.id,
@@ -907,6 +911,52 @@ function deployFailedError(summary, error, nextSteps) {
 		nextSteps
 	});
 }
+/**
+* `app deploy` falls into "create a new project on first deploy" when no
+* existing project matches the package.json name (or the cwd basename as a
+* fallback). When the create call fails the user often doesn't realise the
+* CLI was attempting to create a project at all — they thought the deploy
+* would find an existing project. Surface that context, and recommend the
+* explicit `--project` flag as the unambiguous way out.
+*/
+function createProjectOnFirstDeployError(options) {
+	const { error, inferredName, workspaceName } = options;
+	const status = extractHttpStatus(error);
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	const inferredContext = `No existing project matched the package.json name \`${inferredName}\`, so the CLI attempted to create one.`;
+	const nextSteps = ["prisma-cli project list", "prisma-cli app deploy --project <id-or-name>"];
+	if (status === 401 || status === 403) return new CliError({
+		code: "AUTH_FORBIDDEN",
+		domain: "auth",
+		summary: "Could not create a new project for this deploy",
+		why: `${inferredContext} The platform rejected the create (HTTP ${status}).`,
+		fix: `Pass --project <id-or-name> to deploy into an existing project, or grant the service token project-create permission on workspace \`${workspaceName}\`.`,
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps
+	});
+	return new CliError({
+		code: "DEPLOY_FAILED",
+		domain: "app",
+		summary: "Could not create a new project for this deploy",
+		why: `${inferredContext} ${errorMessage}`.trim(),
+		fix: "Pass --project <id-or-name> to deploy into an existing project, or retry after addressing the platform error above.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps
+	});
+}
+function extractHttpStatus(error) {
+	if (!error || typeof error !== "object") return null;
+	const candidate = error;
+	if (typeof candidate.statusCode === "number") return candidate.statusCode;
+	if (typeof candidate.status === "number") return candidate.status;
+	if (typeof candidate.message === "string") {
+		const match = /\(HTTP (\d{3})\)/.exec(candidate.message);
+		if (match) return Number.parseInt(match[1], 10);
+	}
+	return null;
+}
 function noDeploymentsError(summary, why) {
 	return new CliError({
 		code: "NO_DEPLOYMENTS",

package/dist/controllers/version.js

@@ -0,0 +1,12 @@
+import { buildVersionResult } from "../lib/version.js";
+//#region src/controllers/version.ts
+async function runVersion(context) {
+	return {
+		command: "version",
+		result: buildVersionResult(context.runtime.env, context.runtime.argv),
+		warnings: [],
+		nextSteps: []
+	};
+}
+//#endregion
+export { runVersion };

package/dist/lib/auth/auth-ops.js

@@ -1,7 +1,9 @@
+import { SERVICE_TOKEN_ENV_VAR } from "./client.js";
 import { FileTokenStorage } from "../../adapters/token-storage.js";
 import { requireComputeAuth } from "./guard.js";
 import { login } from "./login.js";
 //#region src/lib/auth/auth-ops.ts
+const WORKSPACE_SUB_PREFIX = "workspace:";
 function decodeJwtPayload(token) {
 	try {
 		const payload = token.split(".")[1];
@@ -15,6 +17,13 @@ function emailFromClaims(claims) {
 	const email = claims.email;
 	return typeof email === "string" && email.trim().length > 0 ? email.trim() : null;
 }
+function workspaceIdFromClaims(claims) {
+	const sub = claims.sub;
+	if (typeof sub !== "string") return null;
+	if (!sub.startsWith(WORKSPACE_SUB_PREFIX)) return null;
+	const id = sub.slice(10).trim();
+	return id.length > 0 ? id : null;
+}
 async function performLogin(env) {
 	await login({
 		tokenStorage: new FileTokenStorage(env),
@@ -22,6 +31,12 @@ async function performLogin(env) {
 	});
 }
 async function readAuthState(env) {
+	const rawServiceToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawServiceToken !== void 0) {
+		const serviceToken = rawServiceToken.trim();
+		if (serviceToken.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return readServiceTokenAuthState(serviceToken, env);
+	}
 	const tokens = await new FileTokenStorage(env).getTokens();
 	if (!tokens) return {
 		authenticated: false,
@@ -29,15 +44,47 @@ async function readAuthState(env) {
 		user: null,
 		workspace: null
 	};
-	const email = emailFromClaims(decodeJwtPayload(tokens.accessToken));
+	const claims = decodeJwtPayload(tokens.accessToken);
+	return buildAuthState({
+		workspaceIdFromCredential: tokens.workspaceId,
+		claims,
+		env
+	});
+}
+async function readServiceTokenAuthState(token, env) {
+	const claims = decodeJwtPayload(token);
+	const workspaceId = workspaceIdFromClaims(claims);
+	if (!workspaceId) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null
+	};
+	return buildAuthState({
+		workspaceIdFromCredential: workspaceId,
+		claims,
+		env
+	});
+}
+async function buildAuthState({ workspaceIdFromCredential, claims, env }) {
+	let workspaceId = workspaceIdFromCredential;
+	let workspaceName = workspaceIdFromCredential;
 	const client = await requireComputeAuth(env);
-	let workspaceId = tokens.workspaceId;
-	let workspaceName = tokens.workspaceId;
 	if (client) try {
-		const { data } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
-		if (data?.data?.id) workspaceId = data.data.id;
+		const { data, response } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: workspaceIdFromCredential } } });
+		if (response?.status === 401) return {
+			authenticated: false,
+			provider: null,
+			user: null,
+			workspace: null
+		};
+		if (data?.data?.id) {
+			workspaceId = data.data.id;
+			workspaceName = data.data.id;
+		}
 		if (data?.data?.name) workspaceName = data.data.name;
 	} catch {}
+	const email = emailFromClaims(claims);
 	return {
 		authenticated: true,
 		provider: null,

package/dist/lib/auth/client.js

@@ -2,7 +2,7 @@ import os from "node:os";
 import path from "node:path";
 //#region src/lib/auth/client.ts
 const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
-const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_TOKEN";
+const SERVICE_TOKEN_ENV_VAR = "PRISMA_SERVICE_TOKEN";
 const AUTH_FILE_ENV_VAR = "PRISMA_COMPUTE_AUTH_FILE";
 function getApiBaseUrl(env = process.env) {
 	return env.PRISMA_MANAGEMENT_API_URL?.trim() || "https://api.prisma.io";

package/dist/lib/auth/guard.js

@@ -6,7 +6,7 @@ import { createManagementApiClient, createManagementApiSdk } from "@prisma/manag
 * Resolve authentication and return a ManagementApiClient.
 *
 * Priority:
-*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   1. PRISMA_SERVICE_TOKEN env var → service token (CI / headless)
 *   2. Stored OAuth tokens     → SDK with auto-refresh
 *
 * Returns null if not authenticated.

package/dist/lib/project/resolution.js

@@ -52,6 +52,9 @@ function projectNotFoundError(projectRef, workspace) {
 	});
 }
 function projectAmbiguousError(projectRef, matches) {
+	const firstMatch = matches[0];
+	const nextSteps = ["prisma-cli project list"];
+	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
 	return new CliError({
 		code: "PROJECT_AMBIGUOUS",
 		domain: "project",
@@ -63,7 +66,7 @@ function projectAmbiguousError(projectRef, matches) {
 			name: project.name
 		})) },
 		exitCode: 1,
-		nextSteps: ["prisma-cli project list"]
+		nextSteps
 	});
 }
 function projectUnresolvedError() {

package/dist/lib/version.js

@@ -0,0 +1,55 @@
+import { CliError } from "../shell/errors.js";
+import { createRequire } from "node:module";
+import process from "node:process";
+//#region src/lib/version.ts
+const requireFromHere = createRequire(import.meta.url);
+function readPackageMetadata() {
+	try {
+		return requireFromHere("../../package.json");
+	} catch {
+		return {};
+	}
+}
+function getCliVersion() {
+	const pkg = readPackageMetadata();
+	if (!pkg.version) throw new CliError({
+		code: "VERSION_UNAVAILABLE",
+		domain: "cli",
+		summary: "CLI version metadata is missing from the installed package",
+		why: "The bundled package.json could not be read or did not contain a version field.",
+		fix: "Reinstall the CLI from the npm registry, or check your install path is intact.",
+		exitCode: 1
+	});
+	return pkg.version;
+}
+function getCliName() {
+	return "prisma-cli";
+}
+function detectInvocation(env, argv) {
+	if (env.npm_config_user_agent?.startsWith("bun")) return "bunx";
+	const normalizedExecPath = env.npm_execpath?.replace(/\\/g, "/").toLowerCase();
+	const normalizedUserAgent = env.npm_config_user_agent?.toLowerCase();
+	if (env.npm_lifecycle_event === "npx" || normalizedExecPath?.includes("/_npx/") || normalizedUserAgent?.includes("npx")) return "npx";
+	const entry = (argv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	if (entry.endsWith(".ts") || entry.includes("/tsx/")) return "dev";
+	if (entry.includes("/_npx/")) return "npx";
+	if (entry.includes("/.bun/")) return "bunx";
+	if (entry.includes("/node_modules/.bin/") || /\/prisma-cli(\.cmd|\.exe)?$/.test(entry)) return "global";
+	return "unknown";
+}
+function buildVersionResult(env, argv) {
+	return {
+		cli: {
+			name: getCliName(),
+			version: getCliVersion()
+		},
+		node: { version: process.version },
+		os: {
+			platform: process.platform,
+			arch: process.arch
+		},
+		invocation: detectInvocation(env, argv)
+	};
+}
+//#endregion
+export { buildVersionResult, getCliName, getCliVersion };

package/dist/presenters/version.js

@@ -0,0 +1,29 @@
+import { renderShow } from "../output/patterns.js";
+//#region src/presenters/version.ts
+function renderVersionSuccess(context, descriptor, result) {
+	return renderShow({
+		title: "Showing CLI build and environment.",
+		descriptor,
+		fields: [
+			{
+				key: result.cli.name,
+				value: result.cli.version
+			},
+			{
+				key: "node",
+				value: result.node.version
+			},
+			{
+				key: "os",
+				value: `${result.os.platform} ${result.os.arch}`
+			},
+			{
+				key: "invocation",
+				value: result.invocation,
+				tone: result.invocation === "unknown" ? "dim" : "default"
+			}
+		]
+	}, context.ui);
+}
+//#endregion
+export { renderVersionSuccess };

package/dist/shell/command-meta.js

@@ -8,6 +8,12 @@ const DESCRIPTORS = [
 		examples: ["prisma-cli auth login", "prisma-cli app deploy"],
 		longDescription: "Deploy your app with isolated infrastructure for every branch"
 	},
+	{
+		id: "version",
+		path: ["prisma", "version"],
+		description: "Show CLI build and environment",
+		examples: ["prisma-cli version", "prisma-cli version --json"]
+	},
 	{
 		id: "auth",
 		path: ["prisma", "auth"],

package/dist/shell/global-flags.js

@@ -6,7 +6,8 @@ const COMPACT_GLOBAL_OPTION_FLAGS = [
 	"-v, --verbose",
 	"--trace",
 	"--no-interactive",
-	"-y, --yes"
+	"-y, --yes",
+	"--version"
 ];
 function addGlobalFlags(command) {
 	return command.option("--json", "Emit structured JSON output.").option("-q, --quiet", "Reduce human-oriented output.").option("-v, --verbose", "Increase human-oriented output detail.").option("--trace", "Show deeper diagnostics for failures.").option("-y, --yes", "Accept supported confirmation prompts.").addOption(new Option("--interactive", "Force interactive behavior when prompts are supported.")).addOption(new Option("--no-interactive", "Disable interactive behavior and prompts.")).addOption(new Option("--color", "Force color output in supported terminals.")).addOption(new Option("--no-color", "Disable color output."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.5",
   "description": "Preview of the unified Prisma CLI.",
   "type": "module",
   "bin": {