@looma/prisma-cli 0.1.1

package/dist/controllers/auth.js

@@ -0,0 +1,107 @@
+import { authRequiredError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createAuthUseCases } from "../use-cases/auth.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { performLogin, performLogout, readAuthState } from "../lib/auth/auth-ops.js";
+//#region src/controllers/auth.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runAuthLogin(context, options) {
+	let result;
+	if (isRealMode(context)) {
+		await performLogin(context.runtime.env);
+		result = await readAuthState(context.runtime.env);
+	} else result = await loginWithSelectionFlow(context, createAuthUseCases(createCliUseCaseGateways(context)), options);
+	return createAuthSuccess("auth.login", result, ["prisma auth whoami", "prisma project list"]);
+}
+async function runAuthLogout(context) {
+	let result;
+	if (isRealMode(context)) {
+		await performLogout(context.runtime.env);
+		result = await readAuthState(context.runtime.env);
+	} else result = await createAuthUseCases(createCliUseCaseGateways(context)).logout();
+	return createAuthSuccess("auth.logout", result, ["prisma auth login"]);
+}
+async function runAuthWhoAmI(context) {
+	let result;
+	if (isRealMode(context)) result = await readAuthState(context.runtime.env);
+	else result = await createAuthUseCases(createCliUseCaseGateways(context)).whoami();
+	return createAuthSuccess("auth.whoami", result, result.authenticated ? [] : ["prisma auth login"]);
+}
+async function requireAuthenticatedAuthState(context) {
+	if (isRealMode(context)) {
+		const current = await readAuthState(context.runtime.env);
+		if (current.authenticated) return current;
+		if (!canPrompt(context)) throw authRequiredError();
+		await performLogin(context.runtime.env);
+		return readAuthState(context.runtime.env);
+	}
+	const useCases = createAuthUseCases(createCliUseCaseGateways(context));
+	const current = await useCases.whoami();
+	if (current.authenticated) return current;
+	if (!canPrompt(context)) throw authRequiredError();
+	return loginWithSelectionFlow(context, useCases, {});
+}
+async function loginWithSelectionFlow(context, useCases, options) {
+	const selection = await resolveLoginSelection(useCases, canPrompt(context) ? createSelectPromptPort(context) : null, options);
+	return useCases.login(selection);
+}
+async function resolveLoginSelection(useCases, prompt, options) {
+	const provider = options.provider ? (await useCases.resolveProvider(options.provider)).id : (await selectProvider(useCases, prompt)).id;
+	const user = options.user ? await useCases.resolveUserForProvider(provider, options.user) : await selectUser(useCases, prompt, provider);
+	const workspace = options.workspace ? await useCases.resolveWorkspaceForUser(user.id, options.workspace) : await selectWorkspace(useCases, prompt, user.id);
+	return {
+		provider,
+		userId: user.id,
+		workspaceId: workspace.id
+	};
+}
+async function selectProvider(useCases, prompt) {
+	if (!prompt) throw nonInteractiveLoginError("Re-run prisma auth login in a TTY, or provide --provider and --user, and --workspace when required.");
+	const providers = await useCases.listProviders();
+	return prompt.select({
+		message: "Select a provider",
+		choices: providers.map((provider) => ({
+			label: provider.name,
+			value: provider
+		}))
+	});
+}
+async function selectUser(useCases, prompt, provider) {
+	const users = await useCases.listUsersForProvider(provider);
+	if (!prompt) throw nonInteractiveLoginError("Re-run prisma auth login in a TTY, or provide --provider and --user, and --workspace when required.");
+	return prompt.select({
+		message: "Select a user",
+		choices: users.map((user) => ({
+			label: `${user.name} <${user.email}>`,
+			value: user
+		}))
+	});
+}
+async function selectWorkspace(useCases, prompt, userId) {
+	const workspaces = await useCases.listWorkspacesForUser(userId);
+	if (workspaces.length === 1) return workspaces[0];
+	if (!prompt) throw usageError("Login requires explicit selectors in non-interactive mode", "The selected mock user belongs to more than one workspace and the shell cannot prompt in the current mode.", "Re-run prisma auth login in a TTY, or provide --workspace.", ["prisma auth login"], "auth");
+	return prompt.select({
+		message: "Select a workspace",
+		choices: workspaces.map((workspace) => ({
+			label: `${workspace.name} (${workspace.id})`,
+			value: workspace
+		}))
+	});
+}
+function nonInteractiveLoginError(fix) {
+	return usageError("Login requires explicit selectors in non-interactive mode", "The mock shell cannot prompt in the current mode.", fix, ["prisma auth login"], "auth");
+}
+function createAuthSuccess(command, result, nextSteps) {
+	return {
+		command,
+		result,
+		warnings: [],
+		nextSteps
+	};
+}
+//#endregion
+export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI };

