@looma/prisma-cli 0.1.1

package/dist/lib/app/prototype-build.js

@@ -0,0 +1,109 @@
+import path from "node:path";
+import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
+import { BunBuild, NextjsBuild } from "@prisma/compute-sdk";
+//#region src/lib/app/prototype-build.ts
+var PrototypeBuildStrategy = class {
+	#appPath;
+	#entrypoint;
+	#buildType;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#entrypoint = options.entrypoint;
+		this.#buildType = options.buildType ?? "auto";
+	}
+	async canBuild() {
+		const { strategy } = await resolvePrototypeBuildStrategy({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return strategy.canBuild();
+	}
+	async execute() {
+		const { artifact } = await executePrototypeBuild({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return artifact;
+	}
+};
+async function executePrototypeBuild(options) {
+	const { strategy, buildType } = await resolvePrototypeBuildStrategy({
+		appPath: options.appPath,
+		entrypoint: options.entrypoint,
+		buildType: options.buildType ?? "auto"
+	});
+	const artifact = await strategy.execute();
+	try {
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
+		return {
+			artifact,
+			buildType
+		};
+	} catch (error) {
+		await artifact.cleanup?.().catch(() => void 0);
+		throw error;
+	}
+}
+async function resolvePrototypeBuildStrategy(options) {
+	if (options.buildType === "nextjs") return {
+		buildType: "nextjs",
+		strategy: new NextjsBuild({ appPath: options.appPath })
+	};
+	if (options.buildType === "bun") return {
+		buildType: "bun",
+		strategy: new BunBuild({
+			appPath: options.appPath,
+			entrypoint: options.entrypoint
+		})
+	};
+	const nextjsStrategy = new NextjsBuild({ appPath: options.appPath });
+	if (await nextjsStrategy.canBuild()) return {
+		buildType: "nextjs",
+		strategy: nextjsStrategy
+	};
+	return {
+		buildType: "bun",
+		strategy: new BunBuild({
+			appPath: options.appPath,
+			entrypoint: options.entrypoint
+		})
+	};
+}
+async function normalizeArtifactSymlinks(artifactDir, appPath) {
+	const normalizedArtifactDir = path.resolve(artifactDir);
+	const normalizedAppPath = path.resolve(appPath);
+	await walkDirectory(normalizedArtifactDir);
+	async function walkDirectory(directory) {
+		const entries = await readdir(directory, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await walkDirectory(fullPath);
+				continue;
+			}
+			if (!entry.isSymbolicLink()) continue;
+			const target = await readlink(fullPath);
+			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
+			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
+			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+			const targetStat = await stat(resolvedTarget);
+			await rm(fullPath, {
+				force: true,
+				recursive: true
+			});
+			await cp(resolvedTarget, fullPath, {
+				recursive: targetStat.isDirectory(),
+				dereference: true
+			});
+			if (targetStat.isDirectory()) await walkDirectory(fullPath);
+		}
+	}
+}
+function isPathWithin(rootPath, candidatePath) {
+	const relativePath = path.relative(rootPath, candidatePath);
+	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+//#endregion
+export { PrototypeBuildStrategy, executePrototypeBuild };

package/dist/lib/app/prototype-interaction.js

@@ -0,0 +1,38 @@
+import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+//#region src/lib/app/prototype-interaction.ts
+const CREATE_NEW_APP = "__create_new_app__";
+const PROTOTYPE_DEFAULT_REGION = "eu-central-1";
+function createPrototypeDeployInteraction(context) {
+	return {
+		async selectService(services) {
+			const sorted = services.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+			const selection = await selectPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "Select an app",
+				choices: [...sorted.map((service) => ({
+					label: service.name,
+					value: service.id
+				})), {
+					label: "Create a new app",
+					value: CREATE_NEW_APP
+				}]
+			});
+			return selection === CREATE_NEW_APP ? null : selection;
+		},
+		async provideServiceName() {
+			return textPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "App name",
+				placeholder: "hello-world",
+				validate: (value) => !value?.trim() ? "App name is required" : void 0
+			}).then((value) => value.trim());
+		},
+		async selectRegion(_regions) {
+			return PROTOTYPE_DEFAULT_REGION;
+		}
+	};
+}
+//#endregion
+export { PROTOTYPE_DEFAULT_REGION, createPrototypeDeployInteraction };

package/dist/lib/app/prototype-progress.js

