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

package/dist/controllers/agent.js

@@ -0,0 +1,228 @@
+import { resolveSkillsPackageRunner } from "../lib/agent/package-manager.js";
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { DEFAULT_PRISMA_AGENT_SKILLS, DEFAULT_PRISMA_AGENT_TARGETS, PRISMA_AGENT_INSTALL_ARGS, PRISMA_AGENT_STATUS_ARGS, PRISMA_SKILLS_SOURCE, SKILLS_CLI_PACKAGE } from "../lib/agent/constants.js";
+import { readPrismaAgentSetupStatus, resolvePrismaAgentSetupCwd } from "../lib/agent/setup-status.js";
+import { formatShellCommand } from "../shell/command-arguments.js";
+import { CliError } from "../shell/errors.js";
+import { execa } from "execa";
+//#region src/controllers/agent.ts
+async function runAgentInstall(context, options, operation = "install", runOptions = {}) {
+	const dryRun = options.dryRun === true;
+	const cwd = await resolvePrismaAgentSetupCwd({
+		cwd: runOptions.cwd ?? context.runtime.cwd,
+		signal: context.runtime.signal
+	});
+	const skills = await installSkills(context, {
+		command: await buildSkillsInstallCommand(context, options, cwd),
+		cwd,
+		dryRun
+	});
+	const nextSteps = await resolveAgentInstallNextSteps(context, {
+		cwd,
+		dryRun,
+		global: options.global === true
+	});
+	return {
+		command: `agent.${operation}`,
+		result: {
+			operation,
+			skills
+		},
+		warnings: [],
+		nextSteps
+	};
+}
+async function resolveAgentInstallNextSteps(context, options) {
+	if (options.dryRun) return [];
+	return [`Run ${await resolvePrismaCliPackageCommand({
+		cwd: options.cwd,
+		signal: context.runtime.signal,
+		args: options.global ? [...PRISMA_AGENT_STATUS_ARGS, "--global"] : PRISMA_AGENT_STATUS_ARGS
+	})} to verify the installed Prisma skills.`];
+}
+async function runAgentStatus(context, options = {}) {
+	const statusScope = options.global ? "global" : "project";
+	const cwd = await resolvePrismaAgentSetupCwd({
+		cwd: context.runtime.cwd,
+		signal: context.runtime.signal
+	});
+	const status = await readPrismaAgentSetupStatus({
+		cwd,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal
+	});
+	const installCommand = await resolvePrismaCliPackageCommand({
+		cwd,
+		signal: context.runtime.signal,
+		args: options.global ? [...PRISMA_AGENT_INSTALL_ARGS, "--global"] : PRISMA_AGENT_INSTALL_ARGS
+	});
+	const skillsList = await listInstalledPrismaSkills(context, cwd, statusScope);
+	const skillsInstalled = skillsList.status === "ok" ? skillsList.skills.length > 0 : statusScope === "project" && status.skillsInstalled;
+	const warnings = skillsList.status === "ok" ? [] : [statusScope === "project" ? `Could not read installed skills with ${formatShellCommand(skillsList.command)}: ${skillsList.message}. Falling back to ${status.skillsLockPath}.` : `Could not read globally installed skills with ${formatShellCommand(skillsList.command)}: ${skillsList.message}.`];
+	const statusSource = resolveStatusSource(skillsList, statusScope);
+	return {
+		command: "agent.status",
+		result: {
+			skills: skillsList.status === "ok" ? skillsList.skills : [],
+			skillsListCommand: skillsList.command,
+			statusScope,
+			skillsLockPath: status.skillsLockPath,
+			skillsLockInstalled: status.skillsInstalled,
+			skillsInstalled,
+			statusSource,
+			promptDismissedAt: status.promptDismissedAt
+		},
+		warnings,
+		nextSteps: skillsInstalled ? [] : [`Run ${installCommand} to install or refresh Prisma skills.`]
+	};
+}
+async function buildSkillsInstallCommand(context, options, cwd) {
+	const command = [
+		...await resolveSkillsPackageRunner({
+			cwd,
+			signal: context.runtime.signal
+		}),
+		SKILLS_CLI_PACKAGE,
+		"add",
+		PRISMA_SKILLS_SOURCE
+	];
+	const skills = options.skill && options.skill.length > 0 ? options.skill : DEFAULT_PRISMA_AGENT_SKILLS;
+	const agents = resolveTargetAgents(options);
+	for (const skill of skills) command.push("--skill", skill);
+	for (const agent of agents) command.push("--agent", agent);
+	if (options.global) command.push("--global");
+	if (options.copy || process.platform === "win32") command.push("--copy");
+	command.push("--yes");
+	return command;
+}
+function resolveTargetAgents(options) {
+	if (options.allAgents) return ["*"];
+	if (options.agent && options.agent.length > 0) return options.agent;
+	return DEFAULT_PRISMA_AGENT_TARGETS;
+}
+async function installSkills(context, options) {
+	if (options.dryRun) return {
+		status: "would-install",
+		command: options.command
+	};
+	await runChildProcess(context, options.command, options.cwd);
+	return {
+		status: "installed",
+		command: options.command
+	};
+}
+async function listInstalledPrismaSkills(context, cwd, scope) {
+	const command = [
+		...await resolveSkillsPackageRunner({
+			cwd,
+			signal: context.runtime.signal
+		}),
+		SKILLS_CLI_PACKAGE,
+		"list",
+		...scope === "global" ? ["-g"] : [],
+		"--json"
+	];
+	try {
+		const { stdout } = await runChildProcessCapture(context, command, cwd);
+		return {
+			status: "ok",
+			command,
+			skills: parseSkillsListOutput(stdout).filter((skill) => isPrismaSkillName(skill.name))
+		};
+	} catch (error) {
+		if (isAbortError(error) || context.runtime.signal.aborted) throw error;
+		return {
+			status: "failed",
+			command,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function runChildProcess(context, command, cwd) {
+	const [executable, args] = splitCommand(command);
+	try {
+		await execa(executable, args, {
+			cwd,
+			env: context.runtime.env,
+			cancelSignal: context.runtime.signal,
+			stdin: "ignore"
+		});
+	} catch (error) {
+		if (isAbortError(error)) throw error;
+		throw skillsInstallFailed(command, exitCodeFromError(error), error);
+	}
+}
+async function runChildProcessCapture(context, command, cwd) {
+	const [executable, args] = splitCommand(command);
+	const result = await execa(executable, args, {
+		cwd,
+		env: context.runtime.env,
+		cancelSignal: context.runtime.signal,
+		stdin: "ignore"
+	});
+	return {
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? ""
+	};
+}
+function splitCommand(command) {
+	const [executable, ...args] = command;
+	if (!executable) throw new Error("Cannot run an empty command.");
+	return [executable, args];
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError" || isObject(error) && error.isCanceled === true;
+}
+function exitCodeFromError(error) {
+	if (!isObject(error) || typeof error.exitCode !== "number") return null;
+	return error.exitCode;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function resolveStatusSource(skillsList, statusScope) {
+	if (skillsList.status === "ok") return "skills-cli";
+	return statusScope === "project" ? "skills-lock" : "unavailable";
+}
+function parseSkillsListOutput(output) {
+	const parsed = JSON.parse(output);
+	if (!Array.isArray(parsed)) throw new Error("skills list did not return a JSON array");
+	return parsed.flatMap((item) => {
+		const skill = parseInstalledSkill(item);
+		return skill ? [skill] : [];
+	});
+}
+function parseInstalledSkill(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const candidate = value;
+	if (typeof candidate.name !== "string" || typeof candidate.path !== "string" || typeof candidate.scope !== "string" || !Array.isArray(candidate.agents)) return null;
+	return {
+		name: candidate.name,
+		path: candidate.path,
+		scope: candidate.scope,
+		agents: candidate.agents.filter((agent) => typeof agent === "string")
+	};
+}
+function isPrismaSkillName(name) {
+	return name === "prisma" || name.startsWith("prisma-");
+}
+function skillsInstallFailed(command, code, error) {
+	const commandText = formatShellCommand(command);
+	return new CliError({
+		code: "AGENT_SKILLS_INSTALL_FAILED",
+		domain: "cli",
+		summary: "Prisma skills install failed",
+		why: `The skills installer exited with code ${code ?? "unknown"}.`,
+		fix: "Run the command below to retry the installer directly.",
+		debug: formatErrorDebug(error),
+		exitCode: 1,
+		nextSteps: [commandText]
+	});
+}
+function formatErrorDebug(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	if (error === void 0) return;
+	return String(error);
+}
+//#endregion
+export { runAgentInstall, runAgentStatus };

package/dist/controllers/app-env-api.js

@@ -0,0 +1,55 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/controllers/app-env-api.ts
+async function findVariableByNaturalKey(client, projectId, key, resolved, signal) {
+	const { data, error, response } = await client.GET("/v1/environment-variables", {
+		params: { query: {
+			projectId,
+			class: resolved.apiTarget.class,
+			key,
+			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {}
+		} },
+		signal
+	});
+	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
+	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
+}
+function toMetadata(row, requestedScope) {
+	const rowScope = row.branchId === null ? {
+		kind: "role",
+		role: row.class
+	} : requestedScope;
+	return {
+		id: row.id,
+		key: row.key,
+		scope: rowScope,
+		source: formatDescriptorLabel(rowScope),
+		isManagedBySystem: row.isManagedBySystem,
+		updatedAt: row.updatedAt
+	};
+}
+function rowMatchesExactScope(row, resolved) {
+	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
+}
+function apiCallError(summary, response, error) {
+	const status = response?.status ?? 0;
+	const apiCode = error?.error?.code;
+	const apiMessage = error?.error?.message;
+	const apiHint = error?.error?.hint;
+	if (status === 401 || status === 403) return authRequiredError(["prisma auth login"]);
+	return new CliError({
+		code: apiCode ?? "ENV_API_ERROR",
+		domain: "app",
+		summary,
+		why: apiMessage ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: apiHint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function formatDescriptorLabel(scope) {
+	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
+	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
+}
+//#endregion
+export { apiCallError, findVariableByNaturalKey, toMetadata };

package/dist/controllers/app-env-file.js

@@ -0,0 +1,181 @@
+import { CliError } from "../shell/errors.js";
+import { formatScopeLabel } from "../lib/app/env-config.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+//#region src/controllers/app-env-file.ts
+async function runEnvAddFile(context, client, projectId, resolved, filePath, assignments, verboseContext) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const existingKeys = assignments.map((assignment) => assignment.key).filter((key) => existing.has(key));
+	if (existingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_ALREADY_EXISTS",
+		domain: "app",
+		summary: `${existingKeys.length} environment variable(s) already exist in ${formatScopeLabel(resolved.scope)}`,
+		why: `Existing keys: ${formatKeyList(existingKeys)}.`,
+		fix: "Split the input file by key state: update existing keys and add new keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			existingKeys,
+			first: "update-existing"
+		}),
+		meta: { keys: existingKeys }
+	});
+	const warnings = await missingPreviewDefaultWarnings(client, projectId, resolved.scope, assignments.map((assignment) => assignment.key), context.runtime.signal);
+	const variables = [];
+	for (const assignment of assignments) try {
+		const { data, error, response } = await client.POST("/v1/environment-variables", {
+			body: {
+				projectId,
+				class: resolved.apiTarget.class,
+				...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
+				key: assignment.key,
+				value: assignment.value
+			},
+			signal: context.runtime.signal
+		});
+		if (error || !data) throw apiCallError(`Failed to add ${assignment.key}`, response, error);
+		variables.push(toMetadata(data.data, resolved.descriptor));
+	} catch (error) {
+		throw envFileApplyFailedError("add", filePath, resolved.scope, assignment.key, variables, error);
+	}
+	return {
+		command: "project.env.add",
+		result: {
+			projectId,
+			verboseContext,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings,
+		nextSteps: []
+	};
+}
+async function runEnvUpdateFile(context, client, projectId, resolved, filePath, assignments, verboseContext) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const missingKeys = assignments.map((assignment) => assignment.key).filter((key) => !existing.has(key));
+	if (missingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `${missingKeys.length} environment variable(s) not found in ${formatScopeLabel(resolved.scope)}`,
+		why: `Missing keys: ${formatKeyList(missingKeys)}.`,
+		fix: "Split the input file by key state: add missing keys and update existing keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			missingKeys,
+			first: "add-missing"
+		}),
+		meta: { keys: missingKeys }
+	});
+	const variables = [];
+	for (const assignment of assignments) {
+		const existingVariable = existing.get(assignment.key);
+		if (!existingVariable) continue;
+		try {
+			const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
+				params: { path: { envVarId: existingVariable.id } },
+				body: { value: assignment.value },
+				signal: context.runtime.signal
+			});
+			if (error || !data) throw apiCallError(`Failed to update value for ${assignment.key}`, response, error);
+			variables.push(toMetadata(data.data, resolved.descriptor));
+		} catch (error) {
+			throw envFileApplyFailedError("update", filePath, resolved.scope, assignment.key, variables, error);
+		}
+	}
+	return {
+		command: "project.env.update",
+		result: {
+			projectId,
+			verboseContext,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function findVariablesByNaturalKey(client, projectId, keys, resolved, signal) {
+	const found = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const row = await findVariableByNaturalKey(client, projectId, key, resolved, signal);
+		if (row) found.set(key, row);
+	}
+	return found;
+}
+async function missingPreviewDefaultWarnings(client, projectId, scope, keys, signal) {
+	if (scope.kind !== "branch") return [];
+	const previewScope = {
+		scope: {
+			kind: "role",
+			role: "preview"
+		},
+		descriptor: {
+			kind: "role",
+			role: "preview"
+		},
+		apiTarget: {
+			class: "preview",
+			branchId: null
+		}
+	};
+	const missing = [];
+	for (const key of keys) if (!await findVariableByNaturalKey(client, projectId, key, previewScope, signal)) missing.push(key);
+	if (missing.length === 0) return [];
+	if (missing.length === 1) return [`Variable "${missing[0]}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`];
+	return [`Variables ${formatKeyList(missing)} do not exist in preview. They will only exist on ${formatScopeLabel(scope)}.`];
+}
+function envFileApplyFailedError(command, filePath, scope, failedKey, writtenVariables, error) {
+	const writtenKeys = writtenVariables.map((variable) => variable.key);
+	const cause = error instanceof CliError ? error.summary : error instanceof Error ? error.message : "Unknown error.";
+	return new CliError({
+		code: "ENV_FILE_APPLY_FAILED",
+		domain: "app",
+		summary: `Failed to ${command} "${failedKey}" from "${filePath}"`,
+		why: writtenKeys.length === 0 ? `No variables were written before ${failedKey} failed. Cause: ${cause}` : `Written keys before failure: ${formatKeyList(writtenKeys)}. Cause: ${cause}`,
+		fix: "Inspect the target scope, then retry the remaining keys once the API issue is resolved.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env list ${formatScopeFlag(scope)}`, retryStepForApplyFailure(command, filePath, scope, writtenKeys)],
+		meta: {
+			file: filePath,
+			failedKey,
+			writtenKeys
+		}
+	});
+}
+function retryStepForApplyFailure(command, filePath, scope, writtenKeys) {
+	if (command === "update") return `prisma-cli project env update --file ${filePath} ${formatScopeFlag(scope)}`;
+	if (writtenKeys.length === 0) return `prisma-cli project env add --file ${filePath} ${formatScopeFlag(scope)}`;
+	return `prisma-cli project env add --file <remaining.env> ${formatScopeFlag(scope)}`;
+}
+function splitFileNextSteps(filePath, scope, options) {
+	const scopeFlag = formatScopeFlag(scope);
+	const existingFile = `${filePath}.existing`;
+	const newFile = `${filePath}.new`;
+	if (options.first === "update-existing") return [
+		`# existing keys: ${formatKeyList(options.existingKeys)}`,
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`,
+		"# new keys only",
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`
+	];
+	return [
+		`# missing keys: ${formatKeyList(options.missingKeys)}`,
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`,
+		"# existing keys only",
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`
+	];
+}
+function formatKeyList(keys) {
+	return keys.map((key) => `"${key}"`).join(", ");
+}
+function formatScopeFlag(scope) {
+	if (scope.kind === "role") return `--role ${scope.role}`;
+	return `--branch ${scope.branchName}`;
+}
+//#endregion
+export { runEnvAddFile, runEnvUpdateFile };