@looma/prisma-cli 0.1.1 → 0.1.3

package/README.md

@@ -15,6 +15,23 @@ pnpm prisma-cli auth login
 pnpm prisma-cli app deploy
 ```
 
+Minimal Bun smoke flow:
+
+```bash
+mkdir my-bun-app
+cd my-bun-app
+bun init --yes
+pnpm add -D @looma/prisma-cli
+```
+
+Then replace `index.ts` with a small `Bun.serve(...)` server and run:
+
+```bash
+pnpm prisma-cli app build
+pnpm prisma-cli auth login
+pnpm prisma-cli app deploy --app my-bun-app
+```
+
 Notes:
 
 - the official Prisma ORM package still owns the `prisma` executable

package/dist/controllers/app.js

@@ -591,6 +591,7 @@ function deployFailedError(summary, error, nextSteps) {
 		summary,
 		why: error instanceof Error ? error.message : String(error),
 		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		debug: formatDebugDetails(error),
 		exitCode: 1,
 		nextSteps
 	});
@@ -613,6 +614,7 @@ function buildFailedError(summary, error) {
 		summary,
 		why: error instanceof Error ? error.message : String(error),
 		fix: "Inspect the framework output, fix the build issue, and rerun prisma app build.",
+		debug: formatDebugDetails(error),
 		exitCode: 1,
 		nextSteps: ["prisma app build", "prisma app deploy"]
 	});
@@ -638,6 +640,7 @@ function removeFailedError(summary, error, nextSteps) {
 		summary,
 		why: error instanceof Error ? error.message : String(error),
 		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		debug: formatDebugDetails(error),
 		exitCode: 1,
 		nextSteps
 	});
@@ -645,6 +648,10 @@ function removeFailedError(summary, error, nextSteps) {
 function localStateCleanupWarning(target, error) {
 	return `The app was removed remotely, but the local ${target} state could not be cleared: ${error instanceof Error ? error.message : String(error)}`;
 }
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
 function isMissingProjectError(error) {
 	return error instanceof Error && error.message === "Resource Not Found";
 }

package/dist/lib/app/bun-project.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+//#region src/lib/app/bun-project.ts
+async function readBunPackageJson(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)}`);
+	}
+}
+function readBunPackageEntrypoint(packageJson) {
+	if (typeof packageJson?.main === "string") return packageJson.main;
+	if (typeof packageJson?.module === "string") return packageJson.module;
+}
+async function resolveBunEntrypoint(appPath, explicitEntrypoint) {
+	const packageJson = await readBunPackageJson(appPath);
+	const candidate = explicitEntrypoint ?? readBunPackageEntrypoint(packageJson);
+	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main or module.");
+	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("/");
+}
+//#endregion
+export { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint };

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

@@ -1,5 +1,6 @@
+import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
 import path from "node:path";
