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

package/dist/lib/app/env-config.js

@@ -20,10 +20,21 @@ function resolveEnvScope(flags, options) {
 	}
 	return null;
 }
-function parseKeyValuePositional(raw, command) {
+function parseKeyValuePositional(raw, command, env = process.env) {
 	if (!raw) throw usageError(`prisma-cli project env ${command} requires KEY=VALUE`, "No KEY=VALUE positional argument was supplied.", "Pass the variable as KEY=VALUE, e.g. STRIPE_KEY=sk_test_xxx.", [`prisma-cli project env ${command} STRIPE_KEY=sk_test_xxx --role production`], "app");
 	const separatorIndex = raw.indexOf("=");
-	if (separatorIndex === -1) throw usageError(`KEY=VALUE argument is missing the = separator`, `"${raw}" does not contain an = character.`, "Pass the variable as KEY=VALUE, e.g. STRIPE_KEY=sk_test_xxx.", [`prisma-cli project env ${command} STRIPE_KEY=sk_test_xxx --role production`], "app");
+	if (separatorIndex === -1) {
+		if (KEY_SHAPE.test(raw)) {
+			validateKey(raw, command);
+			const value = env[raw];
+			if (typeof value === "string" && value.length > 0) return {
+				key: raw,
+				value
+			};
+			throw usageError(`Value for "${raw}" was not provided`, `No KEY=VALUE assignment was supplied, and ${raw} is not set in the current environment.`, "Pass KEY=VALUE or export the variable before running the command.", [`prisma-cli project env ${command} ${raw}=value --role production`, `${raw}=value prisma-cli project env ${command} ${raw} --role production`], "app");
+		}
+		throw usageError(`KEY=VALUE argument is missing the = separator`, `"${raw}" does not contain an = character.`, "Pass the variable as KEY=VALUE, e.g. STRIPE_KEY=sk_test_xxx.", [`prisma-cli project env ${command} STRIPE_KEY=sk_test_xxx --role production`], "app");
+	}
 	const key = raw.slice(0, separatorIndex);
 	const value = raw.slice(separatorIndex + 1);
 	validateKey(key, command);

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,23 +31,60 @@ 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,
 		provider: null,
 		user: null,
-		workspace: null,
-		linkedProjectId: null
+		workspace: null
+	};
+	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
 	};
