@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/controllers/auth.js

@@ -1,9 +1,15 @@
-import { authRequiredError, usageError } from "../shell/errors.js";
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { PRISMA_AGENT_INSTALL_ARGS } from "../lib/agent/constants.js";
+import { isLikelyProjectDirectory, readPrismaAgentSetupStatus, resolvePrismaAgentSetupCwd, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
+import { authRequiredError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceSwitchUnavailableError } from "../shell/errors.js";
 import { canPrompt } from "../shell/runtime.js";
+import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
+import { FileTokenStorage, WorkspaceSelectionError } from "../adapters/token-storage.js";
 import { performLogin, performLogout, readAuthState } from "../lib/auth/auth-ops.js";
 import { createAuthUseCases } from "../use-cases/auth.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createManagementApiSdk } from "@prisma/management-api-sdk";
 //#region src/controllers/auth.ts
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
@@ -11,32 +17,70 @@ function isRealMode(context) {
 async function runAuthLogin(context, options) {
 	let result;
 	if (isRealMode(context)) {
-		await performLogin(context.runtime.env);
-		result = await readAuthState(context.runtime.env);
+		await performLogin(context.runtime.env, context.runtime.signal);
+		result = await readAuthState(context.runtime.env, context.runtime.signal);
 	} else result = await loginWithSelectionFlow(context, createAuthUseCases(createCliUseCaseGateways(context)), options);
-	return createAuthSuccess("auth.login", result, ["prisma-cli auth whoami", "prisma-cli project list"]);
+	const agentSetupTipCommand = await resolveAgentSetupTipCommand(context);
+	if (agentSetupTipCommand) result = {
+		...result,
+		agentSetupTip: { command: agentSetupTipCommand }
+	};
+	return createAuthSuccess("auth.login", result, [
+		"prisma-cli auth whoami",
+		"prisma-cli project list",
+		...result.agentSetupTip ? [result.agentSetupTip.command] : []
+	]);
 }
 async function runAuthLogout(context) {
 	let result;
 	if (isRealMode(context)) {
-		await performLogout(context.runtime.env);
-		result = await readAuthState(context.runtime.env);
+		await performLogout(context.runtime.env, context.runtime.signal);
+		result = await readAuthState(context.runtime.env, context.runtime.signal);
 	} else result = await createAuthUseCases(createCliUseCaseGateways(context)).logout();
 	return createAuthSuccess("auth.logout", result, ["prisma-cli auth login"]);
 }
 async function runAuthWhoAmI(context) {
 	let result;
-	if (isRealMode(context)) result = await readAuthState(context.runtime.env);
+	if (isRealMode(context)) result = await readAuthState(context.runtime.env, context.runtime.signal);
 	else result = await createAuthUseCases(createCliUseCaseGateways(context)).whoami();
 	return createAuthSuccess("auth.whoami", result, result.authenticated ? [] : ["prisma-cli auth login"]);
 }
+async function runAuthWorkspaceList(context) {
+	const result = isRealMode(context) ? await listRealAuthWorkspaces(context) : await createAuthUseCases(createCliUseCaseGateways(context)).listWorkspaces();
+	return {
+		command: "auth.workspace.list",
+		result,
+		warnings: [],
+		nextSteps: result.workspaces.length === 0 ? ["prisma-cli auth login"] : []
+	};
+}
+async function runAuthWorkspaceUse(context, workspaceRef) {
+	const trimmedWorkspaceRef = workspaceRef?.trim();
+	const selectedWorkspaceRef = trimmedWorkspaceRef ? trimmedWorkspaceRef : await selectWorkspaceSession(context);
+	return {
+		command: "auth.workspace.use",
+		result: isRealMode(context) ? await useRealAuthWorkspace(context, selectedWorkspaceRef) : await createAuthUseCases(createCliUseCaseGateways(context)).useWorkspace(selectedWorkspaceRef),
+		warnings: [],
+		nextSteps: ["prisma-cli auth whoami", "prisma-cli project list"]
+	};
+}
+async function runAuthWorkspaceLogout(context, workspaceRef) {
+	if (!workspaceRef?.trim()) throw usageError("Workspace required", "auth workspace logout needs a workspace id or cached workspace name.", "Pass a workspace from prisma-cli auth workspace list.", ["prisma-cli auth workspace list"], "auth");
+	const result = isRealMode(context) ? await logoutRealAuthWorkspace(context, workspaceRef) : await createAuthUseCases(createCliUseCaseGateways(context)).logoutWorkspace(workspaceRef);
+	return {
+		command: "auth.workspace.logout",
+		result,
+		warnings: [],
+		nextSteps: result.activeWorkspace ? ["prisma-cli auth workspace list"] : ["prisma-cli auth workspace list", "prisma-cli auth workspace use <id>"]
+	};
+}
 async function requireAuthenticatedAuthState(context) {
 	if (isRealMode(context)) {
-		const current = await readAuthState(context.runtime.env);
+		const current = await readAuthState(context.runtime.env, context.runtime.signal);
 		if (current.authenticated) return current;
 		if (!canPrompt(context)) throw authRequiredError();
-		await performLogin(context.runtime.env);
-		return readAuthState(context.runtime.env);
+		await performLogin(context.runtime.env, context.runtime.signal);
+		return readAuthState(context.runtime.env, context.runtime.signal);
 	}
 	const useCases = createAuthUseCases(createCliUseCaseGateways(context));
 	const current = await useCases.whoami();
@@ -44,6 +88,183 @@ async function requireAuthenticatedAuthState(context) {
 	if (!canPrompt(context)) throw authRequiredError();
 	return loginWithSelectionFlow(context, useCases, {});
 }
+async function listRealAuthWorkspaces(context) {
+	const rawServiceToken = context.runtime.env[SERVICE_TOKEN_ENV_VAR];
+	const storage = new FileTokenStorage(context.runtime.env, context.runtime.signal);
+	const localWorkspaces = await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	if (rawServiceToken !== void 0) {
+		const authState = await readAuthState(context.runtime.env, context.runtime.signal);
+		return {
+			authSource: authState.authenticated ? "service_token" : "none",
+			activeWorkspace: authState.workspace,
+			workspaces: [...authState.workspace ? [{
+				...authState.workspace,
+				credentialWorkspaceId: null,
+				active: true,
+				source: "service_token",
+				switchable: false,
+				lastSeenAt: null
+			}] : [], ...localWorkspaces.map((workspace) => ({
+				...toAuthWorkspace(workspace),
+				credentialWorkspaceId: workspace.credentialWorkspaceId,
+				active: false,
+				source: "oauth",
+				switchable: false,
+				lastSeenAt: workspace.lastSeenAt
+			}))]
+		};
+	}
+	const active = localWorkspaces.find((workspace) => workspace.active) ?? null;
+	return {
+		authSource: localWorkspaces.length > 0 ? "oauth" : "none",
+		activeWorkspace: active ? toAuthWorkspace(active) : null,
+		workspaces: localWorkspaces.map((workspace) => ({
+			...toAuthWorkspace(workspace),
+			credentialWorkspaceId: workspace.credentialWorkspaceId,
+			active: workspace.active,
+			source: "oauth",
+			switchable: true,
+			lastSeenAt: workspace.lastSeenAt
+		}))
+	};
+}
+async function useRealAuthWorkspace(context, workspaceRef) {
+	if (context.runtime.env["PRISMA_SERVICE_TOKEN"] !== void 0) throw workspaceSwitchUnavailableError();
+	const storage = new FileTokenStorage(context.runtime.env, context.runtime.signal);
+	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	try {
+		const result = await storage.useWorkspace(workspaceRef);
+		return {
+			previousWorkspace: result.previous ? toAuthWorkspace(result.previous) : null,
+			workspace: toAuthWorkspace(result.selected)
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function logoutRealAuthWorkspace(context, workspaceRef) {
+	const storage = new FileTokenStorage(context.runtime.env, context.runtime.signal);
+	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
+	try {
+		const result = await storage.logoutWorkspace(workspaceRef);
+		return {
+			workspace: toAuthWorkspace(result.workspace),
+			wasActive: result.wasActive,
+			activeWorkspace: result.activeWorkspace ? toAuthWorkspace(result.activeWorkspace) : null
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function selectWorkspaceSession(context) {
+	const realMode = isRealMode(context);
+	if (realMode && context.runtime.env["PRISMA_SERVICE_TOKEN"] !== void 0) throw workspaceSwitchUnavailableError();
+	const workspaces = (realMode ? await listRealAuthWorkspaces(context) : await createAuthUseCases(createCliUseCaseGateways(context)).listWorkspaces()).workspaces.filter((workspace) => workspace.switchable);
+	if (workspaces.length === 0) throw usageError("No authenticated workspaces", "There are no local OAuth workspace sessions to select.", "Run prisma-cli auth login and authorize a workspace.", ["prisma-cli auth login"], "auth");
+	if (workspaces.length === 1) return workspaces[0].id;
+	if (!canPrompt(context)) throw usageError("Interactive workspace selection unavailable", "auth workspace use needs an interactive terminal when no workspace is provided and more than one workspace is available.", "Run prisma-cli auth workspace use <id-or-name> with a workspace from prisma-cli auth workspace list.", ["prisma-cli auth workspace list"], "auth");
+	return (await createSelectPromptPort(context).select({
+		message: "Select a workspace",
+		choices: workspaces.map((workspace) => ({
+			label: `${workspace.name} (${workspace.id})${workspace.active ? " active" : ""}`,
+			value: workspace
+		}))
+	})).id;
+}
+async function hydrateLocalAuthWorkspaces(context, storage, workspaces) {
+	const candidates = workspaces.filter(needsWorkspaceMetadataHydration);
+	if (candidates.length === 0) return workspaces;
+	const tokensByCredentialWorkspaceId = new Map((await storage.listWorkspaceTokens()).map((tokens) => [tokens.workspaceId, tokens]));
+	let nextWorkspaces = workspaces;
+	for (const workspace of candidates) {
+		const tokens = tokensByCredentialWorkspaceId.get(workspace.credentialWorkspaceId);
+		if (!tokens) continue;
+		const resolved = await resolveOAuthWorkspaceMetadata(context, tokens);
+		if (!resolved) continue;
+		await rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved);
+		nextWorkspaces = nextWorkspaces.map((candidate) => candidate.credentialWorkspaceId === workspace.credentialWorkspaceId ? {
+			...candidate,
+			id: resolved.id,
+			name: resolved.name,
+			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+		} : candidate);
+	}
+	return nextWorkspaces;
+}
+async function rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved) {
+	try {
+		await storage.rememberWorkspace(tokens.workspaceId, resolved);
+	} catch {
+		context.runtime.signal?.throwIfAborted();
+	}
+}
+function needsWorkspaceMetadataHydration(workspace) {
+	return workspace.id === workspace.credentialWorkspaceId || workspace.name === "Unknown workspace" || workspace.name === workspace.credentialWorkspaceId;
+}
+async function resolveOAuthWorkspaceMetadata(context, tokens) {
+	const sdk = createManagementApiSdk({
+		clientId: CLIENT_ID,
+		redirectUri: "http://localhost:0/auth/callback",
+		tokenStorage: createSingleWorkspaceTokenStorage(new FileTokenStorage(context.runtime.env, context.runtime.signal, { activateOnSetTokens: false }), tokens),
+		apiBaseUrl: getApiBaseUrl(context.runtime.env)
+	});
+	try {
+		const { data } = await sdk.client.GET("/v1/workspaces/{id}", {
+			params: { path: { id: tokens.workspaceId } },
+			signal: context.runtime.signal
+		});
+		const id = stringOrNull(data?.data?.id) ?? tokens.workspaceId;
+		const name = stringOrNull(data?.data?.name) ?? id;
+		if (id === tokens.workspaceId && name === tokens.workspaceId) return null;
+		return {
+			id,
+			name
+		};
+	} catch {
+		context.runtime.signal?.throwIfAborted();
+		return null;
+	}
+}
+function createSingleWorkspaceTokenStorage(storage, initialTokens) {
+	let currentTokens = initialTokens;
+	return {
+		getTokens: async () => currentTokens,
+		setTokens: async (tokens) => {
+			currentTokens = tokens;
+			await storage.setTokens(tokens);
+		},
+		clearTokens: async () => {
+			const tokens = currentTokens;
+			currentTokens = null;
+			if (tokens) await storage.clearTokensIfCurrent(tokens);
+		}
+	};
+}
+function stringOrNull(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function toAuthWorkspace(workspace) {
+	return {
+		id: workspace.id,
+		name: workspace.name
+	};
+}
 async function loginWithSelectionFlow(context, useCases, options) {
 	const selection = await resolveLoginSelection(useCases, canPrompt(context) ? createSelectPromptPort(context) : null, options);
 	return useCases.login(selection);
@@ -103,5 +324,28 @@ function createAuthSuccess(command, result, nextSteps) {
 		nextSteps
 	};
 }
+async function resolveAgentSetupTipCommand(context) {
+	if (context.flags.json || context.flags.quiet) return null;
+	if (context.runtime.env.CI && context.flags.interactive !== true) return null;
+	if (!context.runtime.stderr.isTTY && context.flags.interactive !== true) return null;
+	const setupCwd = await resolvePrismaAgentSetupCwd({
+		cwd: context.runtime.cwd,
+		signal: context.runtime.signal
+	});
+	if (!await isLikelyProjectDirectory({
+		cwd: setupCwd,
+		signal: context.runtime.signal
+	})) return null;
+	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
+		cwd: setupCwd,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal
+	}))) return null;
+	return await resolvePrismaCliPackageCommand({
+		cwd: setupCwd,
+		signal: context.runtime.signal,
+		args: PRISMA_AGENT_INSTALL_ARGS
+	});
+}
 //#endregion
-export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI };
+export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceUse };

package/dist/controllers/branch.js

@@ -1,73 +1,103 @@
-import { featureUnavailableError, usageError } from "../shell/errors.js";
-import { canPrompt } from "../shell/runtime.js";
+import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listRealWorkspaceProjects } from "./project.js";
 import { createBranchUseCases } from "../use-cases/branch.js";
 //#region src/controllers/branch.ts
-const PREVIEW_BRANCH_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
 async function runBranchList(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	return {
+	if (isRealMode(context)) return {
 		command: "branch.list",
-		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
+		result: await listRealBranches(context),
 		warnings: [],
 		nextSteps: []
 	};
-}
-async function runBranchShow(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const result = await createBranchUseCases(createCliUseCaseGateways(context)).show();
 	return {
-		command: "branch.show",
-		result,
+		command: "branch.list",
+		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
 		warnings: [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli app deploy"] : []
+		nextSteps: []
 	};
 }
-async function runBranchUse(context, branchName) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const useCases = createBranchUseCases(createCliUseCaseGateways(context));
-	const resolvedBranchName = await resolveBranchNameForUse(context, useCases, branchName);
-	validateBranchName(resolvedBranchName);
-	const result = await useCases.use(resolvedBranchName);
+async function listRealBranches(context) {
+	const authState = await requireAuthenticatedAuthState(context);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	const workspace = authState.workspace;
+	if (!workspace) throw workspaceRequiredError();
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal)
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	const target = targetResult.value;
+	const branches = await listBranches(client, target.project.id, context.runtime.signal);
 	return {
-		command: "branch.use",
-		result,
-		warnings: result.branch.kind === "production" ? ["Production is protected and durable. Use with care."] : [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli branch show", "prisma-cli app deploy"] : ["prisma-cli branch show"]
+		projectId: target.project.id,
+		projectName: target.project.name,
+		verboseContext: {
+			workspace,
+			project: target.project,
+			resolution: target.resolution
+		},
+		branches: sortBranches(branches.map(toBranchSummary))
 	};
 }
-async function resolveBranchNameForUse(context, useCases, branchName) {
-	if (branchName) return branchName;
-	if (!canPrompt(context)) throw branchSelectionRequiredError();
-	const result = await useCases.list();
-	return createSelectPromptPort(context).select({
-		message: "Select a branch",
-		choices: result.branches.map((branch) => ({
-			label: renderBranchChoiceLabel(branch),
-			value: branch.name
-		}))
+function sortBranches(branches) {
+	return branches.slice().sort((left, right) => {
+		const leftRank = branchOrder(left);
+		const rightRank = branchOrder(right);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		return left.name.localeCompare(right.name);
 	});
 }
-function renderBranchChoiceLabel(branch) {
-	const markers = [];
-	if (branch.active) markers.push("active");
-	if (!branch.remoteState) markers.push("not created yet");
-	return markers.length > 0 ? `${branch.name} (${markers.join(", ")})` : branch.name;
+function branchOrder(branch) {
+	return branch.role === "production" ? 0 : 1;
 }
-function validateBranchName(branchName) {
-	if (branchName === "production") return;
-	if (PREVIEW_BRANCH_PATTERN.test(branchName)) return;
-	throw usageError("Branch name must use the documented form", "Branch names must be production or a lowercase preview slug such as preview or feat-auth.", "Use production or a lowercase preview branch name with letters, numbers, and hyphens.", ["prisma-cli branch list"], "branch");
+async function listBranches(client, projectId, signal) {
+	const collected = [];
+	let cursor;
+	while (true) {
+		const query = {};
+		if (cursor !== void 0) query.cursor = cursor;
+		const { data, error, response } = await client.GET("/v1/projects/{projectId}/branches", {
+			params: {
+				path: { projectId },
+				query
+			},
+			signal
+		});
+		if (error || !data) throw branchApiError("Failed to list branches", response, error);
+		collected.push(...data.data);
+		if (!data.pagination.hasMore || !data.pagination.nextCursor) break;
+		cursor = data.pagination.nextCursor;
+	}
+	return collected;
 }
-function branchSelectionRequiredError() {
-	return usageError("Branch use requires a target in non-interactive mode", "This command cannot prompt for branch selection in the current mode.", "Re-run prisma-cli branch use in a TTY, or pass a branch name explicitly.", ["prisma-cli branch list"], "branch");
+function toBranchSummary(branch) {
+	return {
+		id: branch.id,
+		name: branch.gitName,
+		role: branch.role,
+		envMap: branch.role
+	};
 }
-function branchCommandsUnavailableError() {
-	return featureUnavailableError("Branch commands are not available in this preview", "The current preview cannot resolve or change remote branch context yet.", "Use prisma-cli app deploy for preview app deployment workflows.", ["prisma-cli app deploy --app <name>"], "branch");
+function branchApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "BRANCH_API_ERROR",
+		domain: "branch",
+		summary,
+		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
 }
 //#endregion
-export { runBranchList, runBranchShow, runBranchUse };
+export { runBranchList };

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 };