@prisma/cli 2.20.0 → 3.0.0-alpha.0

package/dist/lib/app/preview-build.js

@@ -0,0 +1,283 @@
+import { resolveBunEntrypoint } from "./bun-project.js";
+import path from "node:path";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { BunBuild } from "@prisma/compute-sdk";
+//#region src/lib/app/preview-build.ts
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+var PreviewBuildStrategy = class {
+	#appPath;
+	#entrypoint;
+	#buildType;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#entrypoint = options.entrypoint;
+		this.#buildType = options.buildType ?? "auto";
+	}
+	async canBuild() {
+		const { strategy } = await resolvePreviewBuildStrategy({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return strategy.canBuild();
+	}
+	async execute() {
+		const { artifact } = await executePreviewBuild({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return artifact;
+	}
+};
+async function executePreviewBuild(options) {
+	const { strategy, buildType } = await resolvePreviewBuildStrategy({
+		appPath: options.appPath,
+		entrypoint: options.entrypoint,
+		buildType: options.buildType ?? "auto"
+	});
+	const artifact = await strategy.execute();
+	try {
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
+		return {
+			artifact,
+			buildType
+		};
+	} catch (error) {
+		await artifact.cleanup?.().catch(() => void 0);
+		throw error;
+	}
+}
+async function resolvePreviewBuildStrategy(options) {
+	if (options.buildType === "nextjs") return {
+		buildType: "nextjs",
+		strategy: new PreviewNextjsBuild({ appPath: options.appPath })
+	};
+	if (options.buildType === "bun") {
+		const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+		return {
+			buildType: "bun",
+			strategy: new BunBuild({
+				appPath: options.appPath,
+				entrypoint
+			})
+		};
+	}
+	const nextjsStrategy = new PreviewNextjsBuild({ appPath: options.appPath });
+	if (await nextjsStrategy.canBuild()) return {
+		buildType: "nextjs",
+		strategy: nextjsStrategy
+	};
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+	return {
+		buildType: "bun",
+		strategy: new BunBuild({
+			appPath: options.appPath,
+			entrypoint
+		})
+	};
+}
+var PreviewNextjsBuild = class {
+	#appPath;
+	constructor(options) {
+		this.#appPath = options.appPath;
+	}
+	async canBuild() {
+		return await this.#hasNextConfig() || await this.#hasNextDependency();
+	}
+	async execute() {
+		await this.#runBuild();
+		const standaloneDir = path.join(this.#appPath, ".next", "standalone");
+		if (!(await stat(standaloneDir).catch(() => null))?.isDirectory()) throw new Error("Next.js build did not produce standalone output. Add output: \"standalone\" to your next.config file.");
+		const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await stageNextjsStandaloneArtifact({
+				standaloneDir,
+				artifactDir,
+				appPath: this.#appPath
+			});
+			const publicDir = path.join(this.#appPath, "public");
+			if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), { recursive: true });
+			const staticDir = path.join(this.#appPath, ".next", "static");
+			if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), { recursive: true });
+			return {
+				directory: artifactDir,
+				entrypoint: "server.js",
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+	async #hasNextConfig() {
+		let entries;
+		try {
+			entries = await readdir(this.#appPath);
+		} catch {
+			return false;
+		}
+		return entries.some((entry) => NEXT_CONFIG_FILENAMES.includes(entry));
+	}
+	async #hasNextDependency() {
+		const packageJsonPath = path.join(this.#appPath, "package.json");
+		let content;
+		try {
+			content = await readFile(packageJsonPath, "utf8");
+		} catch {
+			return false;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch {
+			return false;
+		}
+		const deps = isRecord(parsed.dependencies) ? parsed.dependencies : {};
+		const devDeps = isRecord(parsed.devDependencies) ? parsed.devDependencies : {};
+		return "next" in deps || "next" in devDeps;
+	}
+	async #runBuild() {
+		const candidates = [
+			{
+				command: path.join(this.#appPath, "node_modules", ".bin", "next"),
+				args: ["build"]
+			},
+			{
+				command: "npx",
+				args: ["next", "build"]
+			},
+			{
+				command: "bunx",
+				args: ["next", "build"]
+			}
+		];
+		for (const { command, args } of candidates) try {
+			await exec(command, args, this.#appPath);
+			return;
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
+			throw error;
+		}
+		throw new Error("Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
+	}
+};
+async function stageNextjsStandaloneArtifact(options) {
+	const standaloneRoot = path.resolve(options.standaloneDir);
+	await copyPathMaterializingSymlinks(standaloneRoot, path.resolve(options.artifactDir), {
+		standaloneRoot,
+		appRoot: path.resolve(options.appPath)
+	});
+}
+async function normalizeArtifactSymlinks(artifactDir, appPath) {
+	const normalizedArtifactDir = path.resolve(artifactDir);
+	const normalizedAppPath = path.resolve(appPath);
+	await walkDirectory(normalizedArtifactDir);
+	async function walkDirectory(directory) {
+		const entries = await readdir(directory, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await walkDirectory(fullPath);
+				continue;
+			}
+			if (!entry.isSymbolicLink()) continue;
+			const target = await readlink(fullPath);
+			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
+			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
+			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+			const targetStat = await stat(resolvedTarget);
+			await rm(fullPath, {
+				force: true,
+				recursive: true
+			});
+			await cp(resolvedTarget, fullPath, {
+				recursive: targetStat.isDirectory(),
+				dereference: true
+			});
+			if (targetStat.isDirectory()) await walkDirectory(fullPath);
+		}
+	}
+}
+function isPathWithin(rootPath, candidatePath) {
+	const relativePath = path.relative(rootPath, candidatePath);
+	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
+	const sourceStat = await lstat(sourcePath);
+	if (sourceStat.isSymbolicLink()) {
+		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		return;
+	}
+	if (sourceStat.isDirectory()) {
+		await mkdir(destinationPath, { recursive: true });
+		const entries = await readdir(sourcePath, { withFileTypes: true });
+		for (const entry of entries) await copyPathMaterializingSymlinks(path.join(sourcePath, entry.name), path.join(destinationPath, entry.name), options);
+		return;
+	}
+	if (sourceStat.isFile()) {
+		await mkdir(path.dirname(destinationPath), { recursive: true });
+		await copyFile(sourcePath, destinationPath);
+		await chmod(destinationPath, sourceStat.mode);
+	}
+}
+async function resolveSymlinkTarget(symlinkPath, options) {
+	const linkTarget = await readlink(symlinkPath);
+	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
+	if (await pathExists(resolvedTarget)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+		return resolvedTarget;
+	}
+	if (isPathWithin(options.standaloneRoot, resolvedTarget)) {
+		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
+		if (await pathExists(fallbackTarget)) return fallbackTarget;
+	}
+	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
+}
+async function directoryExists(dirPath) {
+	return (await stat(dirPath).catch(() => null))?.isDirectory() ?? false;
+}
+function exec(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		execFile(command, args, { cwd }, (error, _stdout, stderr) => {
+			if (error) {
+				if ("code" in error && error.code === "ENOENT") {
+					reject(Object.assign(/* @__PURE__ */ new Error(`${command} not found`), { code: "ENOENT" }));
+					return;
+				}
+				const message = stderr.trim() || error.message;
+				reject(/* @__PURE__ */ new Error(`Next.js build failed:\n${message}`));
+				return;
+			}
+			resolve();
+		});
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+async function pathExists(targetPath) {
+	try {
+		await stat(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { PreviewBuildStrategy, executePreviewBuild };

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

@@ -0,0 +1,38 @@
+import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+//#region src/lib/app/preview-interaction.ts
+const CREATE_NEW_APP = "__create_new_app__";
+const PREVIEW_DEFAULT_REGION = "eu-central-1";
+function createPreviewDeployInteraction(context) {
+	return {
+		async selectService(services) {
+			const sorted = services.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+			const selection = await selectPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "Select an app",
+				choices: [...sorted.map((service) => ({
+					label: service.name,
+					value: service.id
+				})), {
+					label: "Create a new app",
+					value: CREATE_NEW_APP
+				}]
+			});
+			return selection === CREATE_NEW_APP ? null : selection;
+		},
+		async provideServiceName() {
+			return textPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "App name",
+				placeholder: "hello-world",
+				validate: (value) => !value?.trim() ? "App name is required" : void 0
+			}).then((value) => value.trim());
+		},
+		async selectRegion(_regions) {
+			return PREVIEW_DEFAULT_REGION;
+		}
+	};
+}
+//#endregion
+export { PREVIEW_DEFAULT_REGION, createPreviewDeployInteraction };

package/dist/lib/app/preview-progress.js

@@ -0,0 +1,139 @@
+//#region src/lib/app/preview-progress.ts
+function createPreviewDeployProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onBuildStart() {
+			write("Building application...");
+		},
+		onBuildComplete() {
+			write("Build complete.");
+		},
+		onArchiveCreating() {
+			write("Creating deployment artifact...");
+		},
+		onArchiveReady(byteLength) {
+			write(`Artifact ready (${(byteLength / 1024).toFixed(1)} KB).`);
+		},
+		onVersionCreated(versionId) {
+			write(`Deployment ${versionId} created.`);
+		},
+		onUploadComplete() {
+			write("Upload complete.");
+		},
+		onStartRequested() {
+			write("Starting deployment...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onRunning(url) {
+			if (url) {
+				write(`Deployment is running at ${url}.`);
+				return;
+			}
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		},
+		onOldVersionStopping(versionId) {
+			write(`Stopping previous deployment ${versionId}...`);
+		},
+		onOldVersionStopped(versionId) {
+			write(`Previous deployment ${versionId} stopped.`);
+		},
+		onOldVersionStopFailed(versionId) {
+			write(`Failed to stop previous deployment ${versionId} (non-fatal).`);
+		},
+		onOldVersionDeleting(versionId) {
+			write(`Deleting previous deployment ${versionId}...`);
+		},
+		onOldVersionDeleted(versionId) {
+			write(`Previous deployment ${versionId} deleted.`);
+		},
+		onOldVersionDeleteFailed(versionId) {
+			write(`Failed to delete previous deployment ${versionId} (non-fatal).`);
+		},
+		onCleanupDanglingVersion(versionId) {
+			write(`Cleaning up deployment ${versionId}...`);
+		},
+		onCleanupDanglingVersionComplete(versionId) {
+			write(`Deployment ${versionId} cleaned up.`);
+		},
+		onCleanupDanglingVersionFailed(versionId) {
+			write(`Failed to clean up deployment ${versionId}.`);
+		}
+	};
+}
+function createPreviewPromoteProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onVersionStarting(versionId) {
+			write(`Starting deployment ${versionId}...`);
+		},
+		onVersionStartRequested() {
+			write("Requesting deployment start...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onVersionRunning() {
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		}
+	};
+}
+function createPreviewUpdateEnvProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onVersionCreated(versionId) {
+			write(`Creating updated deployment ${versionId}...`);
+		},
+		onStartRequested() {
+			write("Starting deployment...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onRunning(url) {
+			if (url) {
+				write(`Deployment is running at ${url}.`);
+				return;
+			}
+			write("Deployment is running.");
+		}
+	};
+}
+//#endregion
+export { createPreviewDeployProgress, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };

package/dist/lib/app/preview-provider.js

@@ -0,0 +1,232 @@
+import { envVarNames } from "./env-vars.js";
+import { PreviewBuildStrategy } from "./preview-build.js";
+import path from "node:path";
+import { ApiError, ComputeClient } from "@prisma/compute-sdk";
+//#region src/lib/app/preview-provider.ts
+function createPreviewAppProvider(client) {
+	const sdk = new ComputeClient(client);
+	return {
+		async createProject(options) {
+			const projectResult = await sdk.createProject({ name: options.name });
+			if (projectResult.isErr()) throw new Error(projectResult.error.message);
+			return {
+				id: projectResult.value.id,
+				name: projectResult.value.name
+			};
+		},
+		async listApps(projectId) {
+			const servicesResult = await sdk.listServices({ projectId });
+			if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+			return (await Promise.all(servicesResult.value.map(async (service) => {
+				const detailResult = await sdk.showService({ serviceId: service.id });
+				return detailResult.isOk() ? detailResult.value : {
+					id: service.id,
+					name: service.name,
+					region: service.region,
+					latestVersionId: null,
+					serviceEndpointDomain: void 0
+				};
+			}))).map((service) => ({
+				id: service.id,
+				name: service.name,
+				region: service.region ?? null,
+				liveDeploymentId: service.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
+			}));
+		},
+		async removeApp(appId) {
+			const appResult = await sdk.showService({ serviceId: appId });
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			const destroyResult = await sdk.destroyService({
+				serviceId: appId,
+				keepService: false,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3
+			});
+			if (destroyResult.isErr()) throw new Error(destroyResult.error.message);
+			return {
+				id: appResult.value.id,
+				name: appResult.value.name
+			};
+		},
+		async promoteDeployment(options) {
+			const promoteResult = await sdk.promote({
+				serviceId: options.appId,
+				versionId: options.deploymentId,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.progress
+			});
+			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
+		},
+		async deployApp(options) {
+			const deployResult = await sdk.deploy({
+				strategy: new PreviewBuildStrategy({
+					appPath: path.resolve(options.cwd),
+					entrypoint: options.entrypoint,
+					buildType: options.buildType
+				}),
+				projectId: options.projectId,
+				serviceId: options.appId,
+				serviceName: options.appName,
+				region: options.region,
+				portMapping: options.portMapping,
+				envVars: options.envVars,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				interaction: options.interaction,
+				progress: options.progress
+			});
+			if (deployResult.isErr()) throw new Error(deployResult.error.message);
+			const deployed = deployResult.value;
+			return {
+				projectId: deployed.projectId,
+				app: {
+					id: deployed.serviceId,
+					name: deployed.serviceName,
+					region: deployed.region ?? null,
+					liveDeploymentId: deployed.versionId,
+					liveUrl: toAbsoluteUrl(deployed.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: deployed.versionId,
+					status: "running",
+					url: toAbsoluteUrl(deployed.serviceEndpointDomain ?? deployed.versionEndpointDomain ?? null)
+				}
+			};
+		},
+		async updateAppEnv(options) {
+			const updateResult = await sdk.updateEnv({
+				serviceId: options.appId,
+				envVars: options.envVars,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.progress
+			});
+			if (updateResult.isErr()) throw new Error(updateResult.error.message);
+			const promoteResult = await sdk.promote({
+				serviceId: options.appId,
+				versionId: updateResult.value.versionId,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.promoteProgress
+			});
+			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({ serviceId: options.appId }), sdk.showVersion({ versionId: updateResult.value.versionId })]);
+			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
+			if (versionResult.isErr()) throw new Error(versionResult.error.message);
+			return {
+				projectId: updateResult.value.projectId,
+				app: {
+					id: serviceResult.value.id,
+					name: serviceResult.value.name,
+					region: serviceResult.value.region ?? null,
+					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: versionResult.value.id,
+					status: versionResult.value.status,
+					createdAt: versionResult.value.createdAt,
+					url: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? versionResult.value.previewDomain ?? null),
+					live: true
+				},
+				variables: envVarNames(versionResult.value.envVars)
+			};
+		},
+		async listAppEnvNames(options) {
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({ serviceId: options.appId }), sdk.showVersion({ versionId: options.deploymentId })]);
+			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
+			if (versionResult.isErr()) throw new Error(versionResult.error.message);
+			return {
+				projectId: serviceResult.value.projectId,
+				app: {
+					id: serviceResult.value.id,
+					name: serviceResult.value.name,
+					region: serviceResult.value.region ?? null,
+					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: versionResult.value.id,
+					status: versionResult.value.status,
+					createdAt: versionResult.value.createdAt,
+					url: toAbsoluteUrl(versionResult.value.previewDomain ?? null),
+					live: serviceResult.value.latestVersionId === versionResult.value.id
+				},
+				variables: envVarNames(versionResult.value.envVars)
+			};
+		},
+		async listDeployments(appId) {
+			const [appResult, versionsResult] = await Promise.all([sdk.showService({ serviceId: appId }), sdk.listVersions({ serviceId: appId })]);
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			return {
+				app: {
+					id: appResult.value.id,
+					name: appResult.value.name,
+					region: appResult.value.region ?? null,
+					liveDeploymentId: appResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(appResult.value.serviceEndpointDomain ?? null)
+				},
+				deployments: versionsResult.value.slice().sort((left, right) => {
+					const byDate = right.createdAt.localeCompare(left.createdAt);
+					return byDate !== 0 ? byDate : right.id.localeCompare(left.id);
+				}).map((deployment) => ({
+					id: deployment.id,
+					status: deployment.status,
+					createdAt: deployment.createdAt,
+					url: toAbsoluteUrl(deployment.previewDomain ?? null),
+					live: null
+				}))
+			};
+		},
+		async showDeployment(deploymentId) {
+			const deploymentResult = await sdk.showVersion({ versionId: deploymentId });
+			if (deploymentResult.isErr()) {
+				if (ApiError.is(deploymentResult.error) && deploymentResult.error.statusCode === 404) return null;
+				throw new Error(deploymentResult.error.message);
+			}
+			return {
+				app: await findAppForDeployment(sdk, deploymentId),
+				deployment: {
+					id: deploymentResult.value.id,
+					status: deploymentResult.value.status,
+					createdAt: deploymentResult.value.createdAt,
+					url: toAbsoluteUrl(deploymentResult.value.previewDomain ?? null),
+					live: null
+				}
+			};
+		}
+	};
+}
+async function findAppForDeployment(sdk, deploymentId) {
+	const projectsResult = await sdk.listProjects();
+	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
+	for (const project of projectsResult.value) {
+		const servicesResult = await sdk.listServices({ projectId: project.id });
+		if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+		for (const service of servicesResult.value) {
+			const detailResult = await sdk.showService({ serviceId: service.id });
+			if (detailResult.isErr()) throw new Error(detailResult.error.message);
+			const app = {
+				id: detailResult.value.id,
+				name: detailResult.value.name,
+				region: detailResult.value.region ?? null,
+				liveDeploymentId: detailResult.value.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(detailResult.value.serviceEndpointDomain ?? null)
+			};
+			if (app.liveDeploymentId === deploymentId) return app;
+			const versionsResult = await sdk.listVersions({ serviceId: service.id });
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			if (versionsResult.value.some((version) => version.id === deploymentId)) return app;
+		}
+	}
+	return null;
+}
+function toAbsoluteUrl(url) {
+	if (!url) return null;
+	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
+}
+//#endregion
+export { createPreviewAppProvider };