-import { access, readFile } from "node:fs/promises";
+import { access } from "node:fs/promises";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
 const NEXT_CONFIG_FILENAMES = [
@@ -18,21 +19,6 @@ async function detectLocalBuildType(appPath) {
 	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") {
@@ -108,7 +94,7 @@ async function isNextProject(appPath) {
 		await access(path.join(appPath, fileName));
 		return true;
 	} catch {}
-	return hasDependency(await readPackageJson(appPath), "next");
+	return hasDependency(await readBunPackageJson(appPath), "next");
 }
 async function isBunProject(appPath) {
 	try {
@@ -119,32 +105,17 @@ async function isBunProject(appPath) {
 		await access(path.join(appPath, "bun.lockb"));
 		return true;
 	} catch {}
-	const packageJson = await readPackageJson(appPath);
+	const packageJson = await readBunPackageJson(appPath);
 	if (!packageJson) return false;
-	const hasMain = typeof packageJson.main === "string";
+	const hasEntrypoint = typeof readBunPackageEntrypoint(packageJson) === "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);
+	return hasEntrypoint && (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);

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

@@ -1,7 +1,16 @@
+import { resolveBunEntrypoint } from "./bun-project.js";
 import path from "node:path";
-import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
-import { BunBuild, NextjsBuild } from "@prisma/compute-sdk";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { BunBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/prototype-build.ts
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
 var PrototypeBuildStrategy = class {
 	#appPath;
 	#entrypoint;
@@ -49,28 +58,132 @@ async function executePrototypeBuild(options) {
 async function resolvePrototypeBuildStrategy(options) {
 	if (options.buildType === "nextjs") return {
 		buildType: "nextjs",
-		strategy: new NextjsBuild({ appPath: options.appPath })
+		strategy: new PrototypeNextjsBuild({ 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 (options.buildType === "bun") {
+		const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+		return {
+			buildType: "bun",
+			strategy: new BunBuild({
+				appPath: options.appPath,
+				entrypoint
+			})
+		};
+	}
+	const nextjsStrategy = new PrototypeNextjsBuild({ appPath: options.appPath });
 	if (await nextjsStrategy.canBuild()) return {
 		buildType: "nextjs",
 		strategy: nextjsStrategy
 	};
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
 	return {
 		buildType: "bun",
 		strategy: new BunBuild({
 			appPath: options.appPath,
-			entrypoint: options.entrypoint
+			entrypoint
 		})
 	};
 }
+var PrototypeNextjsBuild = class {
+	#appPath;
+	constructor(options) {
+		this.#appPath = options.appPath;
+	}
+	async canBuild() {
+		return await this.#hasNextConfig() || await this.#hasNextDependency();
+	}
+	async execute() {
+		await this.#runBuild();
+		const standaloneDir = path.join(this.#appPath, ".next", "standalone");
+		if (!(await stat(standaloneDir).catch(() => null))?.isDirectory()) throw new Error("Next.js build did not produce standalone output. Add output: \"standalone\" to your next.config file.");
+		const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await stageNextjsStandaloneArtifact({
+				standaloneDir,
+				artifactDir,
+				appPath: this.#appPath
+			});
+			const publicDir = path.join(this.#appPath, "public");
+			if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), { recursive: true });
+			const staticDir = path.join(this.#appPath, ".next", "static");
+			if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), { recursive: true });
+			return {
+				directory: artifactDir,
+				entrypoint: "server.js",
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+	async #hasNextConfig() {
+		let entries;
+		try {
+			entries = await readdir(this.#appPath);
+		} catch {
+			return false;
+		}
+		return entries.some((entry) => NEXT_CONFIG_FILENAMES.includes(entry));
+	}
+	async #hasNextDependency() {
+		const packageJsonPath = path.join(this.#appPath, "package.json");
+		let content;
+		try {
+			content = await readFile(packageJsonPath, "utf8");
+		} catch {
+			return false;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch {
+			return false;
+		}
+		const deps = isRecord(parsed.dependencies) ? parsed.dependencies : {};
+		const devDeps = isRecord(parsed.devDependencies) ? parsed.devDependencies : {};
+		return "next" in deps || "next" in devDeps;
+	}
+	async #runBuild() {
+		const candidates = [
+			{
+				command: path.join(this.#appPath, "node_modules", ".bin", "next"),
+				args: ["build"]
+			},
+			{
+				command: "npx",
+				args: ["next", "build"]
+			},
+			{
+				command: "bunx",
+				args: ["next", "build"]
+			}
+		];
+		for (const { command, args } of candidates) try {
+			await exec(command, args, this.#appPath);
+			return;
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
+			throw error;
+		}
+		throw new Error("Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
+	}
+};
+async function stageNextjsStandaloneArtifact(options) {
+	const standaloneRoot = path.resolve(options.standaloneDir);
+	await copyPathMaterializingSymlinks(standaloneRoot, path.resolve(options.artifactDir), {
+		standaloneRoot,
+		appRoot: path.resolve(options.appPath)
+	});
+}
 async function normalizeArtifactSymlinks(artifactDir, appPath) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
@@ -105,5 +218,66 @@ function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
 }
+async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
+	const sourceStat = await lstat(sourcePath);
+	if (sourceStat.isSymbolicLink()) {
+		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		return;
+	}
+	if (sourceStat.isDirectory()) {
+		await mkdir(destinationPath, { recursive: true });
+		const entries = await readdir(sourcePath, { withFileTypes: true });
+		for (const entry of entries) await copyPathMaterializingSymlinks(path.join(sourcePath, entry.name), path.join(destinationPath, entry.name), options);
+		return;
+	}
+	if (sourceStat.isFile()) {
+		await mkdir(path.dirname(destinationPath), { recursive: true });
+		await copyFile(sourcePath, destinationPath);
+		await chmod(destinationPath, sourceStat.mode);
+	}
+}
+async function resolveSymlinkTarget(symlinkPath, options) {
+	const linkTarget = await readlink(symlinkPath);
+	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
+	if (await pathExists(resolvedTarget)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+		return resolvedTarget;
+	}
+	if (isPathWithin(options.standaloneRoot, resolvedTarget)) {
+		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
+		if (await pathExists(fallbackTarget)) return fallbackTarget;
+	}
+	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
+}
+async function directoryExists(dirPath) {
+	return (await stat(dirPath).catch(() => null))?.isDirectory() ?? false;
+}
+function exec(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		execFile(command, args, { cwd }, (error, _stdout, stderr) => {
+			if (error) {
+				if ("code" in error && error.code === "ENOENT") {
+					reject(Object.assign(/* @__PURE__ */ new Error(`${command} not found`), { code: "ENOENT" }));
+					return;
+				}
+				const message = stderr.trim() || error.message;
+				reject(/* @__PURE__ */ new Error(`Next.js build failed:\n${message}`));
+				return;
+			}
+			resolve();
+		});
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+async function pathExists(targetPath) {
+	try {
+		await stat(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
 //#endregion
 export { PrototypeBuildStrategy, executePrototypeBuild };

package/dist/shell/errors.js

@@ -6,6 +6,7 @@ var CliError = class extends Error {
 	summary;
 	why;
 	fix;
+	debug;
 	where;
 	meta;
 	docsUrl;
@@ -20,6 +21,7 @@ var CliError = class extends Error {
 		this.summary = options.summary;
 		this.why = options.why;
 		this.fix = options.fix;
+		this.debug = options.debug ?? null;
 		this.where = options.where ?? null;
 		this.meta = options.meta ?? {};
 		this.docsUrl = options.docsUrl ?? null;

package/dist/shell/output.js

@@ -37,7 +37,13 @@ function writeHumanError(output, ui, error, options) {
 		lines.push(`Why: ${error.why}`);
 	}
 	if (error.fix) lines.push(`Fix: ${error.fix}`);
-	if (!options.trace) {
+	if (options.trace) {
+		if (error.debug) {
+			lines.push("");
+			lines.push("Trace:");
+			lines.push(...error.debug.trimEnd().split("\n"));
+		}
+	} else {
 		lines.push("");
 		lines.push("More: Re-run with --trace for deeper diagnostics");
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looma/prisma-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Prototype Prisma Compute CLI.",
   "type": "module",
   "bin": {