@@ -0,0 +1,115 @@
+//#region src/lib/app/prototype-progress.ts
+function createPrototypeDeployProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onBuildStart() {
+			write("Building application...");
+		},
+		onBuildComplete() {
+			write("Build complete.");
+		},
+		onArchiveCreating() {
+			write("Creating deployment artifact...");
+		},
+		onArchiveReady(byteLength) {
+			write(`Artifact ready (${(byteLength / 1024).toFixed(1)} KB).`);
+		},
+		onVersionCreated(versionId) {
+			write(`Deployment ${versionId} created.`);
+		},
+		onUploadComplete() {
+			write("Upload complete.");
+		},
+		onStartRequested() {
+			write("Starting deployment...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onRunning(url) {
+			if (url) {
+				write(`Deployment is running at ${url}.`);
+				return;
+			}
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		},
+		onOldVersionStopping(versionId) {
+			write(`Stopping previous deployment ${versionId}...`);
+		},
+		onOldVersionStopped(versionId) {
+			write(`Previous deployment ${versionId} stopped.`);
+		},
+		onOldVersionStopFailed(versionId) {
+			write(`Failed to stop previous deployment ${versionId} (non-fatal).`);
+		},
+		onOldVersionDeleting(versionId) {
+			write(`Deleting previous deployment ${versionId}...`);
+		},
+		onOldVersionDeleted(versionId) {
+			write(`Previous deployment ${versionId} deleted.`);
+		},
+		onOldVersionDeleteFailed(versionId) {
+			write(`Failed to delete previous deployment ${versionId} (non-fatal).`);
+		},
+		onCleanupDanglingVersion(versionId) {
+			write(`Cleaning up deployment ${versionId}...`);
+		},
+		onCleanupDanglingVersionComplete(versionId) {
+			write(`Deployment ${versionId} cleaned up.`);
+		},
+		onCleanupDanglingVersionFailed(versionId) {
+			write(`Failed to clean up deployment ${versionId}.`);
+		}
+	};
+}
+function createPrototypePromoteProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onVersionStarting(versionId) {
+			write(`Starting deployment ${versionId}...`);
+		},
+		onVersionStartRequested() {
+			write("Requesting deployment start...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onVersionRunning() {
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		}
+	};
+}
+//#endregion
+export { createPrototypeDeployProgress, createPrototypePromoteProgress };

package/dist/lib/app/prototype-provider.js

