@prisma/cli 8.0.0-rc.2 → 8.0.0-rc.2-dev.49

package/dist/cli.js

@@ -889,7 +889,7 @@ function findTokensForWorkspace(allCredentials, workspaceId) {
 function tokensEqual(a, b) {
 	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
 }
-function sleep$1(ms, signal) {
+function sleep$2(ms, signal) {
 	signal?.throwIfAborted();
 	return new Promise((resolve, reject) => {
 		const onAbort = () => {
@@ -1106,7 +1106,7 @@ var FileTokenStorage = class {
 			if (await this.tryCreateRefreshLock(lockId)) return lockId;
 			if (await this.releaseStaleRefreshLock()) continue;
 			this.throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs);
-			await sleep$1(retryMs, this.signal);
+			await sleep$2(retryMs, this.signal);
 		}
 	}
 	async tryCreateRefreshLock(lockId) {
@@ -4657,8 +4657,45 @@ const bucketListCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/lib/ndjson.ts
+/**
+* Reads a newline-delimited JSON body line by line.
+*
+* Shared by every command that reads an NDJSON log page, so the stream
+* handling below is written and tested once. The two subtleties are the
+* reason: a chunk boundary can fall inside a line, and a body can end
+* without a trailing newline, so the last record arrives only if the
+* leftover buffer is flushed at `done`.
+*/
+async function forEachNdjsonRecord(body, onRecord) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		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;
+			}
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+//#endregion
 //#region src/commands/build/logs.ts
-const TRAILING_NEWLINE = /\n$/;
+const TRAILING_NEWLINE$1 = /\n$/;
 function buildNotFoundError(buildId) {
 	return new CliStructuredError("BUILD.NOT_FOUND", `Build ${buildId} was not found`, {
 		why: "The build does not exist, or your workspace does not have access to it.",
@@ -4706,40 +4743,13 @@ function buildFailedError(buildId, record) {
 		}] : []]
 	});
 }
-/** Reads a newline-delimited JSON body line by line. */
-async function forEachNdjsonRecord(body, onRecord) {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	try {
-		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;
-			}
-		}
-	} finally {
-		await reader.cancel().catch(() => void 0);
-		reader.releaseLock();
-	}
-}
 function reportRecord(ctx, record) {
 	if (record.type === "log") {
 		ctx.report({
 			kind: "output",
 			source: "build",
 			channel: record.source === "stderr" || record.level === "error" ? "diagnostic" : "data",
-			line: record.text.replace(TRAILING_NEWLINE, ""),
+			line: record.text.replace(TRAILING_NEWLINE$1, ""),
 			data: {
 				cursor: record.cursor,
 				level: record.level,
@@ -11257,6 +11267,30 @@ function deploymentNotFoundError(deploymentId) {
 		nextActions: [runCommandAction("Choose an available deployment id", "service deployment list")]
 	});
 }
+/** `--tail` and `--from-start` ask for opposite ends of the log, so a
+*  run naming both has no answer to give. Refused before any work. */
+function logsRangeConflictError() {
+	return new CliStructuredError("SERVICE.LOGS_RANGE_CONFLICT", "Choose one end of the log to read from", {
+		why: "--tail and --from-start are mutually exclusive: one reads the last lines, the other reads from the beginning.",
+		nextActions: [adviceAction("Pass --tail <n> for the last n lines, or --from-start for the whole log.")]
+	});
+}
+/** A deployment id resolves globally, so one that exists but belongs to
+*  another project is its own failure — not "not found". */
+function deploymentOutsideProjectError(deploymentId) {
+	return new CliStructuredError("SERVICE.DEPLOYMENT_OUTSIDE_PROJECT", `Deployment "${deploymentId}" belongs to another project`, {
+		why: "The deployment exists, but the service that owns it is not in the resolved project.",
+		nextActions: [adviceAction("Pass --project for the project that owns it."), runCommandAction("List services", "service list")]
+	});
+}
+/** The deployment exists but names no owning service, so there is no
+*  project to check it against and nothing to scope logs by. */
+function deploymentDetachedError(deploymentId) {
+	return new CliStructuredError("SERVICE.DEPLOYMENT_DETACHED", `Deployment "${deploymentId}" has no owning service`, {
+		why: "The Management API returned the deployment without a service, so it cannot be scoped to a project.",
+		nextActions: [runCommandAction("Show the deployment", `service deployment show ${deploymentId}`)]
+	});
+}
 function deploymentNotFoundForServiceError(deploymentId, serviceName) {
 	return new CliStructuredError("SERVICE.DEPLOYMENT_NOT_FOUND", `Deployment "${deploymentId}" not found for service "${serviceName}"`, {
 		why: "The requested deployment does not belong to the resolved service or is no longer available.",
@@ -12414,12 +12448,13 @@ async function resolveServiceReadState(ctx, options) {
 	});
 	const projectId = target.project.id;
 	const stateStore = await openServiceStateStore(ctx);
+	const services = await listServices(ctx, provider, projectId, target.branch.name);
 	return {
 		provider,
 		stateStore,
 		target,
 		projectId,
-		selected: await resolveExistingServiceSelection(ctx, stateStore, projectId, await listServices(ctx, provider, projectId, target.branch.name), options.serviceName ?? compute.configServiceName)
+		selected: options.skipSelection ? null : await resolveExistingServiceSelection(ctx, stateStore, projectId, services, options.serviceName ?? compute.configServiceName)
 	};
 }
 async function resolveServiceDomainTarget(ctx, options) {
@@ -13325,7 +13360,7 @@ const serviceDomainShowCommand = defineCommand({
 //#endregion
 //#region src/commands/service/domain-wait.ts
 const DEFAULT_TIMEOUT_MS = 900 * 1e3;
-const DEFAULT_POLL_INTERVAL_MS = 5e3;
+const DEFAULT_POLL_INTERVAL_MS$1 = 5e3;
 const UNIT_MULTIPLIER_MS = {
 	ms: 1,
 	s: 1e3,
@@ -13340,13 +13375,13 @@ function parseWaitTimeout(value) {
 	if (!match) throw timeoutInvalidError(value);
 	return Number.parseInt(match[1], 10) * (UNIT_MULTIPLIER_MS[match[2]] ?? 1);
 }
-function pollIntervalMs(ctx) {
+function pollIntervalMs$1(ctx) {
 	const raw = ctx.env.PRISMA_CLI_DOMAIN_WAIT_POLL_MS;
-	if (!raw) return DEFAULT_POLL_INTERVAL_MS;
+	if (!raw) return DEFAULT_POLL_INTERVAL_MS$1;
 	const parsed = Number.parseInt(raw, 10);
-	return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_POLL_INTERVAL_MS;
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_POLL_INTERVAL_MS$1;
 }
-async function sleep(milliseconds, signal) {
+async function sleep$1(milliseconds, signal) {
 	if (milliseconds <= 0) return;
 	signal.throwIfAborted();
 	await new Promise((resolve, reject) => {
@@ -13392,7 +13427,7 @@ const serviceDomainWaitCommand = defineCommand({
 		const domain = await resolveDomainByHostname(target.provider, target.service.id, hostname, "wait", ctx.signal);
 		const start = Date.now();
 		const deadline = start + timeoutMs;
-		const interval = pollIntervalMs(ctx);
+		const interval = pollIntervalMs$1(ctx);
 		let previousStatus = null;
 		let current = domain;
 		for (;;) {
@@ -13418,7 +13453,7 @@ const serviceDomainWaitCommand = defineCommand({
 			}
 			if (current.status === "failed") throw domainVerificationFailedError(hostname, current);
 			if (timeoutMs === 0 || Date.now() >= deadline) throw domainVerificationTimeoutError(hostname, current.status);
-			await sleep(Math.min(interval, Math.max(deadline - Date.now(), 0)), ctx.signal);
+			await sleep$1(Math.min(interval, Math.max(deadline - Date.now(), 0)), ctx.signal);
 			current = await target.provider.showDomain(current.id, { signal: ctx.signal }).catch((error) => {
 				throw domainCommandError("wait", error, hostname);
 			});
@@ -13461,6 +13496,264 @@ const serviceListCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/commands/service/logs.ts
+const TRAILING_NEWLINE = /\n$/;
+/** The endpoint's own default page size, restated so `--tail` and the
+*  unflagged run send the same shape of request. */
+const DEFAULT_TAIL = 100;
+/** Contract: poll every 2s in --follow. Overridable so a test drives the
+*  loop without waiting, the way `service domain wait` does. */
+const DEFAULT_POLL_INTERVAL_MS = 2e3;
+function pollIntervalMs(ctx) {
+	const raw = ctx.env.PRISMA_CLI_SERVICE_LOGS_POLL_MS;
+	if (!raw) return DEFAULT_POLL_INTERVAL_MS;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_POLL_INTERVAL_MS;
+}
+async function sleep(milliseconds, signal) {
+	if (milliseconds <= 0) {
+		signal.throwIfAborted();
+		return;
+	}
+	signal.throwIfAborted();
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, milliseconds);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function logsFailedError(deploymentId, status) {
+	return new CliStructuredError("SERVICE.LOGS_FAILED", `Failed to read logs for deployment ${deploymentId}`, {
+		why: `The Management API returned HTTP ${status}.`,
+		meta: { status },
+		nextActions: [adviceAction("Retry the command, or rerun with --log-level verbose for more detail."), runCommandAction("Show the deployment", `service deployment show ${deploymentId}`)]
+	});
+}
+/**
+* The body ended mid-page, without the terminal record that closes one.
+* Distinct from SERVICE.LOGS_NO_CURSOR, which is a page that closed
+* properly and said there is nothing to resume from: this one is an
+* incomplete read, and the lines already printed are not the whole page.
+*/
+function logsIncompleteError(deploymentId) {
+	return new CliStructuredError("SERVICE.LOGS_INCOMPLETE", `Incomplete log page for deployment ${deploymentId}`, {
+		why: "The response ended without the record that closes a page, so the lines shown may be only part of it.",
+		nextActions: [adviceAction("Rerun the command to read the page again.")]
+	});
+}
+/** An error terminal record is the platform reporting that the log read
+*  itself failed, so it settles the run rather than printing. */
+function logStreamFailedError(deploymentId, record) {
+	return new CliStructuredError("SERVICE.LOGS_FAILED", `Log stream failed for deployment ${deploymentId}`, {
+		why: record.message,
+		meta: {
+			code: record.code,
+			retryable: record.retryable,
+			...record.cursor === null ? {} : { cursor: record.cursor }
+		},
+		nextActions: [runCommandAction("Show the deployment", `service deployment show ${deploymentId}`)]
+	});
+}
+function listDeployments(ctx, provider, serviceId) {
+	return provider.listDeployments(serviceId, { signal: ctx.signal }).catch((error) => {
+		throw deployFailedError("Failed to list service deployments", error, [runCommandAction("List deployments", "service deployment list")]);
+	});
+}
+/** `--deployment <id>`: the id is global, so it is resolved directly and
+*  then checked against the resolved project — a deployment that exists
+*  but belongs elsewhere is reported as its own failure. */
+async function resolveExplicitDeployment(ctx, state, serviceName, deploymentId) {
+	if (serviceName) {
+		if (!state.selected) throw noDeploymentsError("No deployments available to read logs from", "The resolved project does not have any deployed service yet.");
+		const deploymentsResult = await listDeployments(ctx, state.provider, state.selected.id);
+		const deployment = requireDeploymentForService(deploymentsResult.deployments, deploymentId, state.selected.name);
+		await rememberSelectedService(state.stateStore, state.projectId, deploymentsResult.app);
+		return {
+			service: deploymentsResult.app,
+			deployment
+		};
+	}
+	const shown = await state.provider.showDeployment(deploymentId, { signal: ctx.signal }).catch((error) => {
+		throw deployFailedError("Failed to show deployment", error, [runCommandAction("List deployments", "service deployment list")]);
+	});
+	if (!shown) throw deploymentNotFoundError(deploymentId);
+	if (!shown.app) throw deploymentDetachedError(deploymentId);
+	const owning = (await listServices(ctx, state.provider, state.projectId, state.target.branch.name)).find((service) => service.id === shown.app?.id);
+	if (!owning) throw deploymentOutsideProjectError(deploymentId);
+	await rememberSelectedService(state.stateStore, state.projectId, owning);
+	return {
+		service: owning,
+		deployment: shown.deployment
+	};
+}
+/** No `--deployment`: read whatever is live for the selected service. */
+async function resolveLiveDeployment(ctx, state) {
+	if (!state.selected) throw noDeploymentsError("No deployments available to read logs from", "The resolved project does not have any deployed service yet.");
+	const deploymentsResult = await listDeployments(ctx, state.provider, state.selected.id);
+	const currentLiveDeploymentId = resolveCurrentLiveDeploymentId(deploymentsResult.app, deploymentsResult.deployments);
+	const deployments = applyLiveDeploymentHint(deploymentsResult.deployments, currentLiveDeploymentId);
+	const deployment = currentLiveDeploymentId ? deployments.find((candidate) => candidate.id === currentLiveDeploymentId) ?? null : null;
+	await rememberSelectedService(state.stateStore, state.projectId, deploymentsResult.app);
+	if (!deployment) throw noDeploymentsError("No deployments available to read logs from", `The selected service "${deploymentsResult.app.name}" does not have a live deployment.`);
+	return {
+		service: deploymentsResult.app,
+		deployment
+	};
+}
+/**
+* Reads one page and reports its log records. Returns the terminal
+* record that closed it — the caller decides whether that ends the run
+* or starts the next page.
+*
+* Every page ends with a terminal record, so a body that stops without
+* one was truncated. The lines that did arrive have already been
+* reported, but the run must not settle as though it had read the whole
+* page: the user would have a partial log and no way to tell.
+*/
+async function readPage(ctx, deploymentId, query) {
+	const { data, response } = await ctx.api.GET("/v1/deployments/{deploymentId}/logs", {
+		params: {
+			path: { deploymentId },
+			query
+		},
+		parseAs: "stream",
+		signal: ctx.signal
+	});
+	const body = data;
+	if (!response.ok || !body) {
+		await body?.cancel().catch(() => void 0);
+		throw response.status === 404 ? deploymentNotFoundError(deploymentId) : logsFailedError(deploymentId, response.status);
+	}
+	let terminal = null;
+	await forEachNdjsonRecord(body, (record) => {
+		if (record.type === "terminal") {
+			terminal = record;
+			return;
+		}
+		ctx.report({
+			kind: "output",
+			source: "logs",
+			channel: "data",
+			line: record.text.replace(TRAILING_NEWLINE, ""),
+			data: {
+				byteStart: record.byteStart,
+				byteEnd: record.byteEnd
+			}
+		});
+	});
+	if (terminal === null) throw logsIncompleteError(deploymentId);
+	return terminal;
+}
+/**
+* Following needs somewhere to resume from. Without a cursor the next
+* request would carry no range at all, the endpoint would apply its
+* default tail, and the same lines would print again every interval —
+* silent duplication the user cannot act on. So the run stops and says
+* why. It settles as an error rather than a clean end because `--follow`
+* has no successful ending: it runs until interrupted (130) or fails,
+* and an exit 0 here would be a novel outcome meaning "gave up".
+*/
+function requireResumeCursor(deploymentId, cursor) {
+	if (cursor === null) throw new CliStructuredError("SERVICE.LOGS_NO_CURSOR", `Cannot follow logs for deployment ${deploymentId}`, {
+		why: "The log page ended without a resume cursor, so there is no point to continue reading from.",
+		nextActions: [adviceAction("Rerun without --follow to read the page, or retry if the deployment is still starting.")]
+	});
+	return cursor;
+}
+/**
+* `--follow`: wait the poll interval, read the next page from the cursor
+* the last one ended on, repeat until the user interrupts. Never
+* returns — the run ends by abort (the engine settles 130) or by throw.
+*/
+async function followPages(ctx, deploymentId, startCursor) {
+	const interval = pollIntervalMs(ctx);
+	let cursor = requireResumeCursor(deploymentId, startCursor);
+	let retriedAfterError = false;
+	for (;;) {
+		await sleep(interval, ctx.signal);
+		const next = await readPage(ctx, deploymentId, { cursor });
+		if (next.kind === "error") {
+			if (!next.retryable || retriedAfterError) throw logStreamFailedError(deploymentId, next);
+			retriedAfterError = true;
+			continue;
+		}
+		retriedAfterError = false;
+		cursor = requireResumeCursor(deploymentId, next.cursor);
+	}
+}
+const serviceLogsCommand = defineSessionCommand({
+	help: {
+		summary: "Read logs for a deployment of the service",
+		examples: [
+			"service logs",
+			"service logs --tail 500",
+			"service logs --follow",
+			"service logs --deployment dep_123 --from-start"
+		]
+	},
+	args: {
+		flags: {
+			service: flag.string({
+				brief: "Service name",
+				placeholder: "name"
+			}),
+			project: flag.string({
+				brief: "Project id or name",
+				placeholder: "id-or-name"
+			}),
+			deployment: flag.string({
+				brief: "Deployment id to read (default: the live deployment)",
+				placeholder: "id"
+			}),
+			tail: flag.number({
+				brief: `Read the last N lines (default ${DEFAULT_TAIL})`,
+				placeholder: "n"
+			}),
+			fromStart: flag.boolean({ brief: "Read from the beginning instead of the last lines" }),
+			follow: flag.boolean({ brief: "Keep polling for new lines until interrupted" })
+		},
+		positionals: { service: positional.optionalString({
+			brief: "Service target from prisma.compute.ts when the config defines multiple services",
+			placeholder: "service"
+		}) }
+	},
+	needs: { credentials: true },
+	handler: async (args, ctx) => {
+		if (args.flags.fromStart && args.flags.tail !== void 0) throw logsRangeConflictError();
+		const serviceNamed = args.flags.service ?? args.positionals.service;
+		const resolveGlobally = Boolean(args.flags.deployment) && !serviceNamed;
+		const state = await resolveServiceReadState(ctx, {
+			...args.flags.service !== void 0 ? { serviceName: args.flags.service } : {},
+			...args.flags.project !== void 0 ? { projectRef: args.flags.project } : {},
+			...args.positionals.service !== void 0 ? { configTarget: args.positionals.service } : {},
+			commandName: "service logs",
+			skipSelection: resolveGlobally
+		});
+		const target = args.flags.deployment ? await resolveExplicitDeployment(ctx, state, serviceNamed, args.flags.deployment) : await resolveLiveDeployment(ctx, state);
+		const deploymentId = target.deployment.id;
+		for (const line of [
+			`project: ${state.projectId}`,
+			`service: ${target.service.name}`,
+			`deployment: ${deploymentId}`
+		]) ctx.report({
+			kind: "output",
+			source: "logs",
+			channel: "diagnostic",
+			line
+		});
+		const terminal = await readPage(ctx, deploymentId, args.flags.fromStart ? { from_start: "true" } : { tail: args.flags.tail ?? DEFAULT_TAIL });
+		if (terminal.kind === "error") throw logStreamFailedError(deploymentId, terminal);
+		if (!args.flags.follow) return ok(void 0);
+		return followPages(ctx, deploymentId, terminal.cursor);
+	}
+});
+//#endregion
 //#region src/commands/service/open.ts
 const serviceOpenCommand = defineCommand({
 	help: {
@@ -13714,6 +14007,7 @@ const platformCommandFamily = defineCommandFamily({ commands: {
 	gitConnect: gitConnectCommand,
 	gitDisconnect: gitDisconnectCommand,
 	serviceList: serviceListCommand,
+	serviceLogs: serviceLogsCommand,
 	serviceCreate: serviceCreateCommand,
 	serviceShow: serviceShowCommand,
 	serviceOpen: serviceOpenCommand,
@@ -13816,6 +14110,7 @@ const mountedCommands = {
 	"git connect": gitConnectCommand,
 	"git disconnect": gitDisconnectCommand,
 	"service list": serviceListCommand,
+	"service logs": serviceLogsCommand,
 	"service create": serviceCreateCommand,
 	"service show": serviceShowCommand,
 	"service open": serviceOpenCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "8.0.0-rc.2",
+  "version": "8.0.0-rc.2-dev.49",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@prisma/cli-engine": "8.0.0-rc.2",
+    "@prisma/cli-engine": "0.1.1",
     "@prisma/composer": "0.6.0-dev.16",
     "@prisma/compute-sdk": "0.39.0",
     "@prisma/credentials-store": "^7.8.0",
@@ -51,9 +51,9 @@
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@repo/cli-conformance": "8.0.0-rc.2",
-    "@repo/cli-telemetry": "8.0.0-rc.2",
-    "@repo/tsconfig": "8.0.0-rc.2",
+    "@repo/cli-conformance": "8.0.0-rc.2-dev.49",
+    "@repo/cli-telemetry": "8.0.0-rc.2-dev.49",
+    "@repo/tsconfig": "8.0.0-rc.2-dev.49",
     "@types/node": "^22.19.19",
     "tsdown": "^0.21.10",
     "tsx": "^4.22.4",