@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/v8/sender.js

@@ -0,0 +1,192 @@
+import { t as isParentToSenderPayload } from "../payload-B88Qvzxk-CrtTXSOe.js";
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { determineAgent } from "@vercel/detect-agent";
+//#region ../cli-telemetry/dist/sender.js
+/**
+* Identify the runtime the sender is running in. Same-runtime as the
+* parent is a correctness requirement: the parent forked us via
+* `child_process.fork`, which inherits the parent's runtime. Detection
+* keys on the runtime-specific version field rather than env vars so a
+* spoofed env can't lie about the actual interpreter.
+*/
+function resolveRuntime(versions) {
+	if (versions.bun !== void 0) return {
+		name: "bun",
+		version: versions.bun
+	};
+	if (versions.deno !== void 0) return {
+		name: "deno",
+		version: versions.deno
+	};
+	return {
+		name: "node",
+		version: versions.node
+	};
+}
+const WHITESPACE = /\s+/;
+const SEMVER_RANGE_PREFIX = /^[\^~]/;
+/**
+* Parse `npm_config_user_agent` into a `<pm>/<version>` token. The
+* value, when present, looks like
+* `"pnpm/10.27.0 npm/? node/v24.13.0 darwin arm64"` — we take the first
+* whitespace-separated token. Any failure → `null`.
+*/
+function parsePackageManager(userAgent) {
+	if (userAgent === void 0) return null;
+	const first = userAgent.split(WHITESPACE)[0];
+	if (first === void 0 || first.length === 0) return null;
+	if (!first.includes("/")) return null;
+	return first;
+}
+/**
+* Read the user's project `package.json` and resolve a TypeScript
+* version from `devDependencies.typescript` (preferred) or
+* `dependencies.typescript`. Strips a leading `^` or `~` semver
+* prefix. Returns `null` on any failure mode — file missing,
+* unreadable, malformed JSON, key absent, not a string.
+*/
+function readTsVersionFromPackageJson(raw) {
+	if (raw === null) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const candidate = pickStringDep(parsed.devDependencies) ?? pickStringDep(parsed.dependencies);
+	if (candidate === null) return null;
+	return candidate.replace(SEMVER_RANGE_PREFIX, "");
+}
+function pickStringDep(deps) {
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return null;
+	const value = deps.typescript;
+	return typeof value === "string" ? value : null;
+}
+/**
+* Build the full backend event from the parent's payload, the
+* project-config slice, and the child's per-process snapshot. Pure
+* given a `projectConfig` + `EnrichEnvironment`.
+*/
+function buildTelemetryEvent(payload, projectConfig, env) {
+	const runtime = resolveRuntime(env.versions);
+	return {
+		installationId: payload.installationId,
+		version: payload.version,
+		command: payload.command,
+		flags: payload.flags,
+		runtimeName: runtime.name,
+		runtimeVersion: runtime.version,
+		os: env.platform,
+		arch: env.arch,
+		packageManager: parsePackageManager(env.env.npm_config_user_agent),
+		databaseTarget: projectConfig.databaseTarget,
+		tsVersion: readTsVersionFromPackageJson(env.readProjectPackageJson()),
+		agent: env.agent,
+		extensions: projectConfig.extensions
+	};
+}
+/**
+* Resolve the agent label for the telemetry event via
+* `@vercel/detect-agent`, collapsing its discriminated result to the
+* event's `string | null` shape. Any detection failure counts as
+* "no agent" — telemetry is best-effort and non-blocking.
+*/
+async function resolveAgentLabel() {
+	try {
+		const result = await determineAgent();
+		return result.isAgent ? result.agent.name : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Convenience for the sender entry: build the event from the live
+* `process` plus a real project-package.json reader, swallowing any
+* I/O errors in the file read.
+*
+* The project-config slice is payload-only: `databaseTarget` is the
+* parent's override when present (else `null`), and `extensions` is
+* always empty — there is no `prisma-next.config.*` in this product to
+* derive them from.
+*/
+async function buildTelemetryEventFromProcess(payload) {
+	return buildTelemetryEvent(payload, {
+		databaseTarget: payload.databaseTarget ?? null,
+		extensions: []
+	}, {
+		platform: process.platform,
+		arch: process.arch,
+		versions: process.versions,
+		env: process.env,
+		agent: await resolveAgentLabel(),
+		readProjectPackageJson: () => {
+			try {
+				return readFileSync(join(payload.projectRoot, "package.json"), "utf-8");
+			} catch {
+				return null;
+			}
+		}
+	});
+}
+/**
+* Sender script entry — forked into a detached child by the parent CLI via
+* `child_process.fork(senderPath, [], { detached: true, ... })`.
+*
+* Lifecycle:
+*   1. Wait for the parent's IPC `message` event carrying a
+*      `ParentToSenderPayload`.
+*   2. Enrich with the local-process probes (runtime, os, arch, agent,
+*      package manager, tsVersion).
+*   3. POST the event to the endpoint URL with a hard 1.5 s timeout.
+*   4. Exit 0 unconditionally — successful POST, network failure, server
+*      error, parse error of the response, anything else: same outcome.
+*
+* Every error is swallowed; the only escape valve for visibility is
+* `PRISMA_DEBUG=1`, which routes diagnostics to stderr. In normal
+* operation no telemetry-originating output ever reaches the user — the
+* parent's stdio map ignores our streams anyway, but stderr writes are
+* also held behind the debug flag so the same binary is safe to invoke
+* directly outside the spawn flow.
+*/
+const REQUEST_TIMEOUT_MS = 1500;
+function debugLog(message, error) {
+	if (process.env.PRISMA_DEBUG !== "1") return;
+	if (error !== void 0) process.stderr.write(`[cli-telemetry] ${message}: ${String(error)}\n`);
+	else process.stderr.write(`[cli-telemetry] ${message}\n`);
+}
+async function postEvent(payload) {
+	const event = await buildTelemetryEventFromProcess(payload);
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	try {
+		debugLog(`sent event: status=${(await fetch(payload.endpoint, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(event),
+			signal: controller.signal
+		})).status}`);
+	} catch (err) {
+		debugLog("send failed", err);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function exitClean() {
+	try {
+		process.disconnect?.();
+	} catch {}
+	process.exit(0);
+}
+process.once("message", (message) => {
+	if (!isParentToSenderPayload(message)) {
+		debugLog("received malformed payload; exiting");
+		exitClean();
+		return;
+	}
+	postEvent(message).catch((err) => debugLog("post threw", err)).finally(exitClean);
+});
+const SENDER_IDLE_EXIT_MS = REQUEST_TIMEOUT_MS * 2;
+setTimeout(exitClean, SENDER_IDLE_EXIT_MS).unref();
+//#endregion
+export {};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.97.1",
+  "version": "8.0.0-rc.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
-    "prisma-cli": "./dist/cli.js"
+    "prisma-cli": "./dist/v8/cli.js"
   },
   "exports": {
     "./package.json": "./package.json"
@@ -18,7 +18,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.18.0"
   },
   "keywords": [
     "prisma",
@@ -37,31 +37,39 @@
     "url": "https://github.com/prisma/prisma-cli/issues"
   },
   "license": "Apache-2.0",
-  "scripts": {
-    "build": "tsdown",
-    "prepack": "pnpm run build",
-    "test": "vitest run"
-  },
   "dependencies": {
-    "@clack/prompts": "^1.5.0",
-    "@prisma/compute-sdk": "^0.28.0",
+    "@clack/prompts": "1.5.0",
+    "@prisma/cli-engine": "8.0.0-rc.1",
+    "@prisma/composer": "0.6.0-dev.16",
+    "@prisma/compute-sdk": "0.39.0",
     "@prisma/credentials-store": "^7.8.0",
-    "@prisma/management-api-sdk": "^1.37.0",
+    "@prisma/management-api-sdk": "1.55.0",
+    "@prisma/orm-toolchain": "8.0.0-rc.1-dev.40",
+    "@vercel/detect-agent": "^1.2.3",
     "better-result": "^2.9.2",
     "colorette": "^2.0.20",
     "commander": "^14.0.3",
     "dotenv": "^17.4.2",
-    "magicast": "^0.5.3",
+    "execa": "^9.6.1",
     "open": "^11.0.0",
     "string-width": "^8.2.1",
     "strip-ansi": "^7.2.0",
     "wrap-ansi": "^10.0.0"
   },
   "devDependencies": {
+    "@repo/cli-telemetry": "8.0.0-rc.1",
+    "@repo/tsconfig": "8.0.0-rc.1",
     "@types/node": "^22.19.19",
     "tsdown": "^0.21.10",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check:grammar": "vitest run tests/v8-mount-coverage.test.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts"
   }
-}
+}

package/dist/adapters/mock-api.js

@@ -1,136 +0,0 @@
-import { readFile } from "node:fs/promises";
-//#region src/adapters/mock-api.ts
-var MockApi = class MockApi {
-	data;
-	constructor(data) {
-		this.data = data;
-	}
-	static async load(fixturePath, signal) {
-		signal?.throwIfAborted();
-		const raw = await readFile(fixturePath, {
-			encoding: "utf8",
-			signal
-		});
-		return new MockApi(JSON.parse(raw));
-	}
-	listProviders() {
-		return this.data.providers;
-	}
-	getProvider(providerId) {
-		return this.data.providers.find((provider) => provider.id === providerId);
-	}
-	listUsersForProvider(providerId) {
-		return this.data.users.filter((user) => user.providerIds.includes(providerId));
-	}
-	getUser(userId) {
-		return this.data.users.find((user) => user.id === userId);
-	}
-	getUserForProvider(providerId, userId) {
-		return this.listUsersForProvider(providerId).find((user) => user.id === userId);
-	}
-	listUserWorkspaces(userId) {
-		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
-		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
-	}
-	getWorkspace(workspaceId) {
-		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
-	}
-	getUserWorkspace(userId, workspaceId) {
-		return this.listUserWorkspaces(userId).find((workspace) => workspace.id === workspaceId);
-	}
-	listProjectsForWorkspace(workspaceId) {
-		return this.data.projects.filter((project) => project.workspaceId === workspaceId);
-	}
-	getProject(projectId) {
-		return this.data.projects.find((project) => project.id === projectId);
-	}
-	getProjectForWorkspace(workspaceId, projectId) {
-		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
-	}
-	listBranchesForProject(projectId) {
-		return this.data.branches.filter((branch) => branch.projectId === projectId);
-	}
-	getBranchForProject(projectId, name) {
-		return this.listBranchesForProject(projectId).find((branch) => branch.name === name);
-	}
-	getDeployment(deploymentId) {
-		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
-	}
-	listDatabasesForProject(projectId, branchName) {
-		return (this.data.databases ?? []).filter((database) => database.projectId === projectId && (!branchName || database.branchName === branchName));
-	}
-	getDatabase(databaseId) {
-		return (this.data.databases ?? []).find((database) => database.id === databaseId);
-	}
-	createDatabase(input) {
-		this.data.databases ??= [];
-		this.data.databaseConnections ??= [];
-		const database = {
-			id: `db_${this.data.databases.length + 1e3}`,
-			projectId: input.projectId,
-			branchId: input.branchName ? this.getBranchForProject(input.projectId, input.branchName)?.id ?? null : null,
-			branchName: input.branchName ?? null,
-			name: input.name,
-			region: input.region ?? null,
-			status: "ready",
-			isDefault: false,
-			createdAt: "2026-06-09T00:00:00.000Z"
-		};
-		const connectionString = `postgresql://${database.id}.example.prisma.io/postgres`;
-		const connection = {
-			id: `conn_${this.data.databaseConnections.length + 1e3}`,
-			databaseId: database.id,
-			name: "primary",
-			createdAt: "2026-06-09T00:00:00.000Z",
-			connectionString
-		};
-		this.data.databases.push(database);
-		this.data.databaseConnections.push(connection);
-		return {
-			database,
-			connection,
-			connectionString
-		};
-	}
-	removeDatabase(databaseId) {
-		this.data.databases ??= [];
-		this.data.databaseConnections ??= [];
-		const database = this.getDatabase(databaseId);
-		if (!database) return;
-		this.data.databases = this.data.databases.filter((candidate) => candidate.id !== databaseId);
-		this.data.databaseConnections = this.data.databaseConnections.filter((connection) => connection.databaseId !== databaseId);
-		return database;
-	}
-	listDatabaseConnections(databaseId) {
-		return (this.data.databaseConnections ?? []).filter((connection) => connection.databaseId === databaseId);
-	}
-	getDatabaseConnection(connectionId) {
-		return (this.data.databaseConnections ?? []).find((connection) => connection.id === connectionId);
-	}
-	createDatabaseConnection(input) {
-		if (!this.getDatabase(input.databaseId)) return;
-		this.data.databaseConnections ??= [];
-		const connectionString = `postgresql://${input.databaseId}-${this.data.databaseConnections.length + 1}.example.prisma.io/postgres`;
-		const connection = {
-			id: `conn_${this.data.databaseConnections.length + 1e3}`,
-			databaseId: input.databaseId,
-			name: input.name,
-			createdAt: "2026-06-09T00:00:00.000Z",
-			connectionString
-		};
-		this.data.databaseConnections.push(connection);
-		return {
-			connection,
-			connectionString
-		};
-	}
-	removeDatabaseConnection(connectionId) {
-		this.data.databaseConnections ??= [];
-		const connection = this.getDatabaseConnection(connectionId);
-		if (!connection) return;
-		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
-		return connection;
-	}
-};
-//#endregion
-export { MockApi };

package/dist/lib/app/app-interaction.js

@@ -1,5 +0,0 @@
-import "../../shell/prompt.js";
-//#region src/lib/app/app-interaction.ts
-const DEFAULT_REGION = "eu-central-1";
-//#endregion
-export { DEFAULT_REGION };

package/dist/shell/command-arguments.js

@@ -1,6 +0,0 @@
-//#region src/shell/command-arguments.ts
-function formatCommandArgument(value) {
-	return /^[A-Za-z0-9._/-]+$/.test(value) && !value.startsWith("-") ? value : `'${value.replace(/'/g, "'\\''")}'`;
-}
-//#endregion
-export { formatCommandArgument };

package/dist/use-cases/auth.js

@@ -1,145 +0,0 @@
-import { authRequiredError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError } from "../shell/errors.js";
-//#region src/use-cases/auth.ts
-function createAuthUseCases(dependencies) {
-	return {
-		whoami: () => resolveCurrentAuthState(dependencies),
-		login: async (selection) => {
-			await dependencies.sessionGateway.writeAuthSession({
-				provider: selection.provider,
-				userId: selection.userId,
-				workspaceId: selection.workspaceId
-			});
-			return resolveCurrentAuthState(dependencies);
-		},
-		logout: async () => {
-			await dependencies.sessionGateway.clearAuthSession();
-			return resolveCurrentAuthState(dependencies);
-		},
-		listWorkspaces: async () => {
-			const session = await dependencies.sessionGateway.readAuthSession();
-			if (!session) return {
-				authSource: "none",
-				activeWorkspace: null,
-				workspaces: []
-			};
-			const workspaces = dependencies.identityGateway.listUserWorkspaces(session.userId);
-			return {
-				authSource: "oauth",
-				activeWorkspace: workspaces.find((workspace) => workspace.id === session.workspaceId) ?? null,
-				workspaces: workspaces.map((workspace) => ({
-					...workspace,
-					credentialWorkspaceId: workspace.id,
-					active: workspace.id === session.workspaceId,
-					source: "oauth",
-					switchable: true,
-					lastSeenAt: null
-				}))
-			};
-		},
-		useWorkspace: async (workspaceRef) => {
-			const session = await dependencies.sessionGateway.readAuthSession();
-			if (!session) throw authRequiredError(["prisma-cli auth login"]);
-			const ref = workspaceRef.trim();
-			const matches = dependencies.identityGateway.listUserWorkspaces(session.userId).filter((workspace) => workspaceMatchesRef(workspace, ref));
-			if (matches.length === 0) throw workspaceNotAuthenticatedError(workspaceRef);
-			if (matches.length > 1) throw workspaceAmbiguousError(workspaceRef, matches.map((workspace) => ({
-				id: workspace.id,
-				name: workspace.name,
-				credentialWorkspaceId: workspace.id
-			})));
-			const selected = matches[0];
-			const previousWorkspace = dependencies.identityGateway.getWorkspace(session.workspaceId) ?? null;
-			await dependencies.sessionGateway.writeAuthSession({
-				...session,
-				workspaceId: selected.id
-			});
-			return {
-				previousWorkspace,
-				workspace: selected
-			};
-		},
-		logoutWorkspace: async (workspaceRef) => {
-			const session = await dependencies.sessionGateway.readAuthSession();
-			if (!session) throw workspaceNotAuthenticatedError(workspaceRef);
-			const ref = workspaceRef.trim();
-			const matches = dependencies.identityGateway.listUserWorkspaces(session.userId).filter((workspace) => workspaceMatchesRef(workspace, ref));
-			if (matches.length === 0) throw workspaceNotAuthenticatedError(workspaceRef);
-			if (matches.length > 1) throw workspaceAmbiguousError(workspaceRef, matches.map((workspace) => ({
-				id: workspace.id,
-				name: workspace.name,
-				credentialWorkspaceId: workspace.id
-			})));
-			const workspace = matches[0];
-			const wasActive = workspace.id === session.workspaceId;
-			const activeWorkspace = wasActive ? null : dependencies.identityGateway.getWorkspace(session.workspaceId) ?? null;
-			if (wasActive) await dependencies.sessionGateway.clearAuthSession();
-			return {
-				workspace,
-				wasActive,
-				activeWorkspace
-			};
-		},
-		listProviders: async () => dependencies.identityGateway.listProviders(),
-		resolveProvider: async (providerId) => {
-			const provider = dependencies.identityGateway.getProvider(providerId);
-			if (!provider) throw usageError("Login requires a valid mock provider", `The mock provider "${providerId}" does not exist.`, "Use --provider github or --provider google.", ["prisma-cli auth login"], "auth");
-			return provider;
-		},
-		listUsersForProvider: async (providerId) => {
-			const users = dependencies.identityGateway.listUsersForProvider(providerId);
-			if (users.length === 0) throw usageError("Login requires a valid mock user", `No mock users support provider "${providerId}".`, "Update the fixture data or choose a different provider.", ["prisma-cli auth login"], "auth");
-			return users;
-		},
-		resolveUserForProvider: async (providerId, userId) => {
-			const user = dependencies.identityGateway.getUserForProvider(providerId, userId);
-			if (!user) throw usageError("Login requires a valid mock user", `The mock user "${userId}" is not available for provider "${providerId}".`, "Choose a user that supports the selected provider.", ["prisma-cli auth login"], "auth");
-			return user;
-		},
-		listWorkspacesForUser: async (userId) => dependencies.identityGateway.listUserWorkspaces(userId),
-		resolveWorkspaceForUser: async (userId, workspaceId) => {
-			const workspace = dependencies.identityGateway.getUserWorkspace(userId, workspaceId);
-			if (!workspace) throw usageError("Login requires a valid mock workspace", `The mock workspace "${workspaceId}" is not available for the selected user.`, "Choose a workspace that the selected user can access.", ["prisma-cli auth login"], "auth");
-			return workspace;
-		}
-	};
-}
-function workspaceMatchesRef(workspace, ref) {
-	return workspace.id === ref || workspace.name.toLowerCase() === ref.toLowerCase();
-}
-async function resolveCurrentAuthState(dependencies) {
-	const session = await dependencies.sessionGateway.readAuthSession();
-	if (!session) return {
-		authenticated: false,
-		provider: null,
-		user: null,
-		workspace: null,
-		credential: null
-	};
-	const provider = dependencies.identityGateway.getProvider(session.provider);
-	const user = dependencies.identityGateway.getUser(session.userId);
-	const workspace = dependencies.identityGateway.getWorkspace(session.workspaceId);
-	if (!provider || !user || !workspace) return {
-		authenticated: false,
-		provider: null,
-		user: null,
-		workspace: null,
-		credential: null
-	};
-	return {
-		authenticated: true,
-		provider: provider.id,
-		user: {
-			id: user.id,
-			email: user.email,
-			name: user.name
-		},
-		workspace,
-		credential: {
-			type: "oauth",
-			id: null,
-			name: null
-		}
-	};
-}
-//#endregion
-export { createAuthUseCases };

package/dist/use-cases/branch.js

@@ -1,47 +0,0 @@
-//#region src/use-cases/branch.ts
-function createBranchUseCases(dependencies) {
-	return { list: async () => {
-		const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
-		if (!projectId) return {
-			projectId: "",
-			projectName: "not resolved",
-			branches: []
-		};
-		const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
-		return {
-			projectId,
-			projectName: resolveProjectName(dependencies.projectGateway, projectId) ?? "not resolved",
-			branches: buildBranchSummaries(remoteBranches)
-		};
-	} };
-}
-function resolveProjectName(projectGateway, projectId) {
-	if (!projectId) return null;
-	return projectGateway.getProject(projectId)?.name ?? null;
-}
-async function listRemoteBranches(branchGateway, projectId) {
-	if (!projectId) return [];
-	return branchGateway.listBranchesForProject(projectId);
-}
-function buildBranchSummaries(remoteBranches) {
-	return sortBranches(remoteBranches.map((branch) => ({
-		id: branch.id,
-		name: branch.name,
-		role: branch.role,
-		envMap: branch.role
-	})));
-}
-function sortBranches(branches) {
-	return branches.slice().sort((left, right) => {
-		const leftRank = branchOrder(left);
-		const rightRank = branchOrder(right);
-		if (leftRank !== rightRank) return leftRank - rightRank;
-		return left.name.localeCompare(right.name);
-	});
-}
-function branchOrder(branch) {
-	if (branch.role === "production") return 0;
-	return 1;
-}
-//#endregion
-export { createBranchUseCases };

package/dist/use-cases/create-cli-gateways.js

@@ -1,68 +0,0 @@
-//#region src/use-cases/create-cli-gateways.ts
-function createCliUseCaseGateways(context) {
-	return {
-		identityGateway: {
-			listProviders: () => context.api.listProviders(),
-			getProvider: (providerId) => context.api.getProvider(providerId),
-			listUsersForProvider: (providerId) => context.api.listUsersForProvider(providerId).map(toAuthUser),
-			getUser: (userId) => {
-				const user = context.api.getUser(userId);
-				return user ? toAuthUser(user) : void 0;
-			},
-			getUserForProvider: (providerId, userId) => {
-				const user = context.api.getUserForProvider(providerId, userId);
-				return user ? toAuthUser(user) : void 0;
-			},
-			listUserWorkspaces: (userId) => context.api.listUserWorkspaces(userId).map(toAuthWorkspace),
-			getWorkspace: (workspaceId) => {
-				const workspace = context.api.getWorkspace(workspaceId);
-				return workspace ? toAuthWorkspace(workspace) : void 0;
-			},
-			getUserWorkspace: (userId, workspaceId) => {
-				const workspace = context.api.getUserWorkspace(userId, workspaceId);
-				return workspace ? toAuthWorkspace(workspace) : void 0;
-			}
-		},
-		projectGateway: {
-			listProjectsForWorkspace: (workspaceId) => context.api.listProjectsForWorkspace(workspaceId),
-			getProject: (projectId) => context.api.getProject(projectId),
-			getProjectForWorkspace: (workspaceId, projectId) => context.api.getProjectForWorkspace(workspaceId, projectId)
-		},
-		branchGateway: {
-			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId),
-			getBranchForProject: (projectId, name) => {
-				return context.api.getBranchForProject(projectId, name);
-			},
-			getDeployment: (deploymentId) => context.api.getDeployment(deploymentId)
-		},
-		projectStateGateway: { readRememberedProjectId: async () => {
-			return (await context.stateStore.readLastResolvedProject())?.id ?? null;
-		} },
-		sessionGateway: {
-			readAuthSession: async () => {
-				return (await context.stateStore.read()).auth;
-			},
-			writeAuthSession: async (session) => {
-				await context.stateStore.setAuthSession(session);
-			},
-			clearAuthSession: async () => {
-				await context.stateStore.clearAuthSession();
-			}
-		}
-	};
-}
-function toAuthUser(user) {
-	return {
-		id: user.id,
-		name: user.name,
-		email: user.email
-	};
-}
-function toAuthWorkspace(workspace) {
-	return {
-		id: workspace.id,
-		name: workspace.name
-	};
-}
-//#endregion
-export { createCliUseCaseGateways };