@@ -0,0 +1,163 @@
+import { PrototypeBuildStrategy } from "./prototype-build.js";
+import path from "node:path";
+import { ApiError, ComputeClient } from "@prisma/compute-sdk";
+//#region src/lib/app/prototype-provider.ts
+function createPrototypeAppProvider(client) {
+	const sdk = new ComputeClient(client);
+	return {
+		async createProject(options) {
+			const projectResult = await sdk.createProject({ name: options.name });
+			if (projectResult.isErr()) throw new Error(projectResult.error.message);
+			return {
+				id: projectResult.value.id,
+				name: projectResult.value.name
+			};
+		},
+		async listApps(projectId) {
+			const servicesResult = await sdk.listServices({ projectId });
+			if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+			return (await Promise.all(servicesResult.value.map(async (service) => {
+				const detailResult = await sdk.showService({ serviceId: service.id });
+				return detailResult.isOk() ? detailResult.value : {
+					id: service.id,
+					name: service.name,
+					region: service.region,
+					latestVersionId: null,
+					serviceEndpointDomain: void 0
+				};
+			}))).map((service) => ({
+				id: service.id,
+				name: service.name,
+				region: service.region ?? null,
+				liveDeploymentId: service.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
+			}));
+		},
+		async removeApp(appId) {
+			const appResult = await sdk.showService({ serviceId: appId });
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			const destroyResult = await sdk.destroyService({
+				serviceId: appId,
+				keepService: false,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3
+			});
+			if (destroyResult.isErr()) throw new Error(destroyResult.error.message);
+			return {
+				id: appResult.value.id,
+				name: appResult.value.name
+			};
+		},
+		async promoteDeployment(options) {
+			const promoteResult = await sdk.promote({
+				serviceId: options.appId,
+				versionId: options.deploymentId,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.progress
+			});
+			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
+		},
+		async deployApp(options) {
+			const deployResult = await sdk.deploy({
+				strategy: new PrototypeBuildStrategy({ appPath: path.resolve(options.cwd) }),
+				projectId: options.projectId,
+				serviceId: options.appId,
+				serviceName: options.appName,
+				region: options.region,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				interaction: options.interaction,
+				progress: options.progress
+			});
+			if (deployResult.isErr()) throw new Error(deployResult.error.message);
+			const deployed = deployResult.value;
+			return {
+				projectId: deployed.projectId,
+				app: {
+					id: deployed.serviceId,
+					name: deployed.serviceName,
+					region: deployed.region ?? null,
+					liveDeploymentId: deployed.versionId,
+					liveUrl: toAbsoluteUrl(deployed.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: deployed.versionId,
+					status: "running",
+					url: toAbsoluteUrl(deployed.serviceEndpointDomain ?? deployed.versionEndpointDomain ?? null)
+				}
+			};
+		},
+		async listDeployments(appId) {
+			const [appResult, versionsResult] = await Promise.all([sdk.showService({ serviceId: appId }), sdk.listVersions({ serviceId: appId })]);
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			return {
+				app: {
+					id: appResult.value.id,
+					name: appResult.value.name,
+					region: appResult.value.region ?? null,
+					liveDeploymentId: appResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(appResult.value.serviceEndpointDomain ?? null)
+				},
+				deployments: versionsResult.value.slice().sort((left, right) => {
+					const byDate = right.createdAt.localeCompare(left.createdAt);
+					return byDate !== 0 ? byDate : right.id.localeCompare(left.id);
+				}).map((deployment) => ({
+					id: deployment.id,
+					status: deployment.status,
+					createdAt: deployment.createdAt,
+					url: toAbsoluteUrl(deployment.previewDomain ?? null),
+					live: null
+				}))
+			};
+		},
+		async showDeployment(deploymentId) {
+			const deploymentResult = await sdk.showVersion({ versionId: deploymentId });
+			if (deploymentResult.isErr()) {
+				if (ApiError.is(deploymentResult.error) && deploymentResult.error.statusCode === 404) return null;
+				throw new Error(deploymentResult.error.message);
+			}
+			return {
+				app: await findAppForDeployment(sdk, deploymentId),
+				deployment: {
+					id: deploymentResult.value.id,
+					status: deploymentResult.value.status,
+					createdAt: deploymentResult.value.createdAt,
+					url: toAbsoluteUrl(deploymentResult.value.previewDomain ?? null),
+					live: null
+				}
+			};
+		}
+	};
+}
+async function findAppForDeployment(sdk, deploymentId) {
+	const projectsResult = await sdk.listProjects();
+	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
+	for (const project of projectsResult.value) {
+		const servicesResult = await sdk.listServices({ projectId: project.id });
+		if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+		for (const service of servicesResult.value) {
+			const detailResult = await sdk.showService({ serviceId: service.id });
+			if (detailResult.isErr()) throw new Error(detailResult.error.message);
+			const app = {
+				id: detailResult.value.id,
+				name: detailResult.value.name,
+				region: detailResult.value.region ?? null,
+				liveDeploymentId: detailResult.value.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(detailResult.value.serviceEndpointDomain ?? null)
+			};
+			if (app.liveDeploymentId === deploymentId) return app;
+			const versionsResult = await sdk.listVersions({ serviceId: service.id });
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			if (versionsResult.value.some((version) => version.id === deploymentId)) return app;
+		}
+	}
+	return null;
+}
+function toAbsoluteUrl(url) {
+	if (!url) return null;
+	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
+}
+//#endregion
+export { createPrototypeAppProvider };

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

@@ -0,0 +1,57 @@
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { requireComputeAuth } from "./guard.js";
+import { login } from "./login.js";
+//#region src/lib/auth/auth-ops.ts
+function decodeJwtPayload(token) {
+	try {
+		const payload = token.split(".")[1];
+		if (!payload) return {};
+		return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+	} catch {
+		return {};
+	}
+}
+async function performLogin(env) {
+	await login({
+		tokenStorage: new FileTokenStorage(env),
+		env
+	});
+}
+async function readAuthState(env) {
+	const tokens = await new FileTokenStorage(env).getTokens();
+	if (!tokens) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId: null
+	};
+	const claims = decodeJwtPayload(tokens.accessToken);
+	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;
+		if (data?.data?.name) workspaceName = data.data.name;
+	} catch {}
+	return {
+		authenticated: true,
+		provider: null,
+		user: {
+			id: claims.sub ?? "",
+			name: claims.name ?? "",
+			email: claims.email ?? ""
+		},
+		workspace: {
+			id: workspaceId,
+			name: workspaceName
+		},
+		linkedProjectId: null
+	};
+}
+async function performLogout(env) {
+	await new FileTokenStorage(env).clearTokens();
+}
+//#endregion
+export { performLogin, performLogout, readAuthState };

package/dist/lib/auth/client.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/auth/client.ts
+const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
+const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_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";
+}
+function getAuthFilePath(env = process.env) {
+	const configured = env[AUTH_FILE_ENV_VAR];
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "prisma", "auth.json");
+	if (process.platform === "win32") {
+		const appData = env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+		return path.join(appData, "prisma", "auth.json");
+	}
+	const xdgConfigHome = env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+	return path.join(xdgConfigHome, "prisma", "auth.json");
+}
+//#endregion
+export { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl, getAuthFilePath };

package/dist/lib/auth/guard.js

