@prisma/cli 3.0.0-dev.105.1 → 3.0.0-dev.108.1

package/dist/cli2.js

@@ -9,6 +9,7 @@ import "./shell/prompt.js";
 import { createAppCommand } from "./commands/app/index.js";
 import { createAuthCommand } from "./commands/auth/index.js";
 import { createBranchCommand } from "./commands/branch/index.js";
+import { createBuildCommand } from "./commands/build/index.js";
 import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
@@ -52,6 +53,7 @@ function createProgram(runtime) {
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createBuildCommand(runtime));
 	program.addCommand(createDatabaseCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;

package/dist/commands/build/index.js

@@ -0,0 +1,29 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runStreamingCommand } from "../../shell/command-runner.js";
+import { runBuildLogs } from "../../controllers/build.js";
+import { Command, Option } from "commander";
+//#region src/commands/build/index.ts
+function createBuildCommand(runtime) {
+	const build = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "build");
+	addCompactGlobalFlags(build);
+	build.addCommand(createLogsCommand(runtime));
+	return build;
+}
+function createLogsCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "build.logs");
+	command.argument("<buildId>", "Build id from a git-push or Console deploy").addOption(new Option("--follow", "Keep the connection open and stream new logs as the build runs")).addOption(new Option("--cursor <cursor>", "Resume from a prior terminal cursor"));
+	addGlobalFlags(command);
+	command.action(async (buildId, options) => {
+		const follow = options.follow;
+		const cursor = options.cursor;
+		await runStreamingCommand(runtime, "build.logs", options, (context) => runBuildLogs(context, buildId, {
+			follow,
+			cursor
+		}), { emitJsonSuccessEvent: false });
+	});
+	return command;
+}
+//#endregion
+export { createBuildCommand };

package/dist/controllers/app.js

@@ -1088,7 +1088,7 @@ function toAppDomainSummary(domain) {
 		type: domain.type,
 		url: domain.url,
 		hostname: domain.hostname,
-		computeServiceId: domain.computeServiceId,
+		appId: domain.appId,
 		status: domain.status,
 		foundryStatus: domain.foundryStatus,
 		failureReason: domain.failureReason,

package/dist/controllers/build.js

@@ -0,0 +1,88 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+import { writeJsonEvent } from "../shell/output.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+//#region src/controllers/build.ts
+async function runBuildLogs(context, buildId, options = {}) {
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write(`build logs → Streaming logs for build ${buildId}\n\n`);
+	const { data, response } = await client.GET("/v1/builds/{buildId}/logs", {
+		params: {
+			path: { buildId },
+			query: {
+				...options.follow ? { follow: "true" } : {},
+				...options.cursor ? { cursor: options.cursor } : {}
+			}
+		},
+		parseAs: "stream",
+		signal: context.runtime.signal
+	});
+	const body = data;
+	if (!response.ok || !body) throw buildLogsRequestError(buildId, response.status);
+	let sawError = false;
+	await forEachNdjsonRecord(body, (record) => {
+		if (record.type === "terminal" && record.kind === "error") sawError = true;
+		writeBuildLogRecord(context, record);
+	});
+	if (sawError) process.exitCode = 1;
+}
+function writeBuildLogRecord(context, record) {
+	if (context.flags.json) {
+		writeJsonEvent(context.output, {
+			type: record.type,
+			command: "build.logs",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			data: record
+		});
+		return;
+	}
+	if (record.type === "log") {
+		const stream = record.source === "stderr" || record.level === "error" ? context.output.stderr : context.output.stdout;
+		stream.write(record.text);
+		if (!record.text.endsWith("\n")) stream.write("\n");
+		return;
+	}
+	if (record.code !== "end") context.output.stderr.write(`${record.message}\n`);
+}
+/** Reads a newline-delimited JSON body line by line, parsing each into a record. */
+async function forEachNdjsonRecord(body, onRecord) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (value) buffer += decoder.decode(value, { stream: true });
+		let newlineIndex = buffer.indexOf("\n");
+		while (newlineIndex !== -1) {
+			const line = buffer.slice(0, newlineIndex).trim();
+			buffer = buffer.slice(newlineIndex + 1);
+			if (line) onRecord(JSON.parse(line));
+			newlineIndex = buffer.indexOf("\n");
+		}
+		if (done) {
+			const tail = buffer.trim();
+			if (tail) onRecord(JSON.parse(tail));
+			return;
+		}
+	}
+}
+function buildLogsRequestError(buildId, status) {
+	if (status === 404) return new CliError({
+		code: "BUILD_NOT_FOUND",
+		domain: "app",
+		summary: `Build ${buildId} was not found`,
+		why: "The build does not exist, or your workspace does not have access to it.",
+		fix: "Check the build id, or run prisma-cli auth login to switch to the workspace that owns it.",
+		exitCode: 1
+	});
+	return new CliError({
+		code: "BUILD_LOGS_FAILED",
+		domain: "app",
+		summary: `Failed to read logs for build ${buildId}`,
+		why: `The Management API returned HTTP ${status}.`,
+		fix: "Retry the command, or rerun with --trace for more detail.",
+		exitCode: 1
+	});
+}
+//#endregion
+export { runBuildLogs };

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