package/dist/controllers/env.js

@@ -0,0 +1,73 @@
+import { featureUnavailableError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { createEnvUseCases } from "../use-cases/env.js";
+//#region src/controllers/env.ts
+const PREVIEW_ENVIRONMENT_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runEnvList(context) {
+	if (isRealMode(context)) throw envCommandsUnavailableError();
+	return {
+		command: "env.list",
+		result: await createEnvUseCases(createCliUseCaseGateways(context)).list(),
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runEnvShow(context) {
+	if (isRealMode(context)) throw envCommandsUnavailableError();
+	const result = await createEnvUseCases(createCliUseCaseGateways(context)).show();
+	return {
+		command: "env.show",
+		result,
+		warnings: [],
+		nextSteps: result.environment.kind === "preview" && !result.environment.remoteState ? ["prisma app deploy"] : []
+	};
+}
+async function runEnvUse(context, environmentName) {
+	if (isRealMode(context)) throw envCommandsUnavailableError();
+	const useCases = createEnvUseCases(createCliUseCaseGateways(context));
+	const resolvedEnvironmentName = await resolveEnvironmentNameForUse(context, useCases, environmentName);
+	validateEnvironmentName(resolvedEnvironmentName);
+	const result = await useCases.use(resolvedEnvironmentName);
+	return {
+		command: "env.use",
+		result,
+		warnings: result.environment.kind === "production" ? ["Production is now the default target."] : [],
+		nextSteps: result.environment.kind === "preview" && !result.environment.remoteState ? ["prisma env show", "prisma app deploy"] : ["prisma env show"]
+	};
+}
+async function resolveEnvironmentNameForUse(context, useCases, environmentName) {
+	if (environmentName) return environmentName;
+	if (!canPrompt(context)) throw environmentSelectionRequiredError();
+	const result = await useCases.list();
+	return createSelectPromptPort(context).select({
+		message: "Select an environment",
+		choices: result.environments.map((environment) => ({
+			label: renderEnvironmentChoiceLabel(environment),
+			value: environment.name
+		}))
+	});
+}
+function renderEnvironmentChoiceLabel(environment) {
+	const markers = [];
+	if (environment.active) markers.push("active");
+	if (environment.kind !== "local" && !environment.remoteState) markers.push("not created yet");
+	return markers.length > 0 ? `${environment.name} (${markers.join(", ")})` : environment.name;
+}
+function validateEnvironmentName(environmentName) {
+	if (environmentName === "local" || environmentName === "production") return;
+	if (PREVIEW_ENVIRONMENT_PATTERN.test(environmentName)) return;
+	throw usageError("Environment name must use the documented form", "Environment names must be local, production, or a lowercase preview slug such as preview or feat-auth.", "Use local, production, or a lowercase preview name with letters, numbers, and hyphens.", ["prisma env list"], "env");
+}
+function environmentSelectionRequiredError() {
+	return usageError("Environment use requires a target in non-interactive mode", "This command cannot prompt for environment selection in the current mode.", "Re-run prisma env use in a TTY, or pass an environment name explicitly.", ["prisma env list"], "env");
+}
+function envCommandsUnavailableError() {
+	return featureUnavailableError("Environment commands are not available in real provider mode", "The current Management API does not expose environment resources, so the CLI cannot resolve or change real environment context yet.", "Use the prototype app deploy flow for real-provider testing, or rerun with PRISMA_CLI_MOCK_FIXTURE_PATH to exercise the documented MVP environment model.", ["prisma app deploy --app <name>"], "env");
+}
+//#endregion
+export { runEnvList, runEnvShow, runEnvUse };

package/dist/controllers/project.js

@@ -0,0 +1,214 @@
+import { UnsafeConfigWriteError, readLinkedProjectId, writeLinkedProjectId } from "../adapters/config.js";
+import { CliError, authRequiredError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { createProjectUseCases, projectNotFoundError } from "../use-cases/project.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createAuthUseCases } from "../use-cases/auth.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { readAuthState } from "../lib/auth/auth-ops.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+//#region src/controllers/project.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runProjectList(context) {
+	if (isRealMode(context)) {
+		const authState = await requireAuthenticatedAuthState(context);
+		const client = await requireComputeAuth(context.runtime.env);
+		const workspace = authState.workspace;
+		if (!client || !workspace) throw authRequiredError();
+		const { data: projectsData } = await client.GET("/v1/projects", {});
+		return {
+			command: "project.list",
+			result: {
+				workspace,
+				linkedProjectId: await readLinkedProjectId(context.runtime.cwd),
+				projects: (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+					id: project.id,
+					name: project.name
+				})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id))
+			},
+			warnings: [],
+			nextSteps: ["prisma project link"]
+		};
+	}
+	const authState = await requireAuthenticatedAuthState(context);
+	return {
+		command: "project.list",
+		result: await createProjectUseCases(createCliUseCaseGateways(context)).list(authState),
+		warnings: [],
+		nextSteps: ["prisma project link"]
+	};
+}
+async function runProjectShow(context) {
+	if (isRealMode(context)) {
+		const linkedProjectId = await readLinkedProjectId(context.runtime.cwd);
+		if (!linkedProjectId) return {
+			command: "project.show",
+			result: {
+				linkedProjectId: null,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma project link"]
+		};
+		const authState = await readAuthState(context.runtime.env);
+		if (!authState.authenticated || !authState.workspace) return {
+			command: "project.show",
+			result: {
+				linkedProjectId,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma auth login"]
+		};
+		const client = await requireComputeAuth(context.runtime.env);
+		if (!client) return {
+			command: "project.show",
+			result: {
+				linkedProjectId,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma auth login"]
+		};
+		try {
+			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: linkedProjectId } } });
+			const project = data?.data;
+			if (!project || project.workspace.id !== authState.workspace.id) return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: null,
+					project: null
+				},
+				warnings: [],
+				nextSteps: []
+			};
+			return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: {
+						id: project.workspace.id,
+						name: project.workspace.name
+					},
+					project: {
+						id: project.id,
+						name: project.name
+					}
+				},
+				warnings: [],
+				nextSteps: []
+			};
+		} catch {
+			return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: null,
+					project: null
+				},
+				warnings: [],
+				nextSteps: []
+			};
+		}
+	}
+	const gateways = createCliUseCaseGateways(context);
+	const authUseCases = createAuthUseCases(gateways);
+	const projectUseCases = createProjectUseCases(gateways);
+	const authState = await authUseCases.whoami();
+	const result = await projectUseCases.show(authState);
+	return {
+		command: "project.show",
+		result,
+		warnings: [],
+		nextSteps: result.linkedProjectId ? authState.authenticated ? [] : ["prisma auth login"] : ["prisma project link"]
+	};
+}
+async function runProjectLink(context, projectId) {
+	if (!projectId && !canPrompt(context)) throw projectSelectionRequiredError();
+	if (isRealMode(context)) {
+		const authState = await requireAuthenticatedAuthState(context);
+		const client = await requireComputeAuth(context.runtime.env);
+		const workspace = authState.workspace;
+		if (!client || !workspace) throw authRequiredError();
+		let selectedProject;
+		if (projectId) try {
+			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: projectId } } });
+			if (!data?.data || data.data.workspace.id !== workspace.id) throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+			selectedProject = data.data;
+		} catch (error) {
+			if (error instanceof CliError) throw error;
+			throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+		}
+		else {
+			const { data: projectsData } = await client.GET("/v1/projects", {});
+			const projects = (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+				id: project.id,
+				name: project.name,
+				workspace: project.workspace
+			})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+			if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${workspace.name}".`, "Use prisma app deploy to create project context, or switch workspaces and try again.", []);
+			selectedProject = await createSelectPromptPort(context).select({
+				message: "Select a project",
+				choices: projects.map((project) => ({
+					label: `${project.name} (${project.id})`,
+					value: project
+				}))
+			});
+		}
+		try {
+			await writeLinkedProjectId(context.runtime.cwd, selectedProject.id);
+		} catch (error) {
+			if (error instanceof UnsafeConfigWriteError) throw usageError("Project link requires a writable Prisma config", error.message, "Update prisma.config.ts to use a recognizable project field, or remove it and rerun prisma project link.", ["prisma project link proj_123"], "project");
+			throw error;
+		}
+		return {
+			command: "project.link",
+			result: {
+				linkedProjectId: selectedProject.id,
+				workspace: {
+					id: selectedProject.workspace.id,
+					name: selectedProject.workspace.name
+				},
+				project: {
+					id: selectedProject.id,
+					name: selectedProject.name
+				}
+			},
+			warnings: [],
+			nextSteps: ["prisma project show", "prisma app deploy"]
+		};
+	}
+	const projectUseCases = createProjectUseCases(createCliUseCaseGateways(context));
+	const authState = await requireAuthenticatedAuthState(context);
+	const resolvedProjectId = projectId ?? await resolveProjectIdForLink(context, authState, projectUseCases);
+	return {
+		command: "project.link",
+		result: await projectUseCases.link(authState, resolvedProjectId),
+		warnings: [],
+		nextSteps: ["prisma project show", "prisma app deploy"]
+	};
+}
+async function resolveProjectIdForLink(context, authState, projectUseCases) {
+	if (!authState.workspace) throw projectSelectionRequiredError();
+	const projects = await projectUseCases.listProjectsForWorkspace(authState.workspace.id);
+	if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${authState.workspace.name}".`, "Use prisma app deploy to create project context, or switch workspaces and try again.", []);
+	return (await createSelectPromptPort(context).select({
+		message: "Select a project",
+		choices: projects.map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	})).id;
+}
+function projectSelectionRequiredError() {
+	return usageError("Project link requires a project target in non-interactive mode", "This command cannot prompt for project selection in the current mode.", "Re-run prisma project link in a TTY, or pass a project id explicitly.", ["prisma project list"], "project");
+}
+//#endregion
+export { runProjectLink, runProjectList, runProjectShow };