@@ -0,0 +1,34 @@
+import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "./client.js";
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { createManagementApiClient, createManagementApiSdk } from "@prisma/management-api-sdk";
+//#region src/lib/auth/guard.ts
+/**
+* Resolve authentication and return a ManagementApiClient.
+*
+* Priority:
+*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   2. Stored OAuth tokens     → SDK with auto-refresh
+*
+* Returns null if not authenticated.
+*/
+async function requireComputeAuth(env = process.env) {
+	const rawToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawToken !== void 0) {
+		const token = rawToken.trim();
+		if (token.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return createManagementApiClient({
+			baseUrl: getApiBaseUrl(env),
+			token
+		});
+	}
+	const tokenStorage = new FileTokenStorage(env);
+	if (!await tokenStorage.getTokens()) return null;
+	return createManagementApiSdk({
+		clientId: CLIENT_ID,
+		redirectUri: "http://localhost:0/auth/callback",
+		tokenStorage,
+		apiBaseUrl: getApiBaseUrl(env)
+	}).client;
+}
+//#endregion
+export { requireComputeAuth };

package/dist/lib/auth/login.js

@@ -0,0 +1,117 @@
+import { getApiBaseUrl } from "./client.js";
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import open from "open";
+import { AuthError, createManagementApiSdk } from "@prisma/management-api-sdk";
+import events from "node:events";
+import http from "node:http";
+//#region src/lib/auth/login.ts
+var AuthError$1 = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AuthError";
+	}
+};
+async function login(options = {}) {
+	const hostname = options.hostname ?? "localhost";
+	const port = options.port ?? 0;
+	const server = http.createServer();
+	server.listen({
+		host: hostname,
+		port
+	});
+	try {
+		const state = new LoginState({
+			hostname,
+			port: (await events.once(server, "listening").then(() => server.address())).port,
+			tokenStorage: options.tokenStorage,
+			clientId: options.clientId,
+			apiBaseUrl: options.apiBaseUrl,
+			authBaseUrl: options.authBaseUrl,
+			openUrl: options.openUrl,
+			env: options.env
+		});
+		const authResult = new Promise((resolve, reject) => {
+			server.on("request", async (req, res) => {
+				const url = new URL(`http://${state.host}${req.url}`);
+				if (url.pathname !== "/auth/callback") {
+					res.statusCode = 404;
+					res.end("Not found");
+					return;
+				}
+				try {
+					await state.handleCallback(url);
+				} catch (error) {
+					res.statusCode = 400;
+					const message = error instanceof Error ? error.message : String(error);
+					res.end(message);
+					reject(error);
+					return;
+				}
+				res.setHeader("Content-Type", "text/html");
+				res.end(`<html><body style="font-family:system-ui;max-width:400px;margin:80px auto;text-align:center"><h2>✓ Signed in</h2><p>You may now close this tab and return to the terminal.</p></body></html>`);
+				resolve();
+			});
+		});
+		await state.openLoginPage();
+		await authResult;
+	} finally {
+		if (server.listening) await new Promise((resolve) => server.close(() => resolve()));
+	}
+}
+var LoginState = class {
+	latestVerifier;
+	latestState;
+	sdk;
+	openUrl;
+	constructor(options) {
+		this.options = options;
+		const tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.sdk = createManagementApiSdk({
+			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
+			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
+			tokenStorage,
+			apiBaseUrl: options.apiBaseUrl ?? getApiBaseUrl(options.env),
+			authBaseUrl: options.authBaseUrl
+		});
+		this.openUrl = options.openUrl ?? open;
+	}
+	async openLoginPage() {
+		const { url, state, verifier } = await this.sdk.getLoginUrl({
+			scope: "workspace:admin offline_access",
+			additionalParams: {
+				utm_source: "prisma-cli",
+				utm_medium: "command-login",
+				utm_campaign: "prisma-cli"
+			}
+		});
+		this.latestState = state;
+		this.latestVerifier = verifier;
+		await this.openUrl(url);
+	}
+	async handleCallback(url) {
+		if (url.pathname !== "/auth/callback") throw new AuthError$1("Not a callback URL");
+		const params = url.searchParams;
+		const error = params.get("error");
+		if (error) {
+			const desc = params.get("error_description");
+			throw new AuthError$1(desc ? `${error}: ${desc}` : error);
+		}
+		if (!this.latestVerifier) throw new AuthError$1("No verifier found");
+		if (!this.latestState) throw new AuthError$1("No state found");
+		try {
+			await this.sdk.handleCallback({
+				callbackUrl: url,
+				verifier: this.latestVerifier,
+				expectedState: this.latestState
+			});
+		} catch (error) {
+			if (error instanceof AuthError) throw new AuthError$1(error.message);
+			throw new AuthError$1(error instanceof Error ? error.message : "Unknown error during login");
+		}
+	}
+	get host() {
+		return `${this.options.hostname}:${this.options.port}`;
+	}
+};
+//#endregion
+export { login };