@@ -404,9 +404,9 @@ async function listComputeServices(client, options) {
 		liveUrl: toAbsoluteUrl(service.appEndpointDomain ?? null)
 	}));
 }
-async function listComputeServiceDomains(client, computeServiceId, signal) {
+async function listComputeServiceDomains(client, appId, signal) {
 	const result = await client.GET("/v1/apps/{appId}/domains", {
-		params: { path: { appId: computeServiceId } },
+		params: { path: { appId } },
 		signal
 	});
 	if (result.error || !result.data) throw domainApiCallError("Failed to list custom domains", result.response, result.error);
@@ -418,7 +418,7 @@ function normalizeDomainRecord(domain) {
 		type: domain.type,
 		url: domain.url,
 		hostname: domain.hostname,
-		computeServiceId: domain.computeServiceId,
+		appId: domain.appId,
 		status: domain.status,
 		foundryStatus: domain.foundryStatus,
 		failureReason: domain.failureReason,

package/dist/shell/command-meta.js

@@ -195,6 +195,22 @@ const DESCRIPTORS = [
 		description: "View your Platform branches",
 		examples: ["prisma-cli branch list"]
 	},
+	{
+		id: "build",
+		path: ["prisma", "build"],
+		description: "Inspect builds",
+		examples: ["prisma-cli build logs <build_id>"]
+	},
+	{
+		id: "build.logs",
+		path: [
+			"prisma",
+			"build",
+			"logs"
+		],
+		description: "Stream the logs for a build",
+		examples: ["prisma-cli build logs <build_id>", "prisma-cli build logs <build_id> --follow"]
+	},
 	{
 		id: "database",
 		path: ["prisma", "database"],

package/dist/shell/command-runner.js

@@ -75,12 +75,12 @@ async function renderBestEffortCommandDiagnostics(context, options) {
 		return [];
 	}
 }
-async function runStreamingCommand(runtime, commandName, options, handler) {
+async function runStreamingCommand(runtime, commandName, options, handler, streamOptions) {
 	const flags = resolveGlobalFlags(runtime.argv, options);
 	const context = await createCommandContext(runtime, flags);
 	try {
 		await handler(context);
-		if (flags.json) writeJsonEvent(context.output, {
+		if (flags.json && (streamOptions?.emitJsonSuccessEvent ?? true)) writeJsonEvent(context.output, {
 			type: "success",
 			command: commandName,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.105.1",
+  "version": "3.0.0-dev.108.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -46,7 +46,7 @@
     "@clack/prompts": "^1.5.0",
     "@prisma/compute-sdk": "0.31.0",
     "@prisma/credentials-store": "^7.8.0",
-    "@prisma/management-api-sdk": "^1.44.0",
+    "@prisma/management-api-sdk": "^1.46.0",
     "better-result": "^2.9.2",
     "colorette": "^2.0.20",
     "commander": "^14.0.3",