@prisma/cli 3.0.0-dev.51.1 → 3.0.0-dev.53.1

package/dist/cli.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
+import { runUpdateDiscoveryWorker } from "./shell/update-check.js";
 import { runCli } from "./cli2.js";
 import process from "node:process";
 //#region src/bin.ts
-runCli().then((exitCode) => {
+if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") runUpdateDiscoveryWorker().then(() => {
+	process.exitCode = 0;
+});
+else runCli().then((exitCode) => {
 	process.exitCode = exitCode;
 });
 //#endregion

package/dist/cli2.js

@@ -13,6 +13,7 @@ import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
 import { runVersion } from "./controllers/version.js";
 import { createVersionCommand } from "./commands/version/index.js";
+import { maybeWriteCachedUpdateNotification } from "./shell/update-check.js";
 import process from "node:process";
 import { Command, CommanderError, Option } from "commander";
 //#region src/cli.ts
@@ -21,6 +22,7 @@ async function runCli(options = {}) {
 	const program = createProgram(runtime);
 	process.exitCode = 0;
 	try {
+		await maybeWriteCachedUpdateNotification(runtime);
 		if (runtime.argv.includes("--version")) return await handleVersionFlag(runtime);
 		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
 		if (bareHelpCommand) {

package/dist/lib/auth/login.js

@@ -4,6 +4,7 @@ import open from "open";
 import { AuthError, createManagementApiSdk } from "@prisma/management-api-sdk";
 import events from "node:events";
 import http from "node:http";
+import readline from "node:readline/promises";
 //#region src/lib/auth/login.ts
 var AuthError$1 = class extends Error {
 	constructor(message) {
@@ -14,11 +15,15 @@ var AuthError$1 = class extends Error {
 async function login(options = {}) {
 	const hostname = options.hostname ?? "localhost";
 	const port = options.port ?? 0;
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stderr;
+	const interactive = input.isTTY === true;
 	const server = http.createServer();
 	server.listen({
 		host: hostname,
 		port
 	});
+	const pasteAbort = new AbortController();
 	try {
 		const state = new LoginState({
 			hostname,
@@ -28,9 +33,21 @@ async function login(options = {}) {
 			apiBaseUrl: options.apiBaseUrl,
 			authBaseUrl: options.authBaseUrl,
 			openUrl: options.openUrl,
-			env: options.env
+			env: options.env,
+			output
 		});
-		const authResult = new Promise((resolve, reject) => {
+		let completed = false;
+		let completion;
+		const completeOnce = (url) => {
+			if (!completion) completion = state.handleCallback(url).then(() => {
+				completed = true;
+			}, (error) => {
+				completion = void 0;
+				throw error;
+			});
+			return completion;
+		};
+		const httpResult = new Promise((resolve, reject) => {
 			server.on("request", async (req, res) => {
 				const url = new URL(`http://${state.host}${req.url}`);
 				if (url.pathname !== "/auth/callback") {
@@ -38,8 +55,14 @@ async function login(options = {}) {
 					res.end("Not found");
 					return;
 				}
+				if (completed) {
+					const workspaceName = await state.resolveWorkspaceName();
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.end(renderSuccessPage(workspaceName));
+					return;
+				}
 				try {
-					await state.handleCallback(url);
+					await completeOnce(url);
 				} catch (error) {
 					res.statusCode = 400;
 					const message = error instanceof Error ? error.message : String(error);
@@ -53,18 +76,65 @@ async function login(options = {}) {
 				resolve();
 			});
 		});
-		await state.openLoginPage();
-		await authResult;
+		await state.openLoginPage(interactive);
+		if (interactive) {
+			const pasteResult = consumePastedCallback({
+				input,
+				output,
+				signal: pasteAbort.signal,
+				complete: completeOnce
+			});
+			await Promise.race([httpResult, pasteResult]);
+		} else await httpResult;
 	} finally {
+		pasteAbort.abort();
 		if (server.listening) await new Promise((resolve) => server.close(() => resolve()));
 	}
 }
+async function consumePastedCallback(options) {
+	if (!options.input.isTTY) return;
+	const rl = readline.createInterface({
+		input: options.input,
+		output: options.output
+	});
+	try {
+		for (;;) {
+			let answer;
+			try {
+				answer = await rl.question("Paste the callback URL here: ", { signal: options.signal });
+			} catch (error) {
+				if (error?.name === "AbortError") return;
+				throw error;
+			}
+			const trimmed = answer.trim().replace(/^["']|["']$/g, "");
+			let url;
+			try {
+				if (!trimmed) throw new Error("empty input");
+				url = new URL(trimmed);
+			} catch {
+				options.output.write("That didn't look like a URL. Paste the full localhost callback URL and try again.\n");
+				continue;
+			}
+			try {
+				await options.complete(url);
+				return;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				options.output.write(`Sign-in didn't complete (${message}). Paste the callback URL to try again.\n`);
+				continue;
+			}
+		}
+	} finally {
+		rl.close();
+	}
+}
 var LoginState = class {
 	latestVerifier;
 	latestState;
 	sdk;
 	openUrl;
 	tokenStorage;
+	output;
 	constructor(options) {
 		this.options = options;
 		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
@@ -76,8 +146,9 @@ var LoginState = class {
 			authBaseUrl: options.authBaseUrl
 		});
 		this.openUrl = options.openUrl ?? open;
+		this.output = options.output;
 	}
-	async openLoginPage() {
+	async openLoginPage(interactive) {
 		const { url, state, verifier } = await this.sdk.getLoginUrl({
 			scope: "workspace:admin offline_access",
 			additionalParams: {
@@ -88,7 +159,17 @@ var LoginState = class {
 		});
 		this.latestState = state;
 		this.latestVerifier = verifier;
-		await this.openUrl(url);
+		if (interactive) this.printLoginInstructions(url);
+		try {
+			await this.openUrl(url);
+		} catch (error) {
+			if (!interactive) throw error;
+		}
+	}
+	printLoginInstructions(url) {
+		const output = this.output;
+		if (!output) return;
+		output.write(`\nOpen this URL to sign in: ${url}\n\nIf the browser opens on another machine, finish sign-in there. When it\nredirects to localhost, copy the full localhost URL from the address bar\nand paste it here.\n\n`);
 	}
 	async handleCallback(url) {
 		if (url.pathname !== "/auth/callback") throw new AuthError$1("Not a callback URL");

package/dist/shell/update-check.js

@@ -0,0 +1,247 @@
+import { getCliName, getCliVersion } from "../lib/version.js";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { spawn } from "node:child_process";
+//#region src/shell/update-check.ts
+const UPDATE_CHECK_FILE_NAME = "update-check.json";
+const FALLBACK_INSTALL_DOCS_URL = "https://www.prisma.io/docs/orm/tools/prisma-cli";
+const NOTIFICATION_INTERVAL_MS = 1440 * 60 * 1e3;
+const REGISTRY_URL = "https://registry.npmjs.org/@prisma%2fcli";
+const REGISTRY_TIMEOUT_MS = 3e3;
+var UpdateCheckStore = class {
+	filePath;
+	constructor(cacheDir) {
+		this.filePath = path.join(cacheDir, UPDATE_CHECK_FILE_NAME);
+	}
+	async read() {
+		try {
+			return JSON.parse(await readFile(this.filePath, "utf8"));
+		} catch (error) {
+			if (isUnreadableCacheError(error)) return null;
+			throw error;
+		}
+	}
+	async write(state) {
+		const dir = path.dirname(this.filePath);
+		const tempPath = path.join(dir, `${UPDATE_CHECK_FILE_NAME}.${process.pid}.${randomUUID()}.tmp`);
+		await mkdir(dir, { recursive: true });
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		await rename(tempPath, this.filePath);
+	}
+};
+async function maybeWriteCachedUpdateNotification(runtime) {
+	if (!canRunUpdateCheck(runtime)) return;
+	try {
+		const cacheDir = resolveUpdateCheckCacheDir(runtime);
+		const store = new UpdateCheckStore(cacheDir);
+		const state = await store.read();
+		const latestVersion = state?.latestVersion;
+		if (latestVersion && isInstalledVersionStale(getCliVersion(), latestVersion) && shouldNotify(state)) {
+			runtime.stderr.write(renderUpdateNotification(latestVersion, selectUpdateInstruction(runtime.env)));
+			await store.write({
+				...state,
+				packageName: "@prisma/cli",
+				installedVersion: getCliVersion(),
+				notifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		await scheduleRemoteDiscovery(runtime, store, state, cacheDir);
+	} catch {
+		return;
+	}
+}
+async function runUpdateDiscovery(options) {
+	try {
+		const latestVersion = await fetchLatestVersion(options.registryUrl ?? REGISTRY_URL, options.fetchImpl ?? fetch);
+		if (!latestVersion) return;
+		const store = new UpdateCheckStore(options.cacheDir);
+		const previousState = await store.read();
+		await store.write({
+			...previousState,
+			packageName: "@prisma/cli",
+			installedVersion: options.installedVersion,
+			latestVersion,
+			checkedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+		});
+	} catch {
+		return;
+	}
+}
+function isUnreadableCacheError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "EACCES" || code === "EPERM" || error instanceof SyntaxError;
+}
+async function runUpdateDiscoveryWorker(env = process.env) {
+	const cacheDir = env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	const installedVersion = env.PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION;
+	if (!cacheDir || !installedVersion) return;
+	await runUpdateDiscovery({
+		cacheDir,
+		installedVersion,
+		registryUrl: env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL
+	});
+}
+function canRunUpdateCheck(runtime) {
+	if (runtime.env.NO_UPDATE_NOTIFIER !== void 0) return false;
+	if (isTestRuntime(runtime.env) && runtime.env.PRISMA_CLI_TEST_ENABLE_UPDATE_CHECK !== "1") return false;
+	if (runtime.env.CI || runtime.env.GITHUB_ACTIONS) return false;
+	if (!runtime.stderr.isTTY) return false;
+	if (runtime.argv.includes("--json") || runtime.argv.includes("--quiet") || runtime.argv.includes("-q")) return false;
+	if (runtime.argv.includes("--version")) return false;
+	return true;
+}
+function shouldNotify(state) {
+	return !state.notifiedAt || isAtLeastIntervalAgo(state.notifiedAt);
+}
+async function scheduleRemoteDiscovery(runtime, store, state, cacheDir) {
+	if (state?.checkedAt && !isAtLeastIntervalAgo(state.checkedAt)) return;
+	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await store.write({
+		...state,
+		packageName: "@prisma/cli",
+		installedVersion: getCliVersion(),
+		checkedAt
+	});
+	if (isTestRuntime(runtime.env)) return;
+	const entrypoint = process.argv[1];
+	if (!entrypoint) return;
+	spawn(process.execPath, [entrypoint], {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			PRISMA_CLI_RUN_UPDATE_CHECK_WORKER: "1",
+			PRISMA_CLI_UPDATE_CHECK_DIR: cacheDir,
+			PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION: getCliVersion(),
+			PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL: runtime.env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL ?? REGISTRY_URL
+		}
+	}).unref();
+}
+function selectUpdateInstruction(env, processArgv = process.argv) {
+	const entrypoint = (processArgv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	const userAgent = env.npm_config_user_agent?.toLowerCase() ?? "";
+	if (isEphemeralInvocation(entrypoint, env.npm_lifecycle_event?.toLowerCase() ?? "")) return docsInstruction();
+	if (entrypoint.includes("/node_modules/.bin/")) {
+		if (userAgent.startsWith("pnpm")) return commandInstruction("pnpm add -D @prisma/cli@latest");
+		if (userAgent.startsWith("bun")) return commandInstruction("bun add -d @prisma/cli@latest");
+		if (userAgent.startsWith("npm")) return commandInstruction("npm install --save-dev @prisma/cli@latest");
+	}
+	if (env.npm_config_global === "true" || isLikelyGlobalNpmEntrypoint(entrypoint)) return commandInstruction("npm install --global @prisma/cli@latest");
+	return docsInstruction();
+}
+function renderUpdateNotification(latestVersion, instruction) {
+	return [
+		`Update available: ${getCliName()} ${getCliVersion()} -> ${latestVersion}`,
+		renderUpdateInstruction(instruction),
+		""
+	].join("\n");
+}
+function renderUpdateInstruction(instruction) {
+	if (instruction.type === "command") return `Run ${instruction.value} to update.`;
+	return `See ${instruction.value} for update instructions.`;
+}
+function isEphemeralInvocation(entrypoint, lifecycle) {
+	return lifecycle === "npx" || lifecycle === "pnpx" || entrypoint.includes("/_npx/") || entrypoint.includes("/.bun/");
+}
+function isLikelyGlobalNpmEntrypoint(entrypoint) {
+	return /\/npm\/prisma-cli(\.cmd|\.exe)?$/.test(entrypoint) || /\/npm-global\/bin\/prisma-cli$/.test(entrypoint);
+}
+function commandInstruction(value) {
+	return {
+		type: "command",
+		value
+	};
+}
+function docsInstruction() {
+	return {
+		type: "docs",
+		value: FALLBACK_INSTALL_DOCS_URL
+	};
+}
+function resolveUpdateCheckCacheDir(runtime) {
+	const configured = runtime.env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Caches", "prisma-cli");
+	if (process.platform === "win32") {
+		const localAppData = runtime.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+		return path.join(localAppData, "prisma-cli", "cache");
+	}
+	const xdgCacheHome = runtime.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+	return path.join(xdgCacheHome, "prisma-cli");
+}
+function isTestRuntime(env) {
+	return env.VITEST !== void 0 || env.NODE_ENV === "test";
+}
+function isAtLeastIntervalAgo(value) {
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) || Date.now() - timestamp >= NOTIFICATION_INTERVAL_MS;
+}
+function isInstalledVersionStale(installedVersion, latestVersion) {
+	const installed = parseVersion(installedVersion);
+	const latest = parseVersion(latestVersion);
+	if (!installed || !latest) return false;
+	return compareVersions(installed, latest) < 0;
+}
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4]?.split(".") ?? []
+	};
+}
+function compareVersions(left, right) {
+	for (const key of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const diff = left[key] - right[key];
+		if (diff !== 0) return diff;
+	}
+	return comparePrerelease(left.prerelease, right.prerelease);
+}
+function comparePrerelease(left, right) {
+	if (left.length === 0 && right.length === 0) return 0;
+	if (left.length === 0) return 1;
+	if (right.length === 0) return -1;
+	const count = Math.max(left.length, right.length);
+	for (let index = 0; index < count; index += 1) {
+		const leftPart = left[index];
+		const rightPart = right[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		const diff = comparePrereleasePart(leftPart, rightPart);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+function comparePrereleasePart(left, right) {
+	const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+	const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+	if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+	if (leftNumber !== null) return -1;
+	if (rightNumber !== null) return 1;
+	return left.localeCompare(right);
+}
+async function fetchLatestVersion(registryUrl, fetchImpl) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+	try {
+		const response = await fetchImpl(registryUrl, {
+			signal: controller.signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const latest = (await response.json())["dist-tags"]?.latest;
+		return typeof latest === "string" ? latest : null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+export { maybeWriteCachedUpdateNotification, runUpdateDiscoveryWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.51.1",
+  "version": "3.0.0-dev.53.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {