@looma/prisma-cli 0.1.1 → 0.1.2

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/prototype-build.js

@@ -1,7 +1,15 @@
 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,7 +57,7 @@ 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",
@@ -58,7 +66,7 @@ async function resolvePrototypeBuildStrategy(options) {
 			entrypoint: options.entrypoint
 		})
 	};
-	const nextjsStrategy = new NextjsBuild({ appPath: options.appPath });
+	const nextjsStrategy = new PrototypeNextjsBuild({ appPath: options.appPath });
 	if (await nextjsStrategy.canBuild()) return {
 		buildType: "nextjs",
 		strategy: nextjsStrategy
@@ -71,6 +79,106 @@ async function resolvePrototypeBuildStrategy(options) {
 		})
 	};
 }
+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 +213,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.2",
   "description": "Prototype Prisma Compute CLI.",
   "type": "module",
   "bin": {