-	const email = emailFromClaims(decodeJwtPayload(tokens.accessToken));
+	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,
@@ -46,8 +92,7 @@ async function readAuthState(env) {
 		workspace: {
 			id: workspaceId,
 			name: workspaceName
-		},
-		linkedProjectId: null
+		}
 	};
 }
 async function performLogout(env) {

package/dist/lib/auth/client.js

@@ -1,8 +1,8 @@
-import path from "node:path";
 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

@@ -0,0 +1,151 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/lib/project/resolution.ts
+async function resolveProjectTarget(options) {
+	const projects = await options.listProjects();
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit");
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	let staleRemembered = false;
+	if (remembered) {
+		const matched = projects.find((project) => project.id === remembered.id);
+		if (matched) return rememberIfRequested(options, matched, "remembered-local");
+		staleRemembered = true;
+	}
+	const packageName = await readPackageName(options.context.runtime.cwd);
+	if (packageName) {
+		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name");
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, "package-name");
+	}
+	if (options.allowCreate && options.createProject) {
+		const inferredName = packageName ?? path.basename(options.context.runtime.cwd);
+		if (inferredName) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], "package-name");
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, "package-name");
+			return rememberIfRequested(options, await options.createProject(inferredName), "created");
+		}
+	}
+	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(projects).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}), "prompt");
+	if (staleRemembered && projects.length > 1) throw localStateStaleError();
+	throw projectUnresolvedError();
+}
+function projectNotFoundError(projectRef, workspace) {
+	return new CliError({
+		code: "PROJECT_NOT_FOUND",
+		domain: "project",
+		summary: "Project not found",
+		why: `The project "${projectRef}" does not exist in workspace "${workspace.name}" or is not accessible.`,
+		fix: "Pass a project id or name from prisma-cli project list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+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",
+		summary: "Project resolution is ambiguous",
+		why: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		meta: { matches: matches.map((project) => ({
+			id: project.id,
+			name: project.name
+		})) },
+		exitCode: 1,
+		nextSteps
+	});
+}
+function projectUnresolvedError() {
+	return new CliError({
+		code: "PROJECT_UNRESOLVED",
+		domain: "project",
+		summary: "No project is resolved for this directory",
+		why: "No project could be resolved from explicit input, platform mappings, remembered local context, or package metadata.",
+		fix: "Pass --project <id-or-name> on the command that needs a project, or add a package.json name that matches an accessible project.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list", "prisma-cli project show --project <id-or-name>"]
+	});
+}
+function localStateStaleError() {
+	return new CliError({
+		code: "LOCAL_STATE_STALE",
+		domain: "project",
+		summary: "Remembered project context is stale",
+		why: "The remembered project is no longer available in the selected workspace, and automatic resolution would be ambiguous.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+async function readPackageName(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return null;
+		const packageName = "name" in parsed ? parsed.name : null;
+		return typeof packageName === "string" && packageName.trim().length > 0 ? packageName.trim() : null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		if (error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+function sortProjects(projects) {
+	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+function resolveExplicitProject(projectRef, projects, workspace) {
+	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
+	if (matches.length === 1) return matches[0];
+	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
+	throw projectNotFoundError(projectRef, workspace);
+}
+function resolveAmbiguousProject(options, matches, projectRef) {
+	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(matches).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}).then((selected) => rememberIfRequested(options, selected, "prompt"));
+	throw projectAmbiguousError(projectRef, matches);
+}
+function projectMatchesPackageName(project, packageName) {
+	return project.id === packageName || project.name === packageName || project.slug === packageName;
+}
+async function resolveDurablePlatformMapping() {
+	return null;
+}
+async function rememberIfRequested(options, project, projectSource) {
+	if (options.remember) await options.context.stateStore.setRememberedProject({
+		id: project.id,
+		name: project.name,
+		workspaceId: options.workspace.id
+	});
+	return {
+		workspace: options.workspace,
+		project: toProjectSummary(project),
+		resolution: { projectSource }
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+//#endregion
+export { resolveProjectTarget, sortProjects };

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/output/patterns.js

@@ -74,7 +74,6 @@ function formatListItemValue(ui, item) {
 }
 function renderAnnotation(ui, status) {
 	if (status === "active") return ui.success("(active)");
-	if (status === "linked") return ui.accent("(linked)");
 	if (status === "default") return ui.dim("(default)");
 	return "";
 }

package/dist/presenters/app.js

@@ -29,9 +29,17 @@ function renderAppDeploy(context, descriptor, result) {
 		title: "Deploying the selected app.",
 		descriptor,
 		fields: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
 			{
 				key: "project",
-				value: result.projectId
+				value: result.project.name
+			},
+			{
+				key: "branch",
+				value: result.branch.name
 			},
 			{
 				key: "app",

package/dist/presenters/branch.js

@@ -2,11 +2,11 @@ import { renderList, renderMutate, renderShow, serializeList } from "../output/p
 //#region src/presenters/branch.ts
 function renderBranchList(context, descriptor, result) {
 	return renderList({
-		title: "Listing branches for the linked project.",
+		title: "Listing branches for the resolved project.",
 		descriptor,
 		parentContext: {
 			key: "project",
-			value: result.projectName ?? "not linked"
+			value: result.projectName ?? "not resolved"
 		},
 		items: result.branches.map((branch) => ({
 			noun: "branch",
@@ -19,7 +19,7 @@ function renderBranchList(context, descriptor, result) {
 }
 function serializeBranchList(result) {
 	return serializeList({
-		context: { project: result.projectName ?? "not linked" },
+		context: { project: result.projectName ?? "not resolved" },
 		items: result.branches.map((branch) => ({
 			noun: "branch",
 			label: branch.name,
@@ -30,7 +30,7 @@ function serializeBranchList(result) {
 }
 function serializeBranchShow(result) {
 	return {
-		linkedProjectId: result.linkedProjectId,
+		projectId: result.projectId,
 		projectName: result.projectName,
 		branch: {
 			name: result.branch.name,
@@ -45,7 +45,7 @@ function renderBranchShow(context, descriptor, result) {
 	const fields = [
 		{
 			key: "project",
-			value: result.projectName ?? "not linked",
+			value: result.projectName ?? "not resolved",
 			tone: result.projectName ? "default" : "dim"
 		},
 		{
@@ -92,7 +92,7 @@ function renderBranchUse(context, descriptor, result) {
 		descriptor,
 		context: [{
 			key: "project",
-			value: result.projectName ?? "not linked",
+			value: result.projectName ?? "not resolved",
 			tone: result.projectName ? "default" : "dim"
 		}, {
 			key: "branch",

package/dist/presenters/project.js

@@ -12,7 +12,7 @@ function renderProjectList(context, descriptor, result) {
 			noun: "project",
 			label: project.name,
 			id: project.id,
-			status: result.linkedProjectId === project.id ? "linked" : null
+			status: null
 		})),
 		emptyMessage: "No projects found."
 	}, context.ui);
@@ -24,61 +24,101 @@ function serializeProjectList(result) {
 			noun: "project",
 			label: project.name,
 			id: project.id,
-			status: result.linkedProjectId === project.id ? "linked" : null
+			status: null
 		}))
 	});
 }
 function renderProjectShow(context, descriptor, result) {
-	if (!result.linkedProjectId) return renderShow({
-		title: "Showing the linked project for the current repo.",
-		descriptor,
-		fields: [{
-			key: "project",
-			value: "not linked",
-			tone: "dim"
-		}]
-	}, context.ui);
-	if (!result.project || !result.workspace) return renderShow({
-		title: "Showing the linked project for the current repo.",
+	return renderShow({
+		title: "Showing the project Prisma resolves for this directory.",
 		descriptor,
-		fields: [{
-			key: "project",
-			value: "linked",
-			tone: "success"
-		}, {
-			key: "remote details",
-			value: "unavailable until you sign in",
-			tone: "dim"
-		}]
+		fields: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "resolution",
+				value: formatProjectSource(result.resolution.projectSource)
+			}
+		]
 	}, context.ui);
-	return renderShow({
-		title: "Showing the linked project for the current repo.",
+}
+function serializeProjectShow(result) {
+	return result;
+}
+function renderGitConnect(context, descriptor, result) {
+	const connection = result.repositoryConnection;
+	return renderMutate({
+		title: "Connecting Git to the resolved project.",
 		descriptor,
-		fields: [{
-			key: "project",
-			value: result.project.name
-		}, {
-			key: "workspace",
-			value: result.workspace.name
-		}]
+		context: [
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "repository",
+				value: connection.repository.fullName
+			},
+			{
+				key: "status",
+				value: connection.status
+			}
+		],
+		operationDescription: "Applying repository connection",
+		operationCount: 1,
+		details: [formatGitConnectionDetail(connection.status)]
 	}, context.ui);
 }
-function renderProjectLink(context, descriptor, result) {
-	if (!result.project || !result.workspace) throw new Error("Linked project result must be enriched for human output.");
+function renderGitDisconnect(context, descriptor, result) {
 	return renderMutate({
-		title: "Linking the current repo to an existing project.",
+		title: "Disconnecting Git from the resolved project.",
 		descriptor,
-		context: [{
-			key: "project",
-			value: result.project.name
-		}, {
-			key: "workspace",
-			value: result.workspace.name
-		}],
-		operationDescription: "Applying local project link",
+		context: [
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "repository",
+				value: result.repositoryConnection.repository.fullName
+			}
+		],
+		operationDescription: "Applying repository disconnection",
 		operationCount: 1,
-		details: ["Project link written to local repo config."]
+		details: ["GitHub branch automation is no longer active for this project."]
 	}, context.ui);
 }
+function formatProjectSource(source) {
+	switch (source) {
+		case "explicit": return "explicit";
+		case "platform-mapping": return "platform mapping";
+		case "remembered-local": return "remembered local context";
+		case "package-name": return "package name";
+		case "created": return "created";
+		case "prompt": return "prompt";
+	}
+}
+function formatGitConnectionDetail(status) {
+	switch (status) {
+		case "active": return "GitHub branch automation is active for this project.";
+		case "pending": return "GitHub branch automation is pending GitHub App installation.";
+		case "archived": return "GitHub branch automation has been archived for this project.";
+		default: return "GitHub repository is connected, but branch automation is not active.";
+	}
+}
 //#endregion
-export { renderProjectLink, renderProjectList, renderProjectShow, serializeProjectList };
+export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow };

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 };