package/dist/controllers/select-prompt-port.js

@@ -0,0 +1,12 @@
+import { selectPrompt } from "../shell/prompt.js";
+//#region src/controllers/select-prompt-port.ts
+function createSelectPromptPort(context) {
+	return { select: ({ message, choices }) => selectPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		message,
+		choices
+	}) };
+}
+//#endregion
+export { createSelectPromptPort };

package/dist/lib/app/local-dev.js

@@ -0,0 +1,178 @@
+import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+//#region src/lib/app/local-dev.ts
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+const DEFAULT_LOCAL_DEV_PORT = 3e3;
+async function resolveLocalBuildType(appPath, buildType) {
+	if (buildType === "bun" || buildType === "nextjs") return buildType;
+	return detectLocalBuildType(appPath);
+}
+async function detectLocalBuildType(appPath) {
+	if (await isNextProject(appPath)) return "nextjs";
+	if (await isBunProject(appPath)) return "bun";
+	return null;
+}
+async function resolveBunEntrypoint(appPath, explicitEntrypoint) {
+	const packageJson = await readPackageJson(appPath);
+	const candidate = explicitEntrypoint ?? (typeof packageJson?.main === "string" ? packageJson.main : void 0);
+	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main.");
+	if (path.isAbsolute(candidate)) throw new Error("Entrypoint must be a relative path.");
+	const normalized = path.normalize(candidate);
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized.includes(`${path.sep}..${path.sep}`)) throw new Error("Entrypoint must not escape the app directory.");
+	const entrypointPath = path.join(appPath, normalized);
+	try {
+		await access(entrypointPath);
+	} catch {
+		throw new Error(`Entrypoint file does not exist: ${entrypointPath}`);
+	}
+	return normalized.split(path.sep).join("/");
+}
+async function runLocalApp(options) {
+	const spawnImpl = options.spawnImpl ?? spawn;
+	if (options.buildType === "nextjs") {
+		const command = await runWithFallback([
+			{
+				command: path.join(options.appPath, "node_modules", ".bin", process.platform === "win32" ? "next.cmd" : "next"),
+				args: [
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			},
+			{
+				command: "npx",
+				args: [
+					"next",
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			},
+			{
+				command: "bunx",
+				args: [
+					"next",
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			}
+		], {
+			cwd: options.appPath,
+			env: {
+				...options.env,
+				PORT: String(options.port)
+			}
+		}, spawnImpl, "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
+		return {
+			framework: "nextjs",
+			entrypoint: null,
+			port: options.port,
+			command: command.display,
+			exitCode: command.exitCode,
+			signal: command.signal
+		};
+	}
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+	const command = await runWithFallback([{
+		command: "bun",
+		args: ["--watch", entrypoint],
+		display: `bun --watch ${entrypoint}`
+	}], {
+		cwd: options.appPath,
+		env: {
+			...options.env,
+			PORT: String(options.port)
+		}
+	}, spawnImpl, "Bun is required to run this app locally. Install it from https://bun.sh.");
+	return {
+		framework: "bun",
+		entrypoint,
+		port: options.port,
+		command: command.display,
+		exitCode: command.exitCode,
+		signal: command.signal
+	};
+}
+async function isNextProject(appPath) {
+	for (const fileName of NEXT_CONFIG_FILENAMES) try {
+		await access(path.join(appPath, fileName));
+		return true;
+	} catch {}
+	return hasDependency(await readPackageJson(appPath), "next");
+}
+async function isBunProject(appPath) {
+	try {
+		await access(path.join(appPath, "bun.lock"));
+		return true;
+	} catch {}
+	try {
+		await access(path.join(appPath, "bun.lockb"));
+		return true;
+	} catch {}
+	const packageJson = await readPackageJson(appPath);
+	if (!packageJson) return false;
+	const hasMain = typeof packageJson.main === "string";
+	const hasBunDependency = hasDependency(packageJson, "@types/bun") || hasDependency(packageJson, "bun");
+	const usesBunScripts = (typeof packageJson.scripts === "object" && packageJson.scripts !== null ? Object.values(packageJson.scripts) : []).some((value) => typeof value === "string" && /\bbun\b/.test(value));
+	return hasMain && (hasBunDependency || usesBunScripts);
+}
+function hasDependency(packageJson, dependencyName) {
+	if (!packageJson) return false;
+	return [packageJson.dependencies, packageJson.devDependencies].some((group) => typeof group === "object" && group !== null && dependencyName in group);
+}
+async function readPackageJson(appPath) {
+	const packageJsonPath = path.join(appPath, "package.json");
+	let content;
+	try {
+		content = await readFile(packageJsonPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw new Error(`Failed to read ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(`Failed to parse ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function runWithFallback(candidates, options, spawnImpl, missingCommandMessage) {
+	for (const candidate of candidates) try {
+		const result = await spawnCommand(candidate, options, spawnImpl);
+		return {
+			display: candidate.display,
+			exitCode: result.exitCode,
+			signal: result.signal
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") continue;
+		throw error;
+	}
+	throw new Error(missingCommandMessage);
+}
+function spawnCommand(candidate, options, spawnImpl) {
+	return new Promise((resolve, reject) => {
+		const child = spawnImpl(candidate.command, candidate.args, {
+			...options,
+			stdio: "inherit"
+		});
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			resolve({
+				exitCode: code ?? 1,
+				signal
+			});
+		});
+	});
+}
+//#endregion
+export { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp };