@prisma/cli 8.0.0-rc.2-dev.50 → 8.0.0-rc.2-dev.51

package/dist/cli.js

@@ -24,6 +24,8 @@ import { promisify } from "node:util";
 import { ApiError, CancelledError, ComputeClient, normalizeArtifactSymlinks, resolveBuildStrategy, streamLogs } from "@prisma/compute-sdk";
 import { parse } from "dotenv";
 import { fileURLToPath } from "node:url";
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 //#region src/cli-name.ts
 /**
 * The CLI's user-facing identity, in one place. The npm package is
@@ -15064,33 +15066,127 @@ const runPackageManager = async ({ file, args, cwd, signal, onOutput }) => {
 };
 //#endregion
 //#region src/spawn.ts
+/** How long after the child exits the relay keeps reading its pipes. A
+*  grandchild that inherited them can hold EOF back forever; settlement
+*  must not wait on it, so the pipes are destroyed after this grace. */
+const POST_EXIT_DRAIN_GRACE_MS = 5e3;
 /**
-* The engine's spawn seam, adapted to node:child_process. Inherited
-* stdio, no `detached`, no new console: the child stays in this
-* process's group (POSIX) or console (Windows), so the terminal
-* delivers Ctrl-C to it natively.
+* The engine's spawn seam, adapted to node:child_process. Human mode
+* inherits stdio; structured mode pipes both child output streams to
+* diagnostics. Neither mode detaches or opens a new console, so the child
+* stays in this process's group (POSIX) or console (Windows).
+*
+* The child's own status settles the run: `ended` resolves from the
+* process `exit` event, waits for the diagnostic relay only up to the
+* drain grace, and never rejects for a relay failure — rejection is
+* reserved for a child that could not be launched at all.
 */
-const spawnChild = (request) => {
-	const child = spawn(request.command, [...request.args], {
-		cwd: request.cwd,
-		env: request.env,
-		stdio: "inherit"
-	});
-	return {
-		ended: new Promise((resolve, reject) => {
+function makeSpawnChild(diagnostics, options) {
+	const drainGraceMs = options?.drainGraceMs ?? POST_EXIT_DRAIN_GRACE_MS;
+	return (request) => {
+		const structured = request.output === "diagnostic";
+		const child = spawn(request.command, [...request.args], {
+			cwd: request.cwd,
+			env: request.env,
+			stdio: structured ? [
+				"inherit",
+				"pipe",
+				"pipe"
+			] : "inherit"
+		});
+		const processEnded = new Promise((resolve, reject) => {
 			child.on("error", reject);
-			child.on("close", (exitCode, signal) => {
+			child.on("exit", (exitCode, signal) => {
 				resolve({
 					exitCode,
 					signal
 				});
 			});
-		}),
-		kill: (signal) => {
-			child.kill(signal);
-		}
+		});
+		if (!structured) return {
+			ended: processEnded,
+			kill: (signal) => {
+				child.kill(signal);
+			}
+		};
+		const forwarding = forwardStructuredOutput(child.stdout, child.stderr, diagnostics);
+		return {
+			ended: processEnded.then(async (result) => {
+				const drainDeadline = setTimeout(() => {
+					child.stdout?.destroy();
+					child.stderr?.destroy();
+				}, drainGraceMs);
+				await forwarding;
+				clearTimeout(drainDeadline);
+				return result;
+			}),
+			kill: (signal) => {
+				child.kill(signal);
+			}
+		};
 	};
-};
+}
+/** Best-effort relay: a forwarding failure never rejects, so the child's
+*  real status still settles the run when the diagnostic sink dies. */
+function forwardStructuredOutput(stdout, stderr, diagnostics) {
+	const sources = [stdout, stderr].filter((source) => source !== null);
+	return Promise.all(sources.map((source) => forwardOutput(source, diagnostics))).then(() => void 0, () => void 0);
+}
+/** Decode each child stream continuously and stop reading while the
+*  diagnostic destination applies backpressure. A destination that
+*  errors or closes instead of draining fails the relay rather than
+*  stalling it. */
+function forwardOutput(source, diagnostics) {
+	let pendingDone;
+	let pendingDrain;
+	let failure;
+	const fail = (cause) => {
+		failure ??= cause;
+		const done = pendingDone;
+		pendingDone = void 0;
+		done?.(cause);
+	};
+	const onSinkError = (cause) => {
+		fail(toError(cause));
+	};
+	const onSinkClose = () => {
+		fail(/* @__PURE__ */ new Error("the diagnostic stream closed during child output"));
+	};
+	diagnostics.once?.("error", onSinkError);
+	diagnostics.once?.("close", onSinkClose);
+	const destination = new Writable({
+		decodeStrings: false,
+		write: (text, _encoding, done) => {
+			if (failure !== void 0) {
+				done(failure);
+				return;
+			}
+			try {
+				if (diagnostics.write(text) === false && diagnostics.once !== void 0) {
+					pendingDone = done;
+					const onDrain = () => {
+						pendingDrain = void 0;
+						if (pendingDone !== done) return;
+						pendingDone = void 0;
+						done();
+					};
+					pendingDrain = onDrain;
+					diagnostics.once("drain", onDrain);
+				} else done();
+			} catch (cause) {
+				done(toError(cause));
+			}
+		}
+	});
+	return pipeline(source.setEncoding("utf8"), destination).finally(() => {
+		diagnostics.off?.("error", onSinkError);
+		diagnostics.off?.("close", onSinkClose);
+		if (pendingDrain !== void 0) diagnostics.off?.("drain", pendingDrain);
+	});
+}
+function toError(cause) {
+	return cause instanceof Error ? cause : new Error(String(cause));
+}
 //#endregion
 //#region src/runtime.ts
 /** Dumb wiring: forwards process signals to the engine's subscribers.
@@ -15198,7 +15294,7 @@ async function assembleRuntime(proc) {
 			apiBaseUrl,
 			authBaseUrl
 		},
-		spawn: spawnChild,
+		spawn: makeSpawnChild(proc.stderr),
 		/** The engine has already decided and composed; the bin only forks
 		*  the detached sender and hands the payload over. Every failure is
 		*  swallowed inside runTelemetry. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "8.0.0-rc.2-dev.50",
+  "version": "8.0.0-rc.2-dev.51",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -51,9 +51,9 @@
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@repo/cli-conformance": "8.0.0-rc.2-dev.50",
-    "@repo/cli-telemetry": "8.0.0-rc.2-dev.50",
-    "@repo/tsconfig": "8.0.0-rc.2-dev.50",
+    "@repo/cli-conformance": "8.0.0-rc.2-dev.51",
+    "@repo/cli-telemetry": "8.0.0-rc.2-dev.51",
+    "@repo/tsconfig": "8.0.0-rc.2-dev.51",
     "@types/node": "^22.19.19",
     "tsdown": "^0.21.10",
     "tsx": "^4.22.4",