@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/lib/auth/auth-ops.js

@@ -24,20 +24,21 @@ function workspaceIdFromClaims(claims) {
 	const id = sub.slice(10).trim();
 	return id.length > 0 ? id : null;
 }
-async function performLogin(env) {
+async function performLogin(env, signal) {
 	await login({
-		tokenStorage: new FileTokenStorage(env),
-		env
+		tokenStorage: new FileTokenStorage(env, signal),
+		env,
+		signal
 	});
 }
-async function readAuthState(env) {
+async function readAuthState(env, signal) {
 	const rawServiceToken = env[SERVICE_TOKEN_ENV_VAR];
 	if (rawServiceToken !== void 0) {
 		const serviceToken = rawServiceToken.trim();
 		if (serviceToken.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
-		return readServiceTokenAuthState(serviceToken, env);
+		return readServiceTokenAuthState(serviceToken, env, signal);
 	}
-	const tokens = await new FileTokenStorage(env).getTokens();
+	const tokens = await new FileTokenStorage(env, signal).getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
@@ -45,20 +46,21 @@ async function readAuthState(env) {
 		workspace: null,
 		credential: null
 	};
-	const client = await requireComputeAuth(env);
-	const currentPrincipal = await readCurrentPrincipalAuthState(client);
+	const client = await requireComputeAuth(env, signal);
+	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
 	if (currentPrincipal) return currentPrincipal;
 	const claims = decodeJwtPayload(tokens.accessToken);
 	return buildAuthState({
 		workspaceIdFromCredential: tokens.workspaceId,
 		claims,
 		env,
-		client
+		client,
+		signal
 	});
 }
-async function readServiceTokenAuthState(token, env) {
-	const client = await requireComputeAuth(env);
-	const currentPrincipal = await readCurrentPrincipalAuthState(client);
+async function readServiceTokenAuthState(token, env, signal) {
+	const client = await requireComputeAuth(env, signal);
+	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
 	if (currentPrincipal) return currentPrincipal;
 	const claims = decodeJwtPayload(token);
 	const workspaceId = workspaceIdFromClaims(claims);
@@ -73,15 +75,19 @@ async function readServiceTokenAuthState(token, env) {
 		workspaceIdFromCredential: workspaceId,
 		claims,
 		env,
-		client
+		client,
+		signal
 	});
 }
-async function buildAuthState({ workspaceIdFromCredential, claims, env, client }) {
+async function buildAuthState({ workspaceIdFromCredential, claims, env, client, signal }) {
 	let workspaceId = workspaceIdFromCredential;
 	let workspaceName = workspaceIdFromCredential;
-	client ??= await requireComputeAuth(env);
+	client ??= await requireComputeAuth(env, signal);
 	if (client) try {
-		const { data, response } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: workspaceIdFromCredential } } });
+		const { data, response } = await client.GET("/v1/workspaces/{id}", {
+			params: { path: { id: workspaceIdFromCredential } },
+			signal
+		});
 		if (response?.status === 401) return {
 			authenticated: false,
 			provider: null,
@@ -94,7 +100,9 @@ async function buildAuthState({ workspaceIdFromCredential, claims, env, client }
 			workspaceName = data.data.id;
 		}
 		if (data?.data?.name) workspaceName = data.data.name;
-	} catch {}
+	} catch {
+		signal?.throwIfAborted();
+	}
 	const email = emailFromClaims(claims);
 	return {
 		authenticated: true,
@@ -107,10 +115,10 @@ async function buildAuthState({ workspaceIdFromCredential, claims, env, client }
 		credential: null
 	};
 }
-async function readCurrentPrincipalAuthState(client) {
+async function readCurrentPrincipalAuthState(client, signal) {
 	if (!client) return null;
 	try {
-		const { data, response } = await client.GET("/v1/me");
+		const { data, response } = await client.GET("/v1/me", { signal });
 		if (response?.status === 401) return {
 			authenticated: false,
 			provider: null,
@@ -133,11 +141,12 @@ async function readCurrentPrincipalAuthState(client) {
 			credential: principal.credential
 		};
 	} catch {
+		signal?.throwIfAborted();
 		return null;
 	}
 }
-async function performLogout(env) {
-	await new FileTokenStorage(env).clearTokens();
+async function performLogout(env, signal) {
+	await new FileTokenStorage(env, signal).clearTokens();
 }
 //#endregion
 export { performLogin, performLogout, readAuthState };

package/dist/lib/auth/guard.js

@@ -11,7 +11,8 @@ import { createManagementApiClient, createManagementApiSdk } from "@prisma/manag
 *
 * Returns null if not authenticated.
 */
-async function requireComputeAuth(env = process.env) {
+async function requireComputeAuth(env = process.env, signal) {
+	signal?.throwIfAborted();
 	const rawToken = env[SERVICE_TOKEN_ENV_VAR];
 	if (rawToken !== void 0) {
 		const token = rawToken.trim();
@@ -21,7 +22,7 @@ async function requireComputeAuth(env = process.env) {
 			token
 		});
 	}
-	const tokenStorage = new FileTokenStorage(env);
+	const tokenStorage = new FileTokenStorage(env, signal);
 	if (!await tokenStorage.getTokens()) return null;
 	return createManagementApiSdk({
 		clientId: CLIENT_ID,

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,30 @@ async function login(options = {}) {
 			apiBaseUrl: options.apiBaseUrl,
 			authBaseUrl: options.authBaseUrl,
 			openUrl: options.openUrl,
-			env: options.env
+			env: options.env,
+			signal: options.signal,
+			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) => {
+			const onAbort = () => {
+				reject(options.signal?.reason);
+			};
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+			const settle = (callback) => {
+				options.signal?.removeEventListener("abort", onAbort);
+				callback();
+			};
 			server.on("request", async (req, res) => {
 				const url = new URL(`http://${state.host}${req.url}`);
 				if (url.pathname !== "/auth/callback") {
@@ -38,36 +64,94 @@ 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);
+					const workspaceName = await state.resolveWorkspaceName();
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.end(renderSuccessPage(workspaceName));
+					settle(resolve);
 				} catch (error) {
 					res.statusCode = 400;
 					const message = error instanceof Error ? error.message : String(error);
 					res.end(message);
-					reject(error);
+					settle(() => reject(error));
 					return;
 				}
-				const workspaceName = await state.resolveWorkspaceName();
-				res.setHeader("Content-Type", "text/html; charset=utf-8");
-				res.end(renderSuccessPage(workspaceName));
-				resolve();
 			});
 		});
-		await state.openLoginPage();
-		await authResult;
+		options.signal?.throwIfAborted();
+		const callbackResult = interactive ? Promise.race([httpResult, consumePastedCallback({
+			input,
+			output,
+			signal: pasteAbort.signal,
+			complete: completeOnce
+		})]) : httpResult;
+		await Promise.all([state.openLoginPage(interactive), callbackResult]);
 	} 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 (;;) {
+			const url = await readPastedCallbackUrl(rl, options);
+			if (url === null) return;
+			if (url === void 0) continue;
+			if (await tryCompletePastedCallback(url, options)) return;
+		}
+	} finally {
+		rl.close();
+	}
+}
+async function readPastedCallbackUrl(rl, options) {
+	let answer;
+	try {
+		answer = await rl.question("Paste the callback URL here: ", { signal: options.signal });
+	} catch (error) {
+		if (error?.name === "AbortError") return null;
+		throw error;
+	}
+	const trimmed = answer.trim().replace(/^["']|["']$/g, "");
+	try {
+		if (!trimmed) throw new Error("empty input");
+		return new URL(trimmed);
+	} catch {
+		options.output.write("That didn't look like a URL. Paste the full localhost callback URL and try again.\n");
+		return;
+	}
+}
+async function tryCompletePastedCallback(url, options) {
+	try {
+		await options.complete(url);
+		return true;
+	} 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`);
+		return false;
+	}
+}
 var LoginState = class {
 	latestVerifier;
 	latestState;
 	sdk;
 	openUrl;
 	tokenStorage;
+	output;
 	constructor(options) {
 		this.options = options;
-		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env, options.signal);
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
@@ -76,8 +160,10 @@ var LoginState = class {
 			authBaseUrl: options.authBaseUrl
 		});
 		this.openUrl = options.openUrl ?? open;
+		this.output = options.output;
 	}
-	async openLoginPage() {
+	async openLoginPage(interactive) {
+		this.options.signal?.throwIfAborted();
 		const { url, state, verifier } = await this.sdk.getLoginUrl({
 			scope: "workspace:admin offline_access",
 			additionalParams: {
@@ -88,7 +174,19 @@ var LoginState = class {
 		});
 		this.latestState = state;
 		this.latestVerifier = verifier;
-		await this.openUrl(url);
+		this.options.signal?.throwIfAborted();
+		if (interactive) this.printLoginInstructions(url);
+		try {
+			await this.openUrl(url);
+		} catch (error) {
+			if (!interactive) throw error;
+		}
+		this.options.signal?.throwIfAborted();
+	}
+	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");
@@ -115,10 +213,14 @@ var LoginState = class {
 		try {
 			const tokens = await this.tokenStorage.getTokens();
 			if (!tokens?.workspaceId) return null;
-			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
+			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", {
+				params: { path: { id: tokens.workspaceId } },
+				signal: this.options.signal
+			});
 			const name = data?.data?.name;
 			return typeof name === "string" && name.trim().length > 0 ? name.trim() : null;
 		} catch {
+			this.options.signal?.throwIfAborted();
 			return null;
 		}
 	}

package/dist/lib/database/provider.js

@@ -0,0 +1,167 @@
+import { CliError } from "../../shell/errors.js";
+//#region src/lib/database/provider.ts
+function createManagementDatabaseProvider(client) {
+	return {
+		async listDatabases(options) {
+			const databases = [];
+			let cursor;
+			while (true) {
+				const result = await client.GET("/v1/databases", {
+					params: { query: {
+						projectId: options.projectId,
+						branchGitName: options.branchName,
+						cursor
+					} },
+					signal: options.signal
+				});
+				if (result.error || !result.data) throw databaseApiError("Failed to list databases", result.response, result.error);
+				databases.push(...result.data.data);
+				if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+				cursor = result.data.pagination.nextCursor;
+			}
+			return databases.map((database) => normalizeDatabase(database, options.projectId));
+		},
+		async showDatabase(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.response?.status === 404) return null;
+			if (result.error || !result.data) throw databaseApiError("Failed to show database", result.response, result.error);
+			const database = result.data.data;
+			return normalizeDatabase(database, requireDatabaseProjectId(database, options?.projectId));
+		},
+		async createDatabase(options) {
+			const result = await client.POST("/v1/databases", {
+				body: {
+					projectId: options.projectId,
+					name: options.name,
+					source: { type: "empty" },
+					...options.branchName ? { branchGitName: options.branchName } : {},
+					...options.region ? { region: options.region } : {}
+				},
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to create database", result.response, result.error);
+			return normalizeCreatedDatabase(result.data.data, options.projectId);
+		},
+		async removeDatabase(databaseId, options) {
+			const result = await client.DELETE("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error) throw databaseApiError("Failed to remove database", result.response, result.error);
+		},
+		async listConnections(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to list database connections", result.response, result.error);
+			return result.data.data.map((connection) => normalizeConnection(connection, databaseId));
+		},
+		async createConnection(options) {
+			const result = await client.POST("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId: options.databaseId } },
+				body: { name: options.name },
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to create database connection", result.response, result.error);
+			return normalizeCreatedConnection(result.data.data, options.databaseId);
+		},
+		async removeConnection(connectionId, options) {
+			const result = await client.DELETE("/v1/connections/{id}", {
+				params: { path: { id: connectionId } },
+				signal: options?.signal
+			});
+			if (result.error) throw databaseApiError("Failed to remove database connection", result.response, result.error);
+		}
+	};
+}
+function normalizeDatabase(database, fallbackProjectId) {
+	return {
+		id: database.id,
+		name: database.name,
+		projectId: database.projectId ?? fallbackProjectId,
+		branchId: database.branchId ?? database.branch?.id ?? null,
+		branchName: database.branchGitName ?? database.branchName ?? database.branch?.gitName ?? database.branch?.name ?? null,
+		region: normalizeRegion(database),
+		status: database.status ?? null,
+		isDefault: database.isDefault ?? null,
+		createdAt: database.createdAt ?? null
+	};
+}
+function normalizeConnection(connection, fallbackDatabaseId) {
+	return {
+		id: connection.id,
+		name: connection.name ?? connection.id,
+		databaseId: connection.databaseId ?? fallbackDatabaseId,
+		createdAt: connection.createdAt ?? null
+	};
+}
+function normalizeCreatedDatabase(database, fallbackProjectId) {
+	const rawConnection = database.connections?.[0];
+	if (!rawConnection) throw new CliError({
+		code: "DATABASE_CONNECTION_MISSING",
+		domain: "database",
+		summary: "Created database did not return a connection string",
+		why: "The Management API created the database but did not include the one-time connection payload.",
+		fix: "Create a connection explicitly with prisma-cli database connection create <database>.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${database.id}`]
+	});
+	return {
+		database: normalizeDatabase(database, fallbackProjectId),
+		...normalizeCreatedConnection(rawConnection, database.id)
+	};
+}
+function normalizeCreatedConnection(connection, fallbackDatabaseId) {
+	const connectionString = extractConnectionString(connection);
+	if (!connectionString) throw new CliError({
+		code: "DATABASE_CONNECTION_STRING_MISSING",
+		domain: "database",
+		summary: "Created connection did not return a connection string",
+		why: "Database connection strings are one-time-view secrets, but the Management API did not include one in this create response.",
+		fix: "Create another database connection and store the returned URL immediately.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${fallbackDatabaseId}`]
+	});
+	return {
+		connection: normalizeConnection(connection, fallbackDatabaseId),
+		connectionString
+	};
+}
+function normalizeRegion(database) {
+	if (typeof database.region === "string") return database.region;
+	return database.region?.id ?? database.regionId ?? null;
+}
+function requireDatabaseProjectId(database, fallbackProjectId) {
+	const projectId = database.projectId ?? fallbackProjectId;
+	if (projectId) return projectId;
+	throw new CliError({
+		code: "DATABASE_API_ERROR",
+		domain: "database",
+		summary: "Database response did not include a project id",
+		why: "The Management API returned database metadata without project context.",
+		fix: "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function extractConnectionString(connection) {
+	return connection.endpoints?.pooled?.connectionString ?? connection.connectionString ?? connection.endpoints?.direct?.connectionString ?? connection.endpoints?.accelerate?.connectionString ?? null;
+}
+function databaseApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "DATABASE_API_ERROR",
+		domain: "database",
+		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 { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase };

package/dist/lib/diagnostics.js

@@ -0,0 +1,15 @@
+import { resolveLocalStateFilePath } from "../adapters/local-state.js";
+import { resolveStateDir } from "../shell/runtime.js";
+import { readLocalGitState } from "./git/local-status.js";
+//#region src/lib/diagnostics.ts
+async function collectCommandDiagnostics(context, options = {}) {
+	const stateDir = await resolveStateDir(context.runtime);
+	return {
+		cwd: context.runtime.cwd,
+		stateFilePath: resolveLocalStateFilePath(stateDir),
+		git: await readLocalGitState(context.runtime.cwd, context.runtime.signal),
+		durationMs: options.durationMs
+	};
+}
+//#endregion
+export { collectCommandDiagnostics };

package/dist/lib/fs/home-path.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+//#region src/lib/fs/home-path.ts
+/**
+* Shortens a path under the user's home directory to `~/...` for display,
+* posix-style on every platform. Falls back to the Windows home variables
+* when `HOME` is unset (native cmd/PowerShell sessions).
+*/
+function shortenHomePath(value, env) {
+	const resolved = path.resolve(value);
+	const home = resolveHomeDirectory(env);
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved).split(path.sep).join("/");
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
+function resolveHomeDirectory(env) {
+	if (env.HOME) return path.resolve(env.HOME);
+	if (env.USERPROFILE) return path.resolve(env.USERPROFILE);
+	if (env.HOMEDRIVE && env.HOMEPATH) return path.resolve(`${env.HOMEDRIVE}${env.HOMEPATH}`);
+	return null;
+}
+//#endregion
+export { shortenHomePath };

package/dist/lib/git/local-branch.js

@@ -0,0 +1,53 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/git/local-branch.ts
+/**
+* Resolves the checked-out branch the way git does: the nearest `.git`
+* (directory or worktree file) from `cwd` upward owns the answer, so
+* monorepo commands run from inside a package see the repository branch.
+* Returns null for detached HEAD or when no repository contains `cwd`.
+*/
+async function readLocalGitBranch(cwd, signal) {
+	for (let directory = path.resolve(cwd);;) {
+		const headPath = await resolveGitHeadPath(path.join(directory, ".git"), signal);
+		if (headPath) return readBranchFromHead(headPath, signal);
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+async function readBranchFromHead(headPath, signal) {
+	try {
+		const head = (await readFile(headPath, {
+			encoding: "utf8",
+			signal
+		})).trim();
+		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	return null;
+}
+async function resolveGitHeadPath(gitPath, signal) {
+	signal.throwIfAborted();
+	try {
+		const raw = await readFile(gitPath, {
+			encoding: "utf8",
+			signal
+		});
+		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	signal.throwIfAborted();
+	try {
+		await access(path.join(gitPath, "HEAD"));
+		signal.throwIfAborted();
+		return path.join(gitPath, "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+}
+//#endregion
+export { readLocalGitBranch };

package/dist/lib/git/local-status.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+//#region src/lib/git/local-status.ts
+async function readLocalGitState(cwd, signal) {
+	signal.throwIfAborted();
+	if ((await runGit(cwd, ["rev-parse", "--is-inside-work-tree"], signal))?.trim() !== "true") return null;
+	const [ref, sha, status] = await Promise.all([
+		runGit(cwd, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], signal),
+		runGit(cwd, [
+			"rev-parse",
+			"--short",
+			"HEAD"
+		], signal),
+		runGit(cwd, ["status", "--porcelain"], signal)
+	]);
+	return {
+		ref: cleanGitValue(ref),
+		sha: cleanGitValue(sha),
+		dirty: status === null ? null : status.trim().length > 0
+	};
+}
+function runGit(cwd, args, signal) {
+	return new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		execFile("git", args, {
+			cwd,
+			signal,
+			timeout: 2e3
+		}, (error, stdout) => {
+			if (signal.aborted) {
+				reject(error);
+				return;
+			}
+			if (error) {
+				resolve(null);
+				return;
+			}
+			resolve(stdout);
+		}).on("error", (error) => {
+			if (signal.aborted) {
+				reject(error);
+				return;
+			}
+			resolve(null);
+		});
+	});
+}
+function cleanGitValue(value) {
+	const cleaned = value?.trim();
+	return cleaned ? cleaned : null;
+}
+//#endregion
+export { readLocalGitState };

package/dist/lib/project/interactive-setup.js

@@ -36,7 +36,7 @@ async function promptForProjectSetupChoice(options) {
 		targetName: choice.project.name,
 		targetNameSource: "prompt"
 	};
-	const suggestedName = await inferTargetName(options.context.runtime.cwd);
+	const suggestedName = await inferTargetName(options.context.runtime.cwd, options.context.runtime.signal);
 	const rawName = await textPrompt({
 		input: options.context.runtime.stdin,
 		output: options.context.runtime.stderr,