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

package/dist/controllers/project.js

@@ -1,17 +1,18 @@
+import { formatCommandArgument } from "../shell/command-arguments.js";
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
-import { formatCommandArgument } from "../shell/command-arguments.js";
+import { createAppProvider } from "../lib/app/app-provider.js";
 import { readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
+import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectResolutionErrorToCliError, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
 import { createProjectUseCases } from "../use-cases/project.js";
+import { matchError } from "better-result";
 import open from "open";
 //#region src/controllers/project.ts
 const GITHUB_INSTALL_POLL_INTERVAL_MS = 2e3;
@@ -19,21 +20,34 @@ const GITHUB_INSTALL_POLL_TIMEOUT_MS = 12e4;
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
-async function readProjectListLocalBinding(cwd, workspace, projects) {
-	const pin = await readLocalResolutionPin(cwd);
+async function readProjectListLocalBinding(cwd, workspace, projects, signal) {
+	const pinResult = await readLocalResolutionPin(cwd, signal);
+	if (pinResult.isErr()) return localPinReadErrorToInvalidLocalBinding(pinResult.error);
+	const pin = pinResult.value;
 	if (pin.kind === "present") return pin.pin.workspaceId === workspace.id && projects.some((project) => project.id === pin.pin.projectId) ? { status: "linked" } : { status: "invalid" };
-	if (pin.kind === "invalid") return { status: "invalid" };
 	return { status: "not-linked" };
 }
+function localPinReadErrorToInvalidLocalBinding(error) {
+	return matchError(error, {
+		LocalResolutionPinInvalidJsonError: () => ({ status: "invalid" }),
+		LocalResolutionPinInvalidShapeError: () => ({ status: "invalid" }),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 async function runProjectList(context) {
 	const authState = await requireAuthenticatedAuthState(context);
 	const workspace = authState.workspace;
 	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env);
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		const projects = sortProjects(await listRealWorkspaceProjects(client, workspace));
-		const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, projects);
+		const projects = sortProjects(await listRealWorkspaceProjects(client, workspace, context.runtime.signal));
+		const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, projects, context.runtime.signal);
 		const nextActions = buildProjectListNextActions(localBinding);
 		return {
 			command: "project.list",
@@ -48,7 +62,7 @@ async function runProjectList(context) {
 		};
 	}
 	const result = await createProjectUseCases(createCliUseCaseGateways(context)).list(authState);
-	const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, result.projects);
+	const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, result.projects, context.runtime.signal);
 	const nextActions = buildProjectListNextActions(localBinding);
 	return {
 		command: "project.list",
@@ -88,23 +102,28 @@ async function runProjectCreate(context, projectName) {
 	if (!workspace) throw workspaceRequiredError();
 	if (!isValidProjectSetupName(projectName)) throw projectSetupNameRequiredError("project create");
 	if (!isRealMode(context)) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	const provider = createPreviewAppProvider(client);
+	const provider = createAppProvider(client);
 	const name = projectName.trim();
-	const created = await provider.createProject({ name }).catch((error) => {
+	const created = await provider.createProject({
+		name,
+		signal: context.runtime.signal
+	}).catch((error) => {
 		throw projectCreateFailedError(error, name, workspace, {
 			nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"],
 			permissionFix: "Grant the token permission to create Projects in this workspace, or link an existing Project.",
 			fallbackFix: "Retry the command, or choose an existing Project with prisma-cli project link <id-or-name>."
 		});
 	});
+	const bindResult = await bindProjectToDirectory(context, workspace, {
+		id: created.id,
+		name: created.name
+	}, "created");
+	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
 	return {
 		command: "project.create",
-		result: await bindProjectToDirectory(context, workspace, {
-			id: created.id,
-			name: created.name
-		}, "created"),
+		result: bindResult.value,
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
@@ -115,13 +134,13 @@ async function runProjectLink(context, projectRef) {
 	let provider = null;
 	let projects;
 	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env);
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		provider = createPreviewAppProvider(client);
-		projects = await listRealWorkspaceProjects(client, workspace);
+		provider = createAppProvider(client);
+		projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
 	} else projects = listFixtureWorkspaceProjects(context, workspace);
 	let result;
-	if (projectRef?.trim()) result = await bindProjectToDirectory(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked");
+	if (projectRef?.trim()) result = await requireProjectDirectoryBinding(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked");
 	else if (canPrompt(context) && !context.flags.yes) result = await resolveInteractiveProjectLinkSetup(context, workspace, projects, provider);
 	else throw await projectLinkTargetRequiredError(context, projects);
 	return {
@@ -137,7 +156,7 @@ async function resolveInteractiveProjectLinkSetup(context, workspace, projects,
 		projects,
 		createProject: (projectName) => {
 			if (!provider) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
-			return createProjectForLinkSetup(provider, projectName, workspace);
+			return createProjectForLinkSetup(provider, projectName, workspace, context.runtime.signal);
 		},
 		cancel: {
 			why: "Project link needs a Project before it can continue.",
@@ -145,10 +164,18 @@ async function resolveInteractiveProjectLinkSetup(context, workspace, projects,
 			nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli project create <name>"]
 		}
 	});
-	return bindProjectToDirectory(context, workspace, setup.project, setup.action);
-}
-async function createProjectForLinkSetup(provider, projectName, workspace) {
-	const created = await provider.createProject({ name: projectName }).catch((error) => {
+	return requireProjectDirectoryBinding(context, workspace, setup.project, setup.action);
+}
+async function requireProjectDirectoryBinding(context, workspace, project, action) {
+	const bindResult = await bindProjectToDirectory(context, workspace, project, action);
+	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
+	return bindResult.value;
+}
+async function createProjectForLinkSetup(provider, projectName, workspace, signal) {
+	const created = await provider.createProject({
+		name: projectName,
+		signal
+	}).catch((error) => {
 		throw projectCreateFailedError(error, projectName, workspace, {
 			nextSteps: [
 				"prisma-cli project list",
@@ -166,7 +193,7 @@ async function createProjectForLinkSetup(provider, projectName, workspace) {
 	};
 }
 async function projectLinkTargetRequiredError(context, projects) {
-	const suggestedName = await inferTargetName(context.runtime.cwd);
+	const suggestedName = await inferTargetName(context.runtime.cwd, context.runtime.signal);
 	const createCommand = `prisma-cli project create ${formatCommandArgument(suggestedName.name)}`;
 	const recoveryCommands = ["prisma-cli project link <id-or-name>", createCommand];
 	return new CliError({
@@ -194,12 +221,12 @@ async function runGitConnect(context, gitUrl, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env);
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
 		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git connect");
 		const repository = await resolveRepositoryForConnect(context, gitUrl);
 		const api = client;
-		const existing = await readFirstSourceRepository(api, target.project.id);
+		const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
 		if (existing) {
 			const existingConnection = toRepositoryConnection(existing);
 			if (repositoryFullNamesMatch(existingConnection.repository.fullName, repository.fullName)) return {
@@ -214,12 +241,15 @@ async function runGitConnect(context, gitUrl, options = {}) {
 			throw repoAlreadyConnectedError(existingConnection.repository.fullName);
 		}
 		const resolvedRepository = await resolveInstalledRepository(context, api, workspace.id, repository);
-		const { data, error, response } = await api.POST("/v1/source-repositories", { body: {
-			projectId: target.project.id,
-			provider: "github",
-			providerRepositoryId: resolvedRepository.repository.id,
-			installationId: resolvedRepository.installation.id
-		} });
+		const { data, error, response } = await api.POST("/v1/source-repositories", {
+			body: {
+				projectId: target.project.id,
+				provider: "github",
+				providerRepositoryId: resolvedRepository.repository.id,
+				installationId: resolvedRepository.installation.id
+			},
+			signal: context.runtime.signal
+		});
 		if (error || !data) throw repoConnectionApiError("Failed to connect GitHub repository", response, error);
 		return {
 			command: "git.connect",
@@ -262,13 +292,16 @@ async function runGitDisconnect(context, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env);
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
 		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git disconnect");
 		const api = client;
-		const existing = await readFirstSourceRepository(api, target.project.id);
+		const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
 		if (!existing) throw repoNotConnectedError();
-		const { error, response } = await api.DELETE("/v1/source-repositories/{id}", { params: { path: { id: existing.id } } });
+		const { error, response } = await api.DELETE("/v1/source-repositories/{id}", {
+			params: { path: { id: existing.id } },
+			signal: context.runtime.signal
+		});
 		if (error) throw repoConnectionApiError("Failed to disconnect GitHub repository", response, error);
 		return {
 			command: "git.disconnect",
@@ -295,47 +328,55 @@ async function runGitDisconnect(context, options = {}) {
 	};
 }
 async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	return inspectProjectBinding({
+	const result = await inspectProjectBinding({
 		context,
 		workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, workspace),
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
 		commandName: "project show"
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveRequiredProjectInRealMode(context, workspace, explicitProject, commandName) {
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	return resolveProjectTarget({
+	const result = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, workspace),
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
 		commandName
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
-	return inspectProjectBinding({
+	const result = await inspectProjectBinding({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
 		commandName: "project show"
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveRequiredProjectInFixtureMode(context, workspace, explicitProject, commandName) {
-	return resolveProjectTarget({
+	const result = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
 		commandName
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
-async function listRealWorkspaceProjects(client, workspace) {
-	const { data } = await client.GET("/v1/projects", {});
+async function listRealWorkspaceProjects(client, workspace, signal) {
+	const { data } = await client.GET("/v1/projects", { signal });
 	return sortProjects((data?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
 		id: project.id,
 		name: project.name,
@@ -357,16 +398,16 @@ function listFixtureWorkspaceProjects(context, workspace) {
 	})));
 }
 async function resolveRepositoryForConnect(context, gitUrl) {
-	const remoteUrl = gitUrl ?? await readGitOriginRemote(context.runtime.cwd);
+	const remoteUrl = gitUrl ?? await readGitOriginRemote(context.runtime.cwd, context.runtime.signal);
 	if (!remoteUrl) throw usageError("Repository connection requires a GitHub repository URL", "No git-url was provided and the local repo does not have an origin remote.", "Pass a GitHub repository URL, or add a GitHub origin remote and rerun prisma-cli git connect.", ["prisma-cli git connect git@github.com:prisma/prisma-cli.git"], "project");
 	const repository = parseGitHubRepositoryUrl(remoteUrl);
 	if (!repository) throw unsupportedRepositoryProviderError();
 	return repository;
 }
 async function resolveInstalledRepository(context, api, workspaceId, repository) {
-	const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId), repository);
+	const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId, context.runtime.signal), repository, context.runtime.signal);
 	if (lookup.match) return lookup.match;
-	const installUrl = await createGitHubInstallIntent(api, workspaceId);
+	const installUrl = await createGitHubInstallIntent(api, workspaceId, context.runtime.signal);
 	const canWait = canPrompt(context);
 	const opened = await openInstallUrlIfInteractive(context, installUrl);
 	if (!canWait) {
@@ -379,11 +420,11 @@ async function resolveInstalledRepository(context, api, workspaceId, repository)
 	if (result.inspectableInstallationCount > 0) throw repoNotAccessibleError(repository, installUrl, opened);
 	throw repoInstallationRequiredError(repository, installUrl, opened);
 }
-async function findRepositoryInInstallations(api, installations, repository) {
+async function findRepositoryInInstallations(api, installations, repository, signal) {
 	let inspectableInstallationCount = 0;
 	for (const installation of installations) {
 		if (installation.provider !== "github" || installation.suspended) continue;
-		const matchedRepository = await findRepositoryInInstallationIfAvailable(api, installation.id, repository);
+		const matchedRepository = await findRepositoryInInstallationIfAvailable(api, installation.id, repository, signal);
 		if (matchedRepository === "unavailable") continue;
 		inspectableInstallationCount += 1;
 		if (matchedRepository) return {
@@ -405,7 +446,8 @@ async function waitForInstalledRepository(context, api, workspaceId, repository)
 	const deadline = Date.now() + timeoutMs;
 	let inspectableInstallationCount = 0;
 	while (Date.now() <= deadline) {
-		const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId), repository);
+		context.runtime.signal.throwIfAborted();
+		const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId, context.runtime.signal), repository, context.runtime.signal);
 		inspectableInstallationCount = lookup.inspectableInstallationCount;
 		if (lookup.match) return {
 			match: lookup.match,
@@ -413,7 +455,7 @@ async function waitForInstalledRepository(context, api, workspaceId, repository)
 		};
 		const remainingMs = deadline - Date.now();
 		if (remainingMs <= 0) break;
-		await sleep(Math.min(intervalMs, remainingMs));
+		await sleep(Math.min(intervalMs, remainingMs), context.runtime.signal);
 	}
 	return {
 		match: null,
@@ -431,37 +473,54 @@ function writeInstallWaitStatus(context, opened, installUrl) {
 	if (!opened) lines.push(installUrl);
 	context.output.stderr.write(`${lines.join("\n")}\n`);
 }
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms, signal) {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
-async function listScmInstallations(api, workspaceId) {
+async function listScmInstallations(api, workspaceId, signal) {
 	const installations = [];
 	let cursor;
 	const seenCursors = /* @__PURE__ */ new Set();
 	do {
-		const { data, error, response } = await api.GET("/v1/scm-installations", { params: { query: {
-			workspaceId,
-			limit: 100,
-			...cursor ? { cursor } : {}
-		} } });
+		const { data, error, response } = await api.GET("/v1/scm-installations", {
+			params: { query: {
+				workspaceId,
+				limit: 100,
+				...cursor ? { cursor } : {}
+			} },
+			signal
+		});
 		if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub App installations", response, error);
 		installations.push(...data.data);
 		cursor = readNextPaginationCursor(data.pagination, seenCursors, "Failed to inspect GitHub App installations", response);
 	} while (cursor);
 	return installations;
 }
-async function findRepositoryInInstallation(api, installationId, repository) {
+async function findRepositoryInInstallation(api, installationId, repository, signal) {
 	const expectedFullName = repository.fullName.toLowerCase();
 	let cursor;
 	const seenCursors = /* @__PURE__ */ new Set();
 	do {
-		const { data, error, response } = await api.GET("/v1/scm-installations/{installationId}/repositories", { params: {
-			path: { installationId },
-			query: {
-				limit: 100,
-				...cursor ? { cursor } : {}
-			}
-		} });
+		const { data, error, response } = await api.GET("/v1/scm-installations/{installationId}/repositories", {
+			params: {
+				path: { installationId },
+				query: {
+					limit: 100,
+					...cursor ? { cursor } : {}
+				}
+			},
+			signal
+		});
 		if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub repositories", response, error);
 		const matchedRepository = data.data.find((candidate) => candidate.fullName.toLowerCase() === expectedFullName);
 		if (matchedRepository) return matchedRepository;
@@ -476,10 +535,11 @@ function readNextPaginationCursor(pagination, seenCursors, summary, response) {
 	seenCursors.add(nextCursor);
 	return nextCursor;
 }
-async function findRepositoryInInstallationIfAvailable(api, installationId, repository) {
+async function findRepositoryInInstallationIfAvailable(api, installationId, repository, signal) {
 	try {
-		return await findRepositoryInInstallation(api, installationId, repository);
+		return await findRepositoryInInstallation(api, installationId, repository, signal);
 	} catch (error) {
+		if (signal.aborted) throw error;
 		if (isUnavailableScmInstallationError(error)) return "unavailable";
 		throw error;
 	}
@@ -488,28 +548,37 @@ function isUnavailableScmInstallationError(error) {
 	if (!(error instanceof CliError) || error.code !== "REPO_CONNECTION_FAILED") return false;
 	return error.meta.status === 404 || error.meta.status === 422;
 }
-async function createGitHubInstallIntent(api, workspaceId) {
-	const { data, error, response } = await api.POST("/v1/scm-installations/install-intents", { body: {
-		provider: "github",
-		workspaceId
-	} });
+async function createGitHubInstallIntent(api, workspaceId, signal) {
+	const { data, error, response } = await api.POST("/v1/scm-installations/install-intents", {
+		body: {
+			provider: "github",
+			workspaceId
+		},
+		signal
+	});
 	if (error || !data) throw repoConnectionApiError("Failed to create GitHub App installation link", response, error);
 	return data.data.installUrl;
 }
 async function openInstallUrlIfInteractive(context, installUrl) {
 	if (!canPrompt(context)) return false;
 	try {
+		context.runtime.signal.throwIfAborted();
 		await open(installUrl);
+		context.runtime.signal.throwIfAborted();
 		return true;
-	} catch {
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
 		return false;
 	}
 }
-async function readFirstSourceRepository(api, projectId) {
-	const { data, error, response } = await api.GET("/v1/source-repositories", { params: { query: {
-		projectId,
-		limit: 1
-	} } });
+async function readFirstSourceRepository(api, projectId, signal) {
+	const { data, error, response } = await api.GET("/v1/source-repositories", {
+		params: { query: {
+			projectId,
+			limit: 1
+		} },
+		signal
+	});
 	if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub repository connection", response, error);
 	return data.data[0] ?? null;
 }
@@ -659,4 +728,4 @@ function repoConnectionFixForStatus(status) {
 	return "Re-run with --trace for the underlying API response details.";
 }
 //#endregion
-export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };
+export { listFixtureWorkspaceProjects, listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };

package/dist/controllers/select-prompt-port.js

@@ -4,6 +4,7 @@ function createSelectPromptPort(context) {
 	return { select: ({ message, choices }) => selectPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message,
 		choices
 	}) };

package/dist/lib/agent/cli-command.js

@@ -0,0 +1,17 @@
+import { formatPrismaCliCommand } from "../../shell/cli-command.js";
+import { resolvePackageRunner, resolvePackageRunnerSync } from "./package-manager.js";
+//#region src/lib/agent/cli-command.ts
+async function resolvePrismaCliPackageCommandFormatter(options) {
+	return createPrismaCliPackageCommandFormatter(await resolvePackageRunner(options));
+}
+async function resolvePrismaCliPackageCommand(options) {
+	return (await resolvePrismaCliPackageCommandFormatter(options))(options.args);
+}
+function resolvePrismaCliPackageCommandFormatterSync(cwd) {
+	return createPrismaCliPackageCommandFormatter(resolvePackageRunnerSync(cwd));
+}
+function createPrismaCliPackageCommandFormatter(packageRunner) {
+	return (args) => formatPrismaCliCommand(args, { packageRunner });
+}
+//#endregion
+export { resolvePrismaCliPackageCommand, resolvePrismaCliPackageCommandFormatterSync };

package/dist/lib/agent/constants.js

@@ -0,0 +1,12 @@
+//#region src/lib/agent/constants.ts
+const PRISMA_SKILLS_SOURCE = "prisma/skills";
+const PRISMA_SKILLS_LOCK_FILENAME = "skills-lock.json";
+const SKILLS_CLI_PACKAGE = "skills@latest";
+const DEFAULT_PRISMA_AGENT_SKILLS = ["*"];
+const PRISMA_COMPUTE_AGENT_SKILL = "prisma-compute";
+const DEFAULT_PRISMA_AGENT_TARGETS = ["codex", "claude-code"];
+const PRISMA_AGENT_INSTALL_ARGS = ["agent", "install"];
+const PRISMA_AGENT_UPDATE_ARGS = ["agent", "update"];
+const PRISMA_AGENT_STATUS_ARGS = ["agent", "status"];
+//#endregion
+export { DEFAULT_PRISMA_AGENT_SKILLS, DEFAULT_PRISMA_AGENT_TARGETS, PRISMA_AGENT_INSTALL_ARGS, PRISMA_AGENT_STATUS_ARGS, PRISMA_AGENT_UPDATE_ARGS, PRISMA_COMPUTE_AGENT_SKILL, PRISMA_SKILLS_LOCK_FILENAME, PRISMA_SKILLS_SOURCE, SKILLS_CLI_PACKAGE };

package/dist/lib/agent/package-manager.js

@@ -0,0 +1,99 @@
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+//#region src/lib/agent/package-manager.ts
+const LOCKFILE_PACKAGE_MANAGERS = [
+	{
+		packageManager: "bun",
+		fileNames: ["bun.lock", "bun.lockb"]
+	},
+	{
+		packageManager: "pnpm",
+		fileNames: ["pnpm-lock.yaml", "pnpm-workspace.yaml"]
+	},
+	{
+		packageManager: "yarn",
+		fileNames: ["yarn.lock"]
+	},
+	{
+		packageManager: "npm",
+		fileNames: ["package-lock.json", "npm-shrinkwrap.json"]
+	}
+];
+async function resolveSkillsPackageRunner(options) {
+	return resolvePackageRunner(options);
+}
+async function resolvePackageRunner(options) {
+	options.signal.throwIfAborted();
+	const packageManager = detectPackageManagerSync(options.cwd, options.signal) ?? "npm";
+	options.signal.throwIfAborted();
+	return packageRunnerForPackageManager(packageManager);
+}
+function resolvePackageRunnerSync(cwd) {
+	return packageRunnerForPackageManager(detectPackageManagerSync(cwd) ?? "npm");
+}
+function detectPackageManagerSync(cwd, signal) {
+	let directory = path.resolve(cwd);
+	while (true) {
+		signal?.throwIfAborted();
+		const packageJsonManager = readPackageJsonPackageManager(directory);
+		if (packageJsonManager) return packageJsonManager;
+		const lockfileManager = readLockfilePackageManager(directory, signal);
+		if (lockfileManager) return lockfileManager;
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+function readPackageJsonPackageManager(directory) {
+	const packageJsonPath = path.join(directory, "package.json");
+	let content;
+	try {
+		content = readFileSync(packageJsonPath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return null;
+		throw error;
+	}
+	try {
+		return parsePackageManager(JSON.parse(content).packageManager);
+	} catch {
+		return null;
+	}
+}
+function readLockfilePackageManager(directory, signal) {
+	for (const candidate of LOCKFILE_PACKAGE_MANAGERS) for (const fileName of candidate.fileNames) {
+		signal?.throwIfAborted();
+		if (fileExists(path.join(directory, fileName))) return candidate.packageManager;
+	}
+	return null;
+}
+function fileExists(filePath) {
+	try {
+		return statSync(filePath).isFile();
+	} catch (error) {
+		if (isMissingFileError(error)) return false;
+		throw error;
+	}
+}
+function parsePackageManager(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "bun" || normalized.startsWith("bun@")) return "bun";
+	if (normalized === "pnpm" || normalized.startsWith("pnpm@")) return "pnpm";
+	if (normalized === "yarn" || normalized.startsWith("yarn@")) return "yarn";
+	if (normalized === "npm" || normalized.startsWith("npm@")) return "npm";
+	return null;
+}
+function packageRunnerForPackageManager(packageManager) {
+	switch (packageManager) {
+		case "bun": return ["bunx"];
+		case "pnpm": return ["pnpm", "dlx"];
+		case "yarn": return ["yarn", "dlx"];
+		case "npm": return ["npx", "-y"];
+	}
+}
+function isMissingFileError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+//#endregion
+export { resolvePackageRunner, resolvePackageRunnerSync, resolveSkillsPackageRunner };