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

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

@@ -16,24 +16,28 @@ var PreviewBuildStrategy = class {
 	#appPath;
 	#entrypoint;
 	#buildType;
+	#signal;
 	constructor(options) {
 		this.#appPath = options.appPath;
 		this.#entrypoint = options.entrypoint;
 		this.#buildType = options.buildType ?? "auto";
+		this.#signal = options.signal;
 	}
-	async canBuild() {
+	async canBuild(signal = this.#signal) {
 		const { strategy } = await resolvePreviewBuildStrategy({
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
-			buildType: this.#buildType
+			buildType: this.#buildType,
+			signal
 		});
-		return strategy.canBuild();
+		return strategy.canBuild(signal);
 	}
-	async execute() {
+	async execute(signal = this.#signal) {
 		const { artifact } = await executePreviewBuild({
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
-			buildType: this.#buildType
+			buildType: this.#buildType,
+			signal
 		});
 		return artifact;
 	}
@@ -42,12 +46,13 @@ async function executePreviewBuild(options) {
 	const { strategy, buildType } = await resolvePreviewBuildStrategy({
 		appPath: options.appPath,
 		entrypoint: options.entrypoint,
-		buildType: options.buildType ?? "auto"
+		buildType: options.buildType ?? "auto",
+		signal: options.signal
 	});
-	const artifact = await strategy.execute();
+	const artifact = await strategy.execute(options.signal);
 	try {
-		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath);
-		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
+		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath, options.signal);
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath, options.signal);
 		return {
 			artifact,
 			buildType
@@ -62,7 +67,8 @@ async function resolvePreviewBuildStrategy(options) {
 		const strategy = await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType: options.buildType
+			buildType: options.buildType,
+			signal: options.signal
 		});
 		return {
 			buildType: options.buildType,
@@ -74,9 +80,10 @@ async function resolvePreviewBuildStrategy(options) {
 		const strategy = await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType
+			buildType,
+			signal: options.signal
 		});
-		if (await strategy.canBuild()) return {
+		if (await strategy.canBuild(options.signal)) return {
 			buildType,
 			strategy
 		};
@@ -86,7 +93,8 @@ async function resolvePreviewBuildStrategy(options) {
 		strategy: await createPreviewBuildStrategy({
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
-			buildType: "bun"
+			buildType: "bun",
+			signal: options.signal
 		})
 	};
 }
@@ -97,7 +105,7 @@ async function createPreviewBuildStrategy(options) {
 		case "astro": return new AstroBuild({ appPath: options.appPath });
 		case "tanstack-start": return new TanstackStartBuild({ appPath: options.appPath });
 		case "bun": {
-			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
 			return new BunBuild({
 				appPath: options.appPath,
 				entrypoint
@@ -112,74 +120,78 @@ async function stageNextjsStandaloneArtifact(options) {
 	await copyPathMaterializingSymlinks(standaloneRoot, artifactRoot, {
 		standaloneRoot,
 		appRoot,
-		sourceRoot: await resolveSourceRoot(appRoot)
+		sourceRoot: await resolveSourceRoot(appRoot, options.signal),
+		signal: options.signal
 	});
-	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"));
+	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"), options.signal);
 }
-async function restageNextjsArtifact(artifact, appPath) {
+async function restageNextjsArtifact(artifact, appPath, signal) {
 	const artifactDir = artifact.directory;
 	const standaloneDir = path.join(appPath, ".next", "standalone");
-	await rm(artifactDir, {
+	await unsupportedFilesystemBoundary(signal, () => rm(artifactDir, {
 		recursive: true,
 		force: true
-	});
+	}));
 	await stageNextjsStandaloneArtifact({
 		standaloneDir,
 		artifactDir,
-		appPath
+		appPath,
+		signal
 	});
 	const serverSubpath = nextjsServerSubpath(artifact.entrypoint);
 	const serverDir = serverSubpath ? path.join(artifactDir, serverSubpath) : artifactDir;
 	const publicDir = path.join(appPath, "public");
-	if (await directoryExists(publicDir)) await cp(publicDir, path.join(serverDir, "public"), {
+	if (await directoryExists(publicDir, signal)) await unsupportedFilesystemBoundary(signal, () => cp(publicDir, path.join(serverDir, "public"), {
 		recursive: true,
 		verbatimSymlinks: true
-	});
+	}));
 	const staticDir = path.join(appPath, ".next", "static");
-	if (await directoryExists(staticDir)) await cp(staticDir, path.join(serverDir, ".next", "static"), {
+	if (await directoryExists(staticDir, signal)) await unsupportedFilesystemBoundary(signal, () => cp(staticDir, path.join(serverDir, ".next", "static"), {
 		recursive: true,
 		verbatimSymlinks: true
-	});
+	}));
 }
 function nextjsServerSubpath(entrypoint) {
 	const dir = path.posix.dirname(entrypoint);
 	return dir === "." ? "" : dir;
 }
-async function hoistPnpmDependencies(nodeModulesDir) {
+async function hoistPnpmDependencies(nodeModulesDir, signal) {
 	const pnpmNodeModulesDir = path.join(nodeModulesDir, ".pnpm", "node_modules");
-	if (!await directoryExists(pnpmNodeModulesDir)) return;
-	const entries = await readdir(pnpmNodeModulesDir, { withFileTypes: true });
+	if (!await directoryExists(pnpmNodeModulesDir, signal)) return;
+	const entries = await unsupportedFilesystemBoundary(signal, () => readdir(pnpmNodeModulesDir, { withFileTypes: true }));
 	for (const entry of entries) {
 		const sourcePath = path.join(pnpmNodeModulesDir, entry.name);
 		if (entry.name.startsWith("@") && entry.isDirectory()) {
-			const scopedEntries = await readdir(sourcePath, { withFileTypes: true });
+			const scopedEntries = await unsupportedFilesystemBoundary(signal, () => readdir(sourcePath, { withFileTypes: true }));
 			for (const scopedEntry of scopedEntries) {
 				const scopedDestination = path.join(nodeModulesDir, entry.name, scopedEntry.name);
-				if (await pathExists(scopedDestination)) continue;
-				await mkdir(path.dirname(scopedDestination), { recursive: true });
+				if (await pathExists(scopedDestination, signal)) continue;
+				await unsupportedFilesystemBoundary(signal, () => mkdir(path.dirname(scopedDestination), { recursive: true }));
 				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
 					standaloneRoot: pnpmNodeModulesDir,
 					appRoot: nodeModulesDir,
-					sourceRoot: nodeModulesDir
+					sourceRoot: nodeModulesDir,
+					signal
 				});
 			}
 			continue;
 		}
 		const destinationPath = path.join(nodeModulesDir, entry.name);
-		if (await pathExists(destinationPath)) continue;
+		if (await pathExists(destinationPath, signal)) continue;
 		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
 			standaloneRoot: pnpmNodeModulesDir,
 			appRoot: nodeModulesDir,
-			sourceRoot: nodeModulesDir
+			sourceRoot: nodeModulesDir,
+			signal
 		});
 	}
 }
-async function normalizeArtifactSymlinks(artifactDir, appPath) {
+async function normalizeArtifactSymlinks(artifactDir, appPath, signal) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
 	await walkDirectory(normalizedArtifactDir);
 	async function walkDirectory(directory) {
-		const entries = await readdir(directory, { withFileTypes: true });
+		const entries = await unsupportedFilesystemBoundary(signal, () => readdir(directory, { withFileTypes: true }));
 		for (const entry of entries) {
 			const fullPath = path.join(directory, entry.name);
 			if (entry.isDirectory()) {
@@ -187,19 +199,19 @@ async function normalizeArtifactSymlinks(artifactDir, appPath) {
 				continue;
 			}
 			if (!entry.isSymbolicLink()) continue;
-			const target = await readlink(fullPath);
+			const target = await unsupportedFilesystemBoundary(signal, () => 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, {
+			const targetStat = await unsupportedFilesystemBoundary(signal, () => stat(resolvedTarget));
+			await unsupportedFilesystemBoundary(signal, () => rm(fullPath, {
 				force: true,
 				recursive: true
-			});
-			await cp(resolvedTarget, fullPath, {
+			}));
+			await unsupportedFilesystemBoundary(signal, () => cp(resolvedTarget, fullPath, {
 				recursive: targetStat.isDirectory(),
 				dereference: true
-			});
+			}));
 			if (targetStat.isDirectory()) await walkDirectory(fullPath);
 		}
 	}
@@ -208,8 +220,11 @@ function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
 }
+function isPathWithinWorkspaceDependency(sourceRoot, candidatePath) {
+	return isPathWithin(path.join(sourceRoot, "node_modules"), candidatePath);
+}
 async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
-	const sourceStat = await lstat(sourcePath);
+	const sourceStat = await unsupportedFilesystemBoundary(options.signal, () => lstat(sourcePath));
 	if (sourceStat.isSymbolicLink()) {
 		const resolvedTarget = await resolveSymlinkTarget(sourcePath, options);
 		if (resolvedTarget === null) return;
@@ -217,27 +232,27 @@ async function copyPathMaterializingSymlinks(sourcePath, destinationPath, option
 		return;
 	}
 	if (sourceStat.isDirectory()) {
-		await mkdir(destinationPath, { recursive: true });
-		const entries = await readdir(sourcePath, { withFileTypes: true });
+		await unsupportedFilesystemBoundary(options.signal, () => mkdir(destinationPath, { recursive: true }));
+		const entries = await unsupportedFilesystemBoundary(options.signal, () => 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);
+		await unsupportedFilesystemBoundary(options.signal, () => mkdir(path.dirname(destinationPath), { recursive: true }));
+		await unsupportedFilesystemBoundary(options.signal, () => copyFile(sourcePath, destinationPath));
+		await unsupportedFilesystemBoundary(options.signal, () => chmod(destinationPath, sourceStat.mode));
 	}
 }
 async function resolveSymlinkTarget(symlinkPath, options) {
-	const linkTarget = await readlink(symlinkPath);
+	const linkTarget = await unsupportedFilesystemBoundary(options.signal, () => readlink(symlinkPath));
 	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
-	if (await pathExists(resolvedTarget)) {
-		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithin(options.sourceRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+	if (await pathExists(resolvedTarget, options.signal)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithinWorkspaceDependency(options.sourceRoot, 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;
+		if (await pathExists(fallbackTarget, options.signal)) return fallbackTarget;
 	}
 	if (isPnpmHoistLink(symlinkPath)) return null;
 	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
@@ -247,38 +262,51 @@ function isPnpmHoistLink(symlinkPath) {
 	for (let i = 0; i < parts.length - 1; i++) if (parts[i] === ".pnpm" && parts[i + 1] === "node_modules") return true;
 	return false;
 }
-async function pathExists(targetPath) {
+async function pathExists(targetPath, signal) {
 	try {
-		await stat(targetPath);
+		await unsupportedFilesystemBoundary(signal, () => stat(targetPath));
 		return true;
-	} catch {
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
-async function directoryExists(targetPath) {
+async function directoryExists(targetPath, signal) {
 	try {
-		return (await stat(targetPath)).isDirectory();
-	} catch {
+		return (await unsupportedFilesystemBoundary(signal, () => stat(targetPath))).isDirectory();
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
-async function resolveSourceRoot(appRoot) {
+async function resolveSourceRoot(appRoot, signal) {
 	let current = path.resolve(appRoot);
 	while (true) {
-		if (await pathExists(path.join(current, ".git")) || await pathExists(path.join(current, "pnpm-workspace.yaml")) || await pathExists(path.join(current, "bun.lock")) || await pathExists(path.join(current, "bun.lockb")) || await packageJsonDeclaresWorkspaces(current)) return current;
+		if (await pathExists(path.join(current, ".git"), signal) || await pathExists(path.join(current, "pnpm-workspace.yaml"), signal) || await pathExists(path.join(current, "bun.lock"), signal) || await pathExists(path.join(current, "bun.lockb"), signal) || await packageJsonDeclaresWorkspaces(current, signal)) return current;
 		const parent = path.dirname(current);
 		if (parent === current) return path.resolve(appRoot);
 		current = parent;
 	}
 }
-async function packageJsonDeclaresWorkspaces(directory) {
+async function packageJsonDeclaresWorkspaces(directory, signal) {
+	signal?.throwIfAborted();
 	try {
-		const content = await readFile(path.join(directory, "package.json"), "utf8");
+		const content = await readFile(path.join(directory, "package.json"), {
+			encoding: "utf8",
+			signal
+		});
 		const parsed = JSON.parse(content);
 		return Boolean(parsed.workspaces);
-	} catch {
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return false;
 	}
 }
+async function unsupportedFilesystemBoundary(signal, operation) {
+	signal?.throwIfAborted();
+	const result = await operation();
+	signal?.throwIfAborted();
+	return result;
+}
 //#endregion
 export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };

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

@@ -19,7 +19,10 @@ function createPreviewAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
 		async createProject(options) {
-			const projectResult = await sdk.createProject({ name: options.name });
+			const projectResult = await sdk.createProject({
+				name: options.name,
+				signal: options.signal
+			});
 			if (projectResult.isErr()) throw new Error(projectResult.error.message);
 			return {
 				id: projectResult.value.id,
@@ -29,17 +32,22 @@ function createPreviewAppProvider(client, options) {
 		async listApps(projectId, options) {
 			return listComputeServices(client, {
 				projectId,
-				branchGitName: options?.branchName
+				branchGitName: options?.branchName,
+				signal: options?.signal
 			});
 		},
-		async removeApp(appId) {
-			const appResult = await sdk.showService({ serviceId: appId });
+		async removeApp(appId, options) {
+			const appResult = await sdk.showService({
+				serviceId: appId,
+				signal: options?.signal
+			});
 			if (appResult.isErr()) throw new Error(appResult.error.message);
 			const destroyResult = await sdk.destroyService({
 				serviceId: appId,
 				keepService: false,
 				timeoutSeconds: 120,
-				pollIntervalMs: 2e3
+				pollIntervalMs: 2e3,
+				signal: options?.signal
 			});
 			if (destroyResult.isErr()) throw new Error(destroyResult.error.message);
 			return {
@@ -47,17 +55,18 @@ function createPreviewAppProvider(client, options) {
 				name: appResult.value.name
 			};
 		},
-		async listDomains(appId) {
-			return listComputeServiceDomains(client, appId);
+		async listDomains(appId, options) {
+			return listComputeServiceDomains(client, appId, options?.signal);
 		},
 		async addDomain(options) {
 			const result = await client.POST("/v1/compute-services/{computeServiceId}/domains", {
 				params: { path: { computeServiceId: options.appId } },
-				body: { hostname: options.hostname }
+				body: { hostname: options.hostname },
+				signal: options.signal
 			});
 			if (result.error || !result.data) {
 				if (result.response.status === 409) {
-					const existing = (await listComputeServiceDomains(client, options.appId)).find((domain) => sameHostname(domain.hostname, options.hostname));
+					const existing = (await listComputeServiceDomains(client, options.appId, options.signal)).find((domain) => sameHostname(domain.hostname, options.hostname));
 					if (existing) return {
 						domain: existing,
 						existing: true
@@ -70,17 +79,26 @@ function createPreviewAppProvider(client, options) {
 				existing: false
 			};
 		},
-		async showDomain(domainId) {
-			const result = await client.GET("/v1/domains/{domainId}", { params: { path: { domainId } } });
+		async showDomain(domainId, options) {
+			const result = await client.GET("/v1/domains/{domainId}", {
+				params: { path: { domainId } },
+				signal: options?.signal
+			});
 			if (result.error || !result.data) throw domainApiCallError("Failed to show custom domain", result.response, result.error);
 			return normalizeDomainRecord(result.data.data);
 		},
-		async removeDomain(domainId) {
-			const result = await client.DELETE("/v1/domains/{domainId}", { params: { path: { domainId } } });
+		async removeDomain(domainId, options) {
+			const result = await client.DELETE("/v1/domains/{domainId}", {
+				params: { path: { domainId } },
+				signal: options?.signal
+			});
 			if (result.error) throw domainApiCallError("Failed to remove custom domain", result.response, result.error);
 		},
-		async retryDomain(domainId) {
-			const result = await client.POST("/v1/domains/{domainId}/retry", { params: { path: { domainId } } });
+		async retryDomain(domainId, options) {
+			const result = await client.POST("/v1/domains/{domainId}/retry", {
+				params: { path: { domainId } },
+				signal: options?.signal
+			});
 			if (result.error || !result.data) throw domainApiCallError("Failed to retry custom domain", result.response, result.error);
 			return normalizeDomainRecord(result.data.data);
 		},
@@ -90,6 +108,7 @@ function createPreviewAppProvider(client, options) {
 				versionId: options.deploymentId,
 				timeoutSeconds: 120,
 				pollIntervalMs: 2e3,
+				signal: options.signal,
 				progress: options.progress
 			});
 			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
@@ -103,7 +122,8 @@ function createPreviewAppProvider(client, options) {
 				projectId: options.projectId,
 				branchName: options.branchName,
 				appName: options.appName,
-				region: options.region
+				region: options.region,
+				signal: options.signal
 			}) : {
 				appId: void 0,
 				appName: options.appName,
@@ -113,7 +133,8 @@ function createPreviewAppProvider(client, options) {
 				strategy: new PreviewBuildStrategy({
 					appPath: path.resolve(options.cwd),
 					entrypoint: options.entrypoint,
-					buildType: options.buildType
+					buildType: options.buildType,
+					signal: options.signal
 				}),
 				projectId: options.projectId,
 				serviceId: resolvedApp.appId,
@@ -124,6 +145,7 @@ function createPreviewAppProvider(client, options) {
 				timeoutSeconds: 120,
 				pollIntervalMs: 2e3,
 				interaction: options.interaction,
+				signal: options.signal,
 				progress: options.progress
 			});
 			if (deployResult.isErr()) throw new Error(deployResult.error.message);
@@ -150,6 +172,7 @@ function createPreviewAppProvider(client, options) {
 				envVars: options.envVars,
 				timeoutSeconds: 120,
 				pollIntervalMs: 2e3,
+				signal: options.signal,
 				progress: options.progress
 			});
 			if (updateResult.isErr()) throw new Error(updateResult.error.message);
@@ -158,10 +181,17 @@ function createPreviewAppProvider(client, options) {
 				versionId: updateResult.value.versionId,
 				timeoutSeconds: 120,
 				pollIntervalMs: 2e3,
+				signal: options.signal,
 				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 })]);
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({
+				serviceId: options.appId,
+				signal: options.signal
+			}), sdk.showVersion({
+				versionId: updateResult.value.versionId,
+				signal: options.signal
+			})]);
 			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
 			if (versionResult.isErr()) throw new Error(versionResult.error.message);
 			return {
@@ -184,7 +214,13 @@ function createPreviewAppProvider(client, options) {
 			};
 		},
 		async listAppEnvNames(options) {
-			const [serviceResult, versionResult] = await Promise.all([sdk.showService({ serviceId: options.appId }), sdk.showVersion({ versionId: options.deploymentId })]);
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({
+				serviceId: options.appId,
+				signal: options.signal
+			}), sdk.showVersion({
+				versionId: options.deploymentId,
+				signal: options.signal
+			})]);
 			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
 			if (versionResult.isErr()) throw new Error(versionResult.error.message);
 			return {
@@ -206,8 +242,14 @@ function createPreviewAppProvider(client, options) {
 				variables: envVarNames(versionResult.value.envVars)
 			};
 		},
-		async listDeployments(appId) {
-			const [appResult, versionsResult] = await Promise.all([sdk.showService({ serviceId: appId }), sdk.listVersions({ serviceId: appId })]);
+		async listDeployments(appId, options) {
+			const [appResult, versionsResult] = await Promise.all([sdk.showService({
+				serviceId: appId,
+				signal: options?.signal
+			}), sdk.listVersions({
+				serviceId: appId,
+				signal: options?.signal
+			})]);
 			if (appResult.isErr()) throw new Error(appResult.error.message);
 			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
 			return {
@@ -230,14 +272,17 @@ function createPreviewAppProvider(client, options) {
 				}))
 			};
 		},
-		async showDeployment(deploymentId) {
-			const deploymentResult = await sdk.showVersion({ versionId: deploymentId });
+		async showDeployment(deploymentId, options) {
+			const deploymentResult = await sdk.showVersion({
+				versionId: deploymentId,
+				signal: options?.signal
+			});
 			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),
+				app: await findAppForDeployment(sdk, deploymentId, options?.signal),
 				deployment: {
 					id: deploymentResult.value.id,
 					status: deploymentResult.value.status,
@@ -263,10 +308,13 @@ function createPreviewAppProvider(client, options) {
 	};
 }
 async function listBranches(client, options) {
-	const result = await client.GET("/v1/projects/{projectId}/branches", { params: {
-		path: { projectId: options.projectId },
-		query: { gitName: options.gitName }
-	} });
+	const result = await client.GET("/v1/projects/{projectId}/branches", {
+		params: {
+			path: { projectId: options.projectId },
+			query: { gitName: options.gitName }
+		},
+		signal: options.signal
+	});
 	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
 	return result.data.data;
 }
@@ -278,7 +326,8 @@ async function resolveOrCreateBranch(client, options) {
 		body: {
 			gitName: options.gitName,
 			isDefault: options.gitName === "main"
-		}
+		},
+		signal: options.signal
 	});
 	if (result.error || !result.data) {
 		if (result.response.status === 409) {
@@ -293,11 +342,14 @@ async function listComputeServices(client, options) {
 	const services = [];
 	let cursor;
 	while (true) {
-		const result = await client.GET("/v1/compute-services", { params: { query: {
-			projectId: options.projectId,
-			branchGitName: options.branchGitName,
-			cursor
-		} } });
+		const result = await client.GET("/v1/compute-services", {
+			params: { query: {
+				projectId: options.projectId,
+				branchGitName: options.branchGitName,
+				cursor
+			} },
+			signal: options.signal
+		});
 		if (result.error || !result.data) throw apiCallError("Failed to list apps", result.response, result.error);
 		services.push(...result.data.data);
 		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
@@ -312,8 +364,11 @@ async function listComputeServices(client, options) {
 		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
 	}));
 }
-async function listComputeServiceDomains(client, computeServiceId) {
-	const result = await client.GET("/v1/compute-services/{computeServiceId}/domains", { params: { path: { computeServiceId } } });
+async function listComputeServiceDomains(client, computeServiceId, signal) {
+	const result = await client.GET("/v1/compute-services/{computeServiceId}/domains", {
+		params: { path: { computeServiceId } },
+		signal
+	});
 	if (result.error || !result.data) throw domainApiCallError("Failed to list custom domains", result.response, result.error);
 	return result.data.data.map((domain) => normalizeDomainRecord(domain));
 }
@@ -355,19 +410,24 @@ function normalizeHostnameForComparison(hostname) {
 async function createBranchApp(client, options) {
 	const branch = await resolveOrCreateBranch(client, {
 		projectId: options.projectId,
-		gitName: options.branchName
+		gitName: options.branchName,
+		signal: options.signal
+	});
+	const result = await client.POST("/v1/compute-services", {
+		body: {
+			projectId: options.projectId,
+			branchId: branch.id,
+			displayName: options.appName,
+			...options.region ? { regionId: options.region } : {}
+		},
+		signal: options.signal
 	});
-	const result = await client.POST("/v1/compute-services", { body: {
-		projectId: options.projectId,
-		branchId: branch.id,
-		displayName: options.appName,
-		...options.region ? { regionId: options.region } : {}
-	} });
 	if (result.error || !result.data) {
 		if (result.response.status === 409) {
 			const matched = (await listComputeServices(client, {
 				projectId: options.projectId,
-				branchGitName: options.branchName
+				branchGitName: options.branchName,
+				signal: options.signal
 			})).find((app) => app.name === options.appName);
 			if (matched) return {
 				appId: matched.id,
@@ -399,14 +459,20 @@ function domainApiCallError(summary, response, error) {
 		hint: error.error?.hint ?? null
 	});
 }
-async function findAppForDeployment(sdk, deploymentId) {
-	const projectsResult = await sdk.listProjects();
+async function findAppForDeployment(sdk, deploymentId, signal) {
+	const projectsResult = await sdk.listProjects({ signal });
 	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
 	for (const project of projectsResult.value) {
-		const servicesResult = await sdk.listServices({ projectId: project.id });
+		const servicesResult = await sdk.listServices({
+			projectId: project.id,
+			signal
+		});
 		if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
 		for (const service of servicesResult.value) {
-			const detailResult = await sdk.showService({ serviceId: service.id });
+			const detailResult = await sdk.showService({
+				serviceId: service.id,
+				signal
+			});
 			if (detailResult.isErr()) throw new Error(detailResult.error.message);
 			const app = {
 				id: detailResult.value.id,
@@ -416,7 +482,10 @@ async function findAppForDeployment(sdk, deploymentId) {
 				liveUrl: toAbsoluteUrl(detailResult.value.serviceEndpointDomain ?? null)
 			};
 			if (app.liveDeploymentId === deploymentId) return app;
-			const versionsResult = await sdk.listVersions({ serviceId: service.id });
+			const versionsResult = await sdk.listVersions({
+				serviceId: service.id,
+				signal
+			});
 			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
 			if (versionsResult.value.some((version) => version.id === deploymentId)) return app;
 		}