@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.0

package/scripts/lib/cloud-smoke-github.mjs

@@ -1,331 +0,0 @@
-import { randomUUID as nodeRandomUUID } from "node:crypto";
-import { spawnSync } from "node:child_process";
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
-export const CLOUD_SMOKE_REPO_NAME_PREFIX = "pi-cursor-cloud-smoke-";
-export const CLOUD_SMOKE_OWNERSHIP_TOKEN_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const OWNED_REPO_NAME_PATTERN = /^[^/]+\/pi-cursor-cloud-smoke-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
-
-function fail(message, details = "") {
-	const error = new Error(message);
-	error.details = details;
-	throw error;
-}
-
-export function cloudSmokeRepositoryDescription(ownershipToken) {
-	const token = String(ownershipToken ?? "").toLowerCase();
-	if (!CLOUD_SMOKE_OWNERSHIP_TOKEN_PATTERN.test(token)) fail("cloud smoke ownership token must be a lowercase UUID");
-	return `pi-cursor-sdk throwaway cloud smoke; ownership=${token}; safe to delete`;
-}
-
-export function assertOwnedThrowawayRepositoryHandle(repo) {
-	if (!repo || typeof repo !== "object" || Array.isArray(repo)) fail("throwaway repository handle must be an object");
-	const ownershipToken = String(repo.ownershipToken ?? "").toLowerCase();
-	if (!CLOUD_SMOKE_OWNERSHIP_TOKEN_PATTERN.test(ownershipToken)) {
-		fail("throwaway repository handle missing exact ownership token");
-	}
-	const fullName = String(repo.fullName ?? "").toLowerCase();
-	const match = fullName.match(OWNED_REPO_NAME_PATTERN);
-	if (!match || match[1] !== ownershipToken) {
-		fail("throwaway repository handle fullName must match pi-cursor-cloud-smoke-<ownership-token>");
-	}
-	const expectedDescription = cloudSmokeRepositoryDescription(ownershipToken);
-	if (repo.description !== expectedDescription) {
-		fail("throwaway repository handle description must include exact ownership marker");
-	}
-	return {
-		fullName,
-		ownershipToken,
-		description: expectedDescription,
-		repoUrl: typeof repo.repoUrl === "string" ? repo.repoUrl : `https://github.com/${fullName}.git`,
-		seedDir: typeof repo.seedDir === "string" ? repo.seedDir : undefined,
-	};
-}
-
-export function runTimedCommand(commandName, commandArgs, options = {}) {
-	const run = options.spawnSync ?? spawnSync;
-	const result = run(commandName, commandArgs, {
-		cwd: options.cwd,
-		env: options.env ?? process.env,
-		encoding: "utf8",
-		maxBuffer: options.maxBuffer ?? 16 * 1024 * 1024,
-		timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
-	});
-	if (result.error || result.status !== 0) {
-		fail(
-			`${options.label ?? commandName} failed${result.status === null ? "" : ` with exit ${result.status}`}`,
-			[result.error?.message, result.stderr, result.stdout].filter(Boolean).join("\n"),
-		);
-	}
-	return String(result.stdout ?? "").trim();
-}
-
-export function authenticatedGitArgs(commandArgs) {
-	return ["-c", "credential.helper=", "-c", "credential.helper=!gh auth git-credential", ...commandArgs];
-}
-
-function isTransientCommandFailure(error) {
-	const text = `${error instanceof Error ? error.message : String(error)}\n${error?.details ?? ""}`;
-	return /HTTP\s*5\d\d|Service Unavailable|timed?\s*out|ECONNRESET|EAI_AGAIN/i.test(text);
-}
-
-function runRetryableCommand(command, commandName, commandArgs, commandOptions, options = {}) {
-	const sleep = options.sleep ?? ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
-	const attempts = options.verificationAttempts ?? 5;
-	let lastError;
-	for (let attempt = 1; attempt <= attempts; attempt += 1) {
-		try {
-			return command(commandName, commandArgs, commandOptions);
-		} catch (error) {
-			lastError = error;
-			if (!isTransientCommandFailure(error) || attempt === attempts) throw error;
-			sleep(options.verificationDelayMs ?? 500);
-		}
-	}
-	throw lastError;
-}
-
-export function normalizeCloudSmokeGitHubRepo(value) {
-	if (typeof value !== "string" || !value.trim()) return undefined;
-	let url;
-	try {
-		url = new URL(value.includes("://") ? value : `https://${value}`);
-	} catch {
-		return undefined;
-	}
-	if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password || url.search || url.hash) {
-		return undefined;
-	}
-	const segments = url.pathname.replace(/\.git$/, "").split("/").filter(Boolean);
-	return segments.length === 2 ? `${segments[0]}/${segments[1]}`.toLowerCase() : undefined;
-}
-
-function explicitHttpStatus(stdout) {
-	const firstLine = String(stdout ?? "").split(/\r?\n/, 1)[0].trim();
-	return /^HTTP\/\S+\s+(\d{3})(?:\s|$)/i.exec(firstLine)?.[1];
-}
-
-function readRepositoryOwnership(fullName, options = {}) {
-	const run = options.spawnSync ?? spawnSync;
-	const probe = run("gh", ["api", "-i", `repos/${fullName}`], {
-		cwd: options.cwd,
-		env: options.env ?? process.env,
-		encoding: "utf8",
-		maxBuffer: 1024 * 1024,
-		timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
-	});
-	const output = [probe.error?.message, probe.stdout, probe.stderr].filter(Boolean).join("\n");
-	if (probe.error) fail(`probe throwaway repository ownership transport failed for ${fullName}`, output);
-	const status = explicitHttpStatus(probe.stdout);
-	if (status === "404" && probe.status !== 0) return { exists: false, isPrivate: false, description: "" };
-	if (probe.status !== 0 || status !== "200") {
-		fail(`probe throwaway repository ownership did not return explicit HTTP 200/404 for ${fullName}`, output);
-	}
-	const bodyStart = String(probe.stdout ?? "").indexOf("{");
-	let parsed;
-	try {
-		parsed = JSON.parse(String(probe.stdout ?? "").slice(bodyStart));
-	} catch (error) {
-		fail(`probe throwaway repository ownership returned invalid JSON for ${fullName}`, error instanceof Error ? error.message : String(error));
-	}
-	return {
-		exists: true,
-		isPrivate: parsed.private === true,
-		description: typeof parsed.description === "string" ? parsed.description : "",
-	};
-}
-
-function probeRepositoryOwnership(fullName, options = {}) {
-	const sleep = options.sleep ?? ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
-	const attempts = options.verificationAttempts ?? 5;
-	let lastResult = { exists: false, isPrivate: false, description: "" };
-	let lastError;
-	for (let attempt = 1; attempt <= attempts; attempt += 1) {
-		try {
-			lastResult = readRepositoryOwnership(fullName, options);
-			lastError = undefined;
-			if (lastResult.exists) return lastResult;
-		} catch (error) {
-			lastError = error;
-		}
-		if (attempt < attempts) sleep(options.verificationDelayMs ?? 500);
-	}
-	if (lastError) throw lastError;
-	return lastResult;
-}
-
-function verifyOwnedRepository(repo, options = {}) {
-	const owned = assertOwnedThrowawayRepositoryHandle(repo);
-	const command = options.runCommand ?? ((name, args, opts = {}) => runTimedCommand(name, args, { ...opts, spawnSync: options.spawnSync }));
-	const view = JSON.parse(runRetryableCommand(command, "gh", ["repo", "view", owned.fullName, "--json", "isPrivate,description"], {
-		cwd: options.cwd,
-		label: "verify throwaway repository ownership marker",
-	}, options));
-	if (view.isPrivate !== true) fail("throwaway repository is not private");
-	if (view.description !== owned.description) fail("throwaway repository description does not match ownership marker");
-	return owned;
-}
-
-export function createThrowawayRepository(artifactRoot, onOwned, options = {}) {
-	const command = options.runCommand ?? ((name, args, opts = {}) => runTimedCommand(name, args, { ...opts, spawnSync: options.spawnSync }));
-	const writeFile = options.writeFileSync ?? writeFileSync;
-	const randomUUID = options.randomUUID ?? nodeRandomUUID;
-	const ownershipToken = String(randomUUID()).toLowerCase();
-	if (!CLOUD_SMOKE_OWNERSHIP_TOKEN_PATTERN.test(ownershipToken)) fail("cloud smoke ownership token must be a lowercase UUID");
-	const cwd = options.cwd;
-
-	command("gh", ["auth", "status"], { cwd, label: "gh auth status" });
-	const owner = command("gh", ["api", "user", "--jq", ".login"], { cwd, label: "read gh user" });
-	if (!owner) fail("gh auth did not return a GitHub login");
-	const name = `${CLOUD_SMOKE_REPO_NAME_PREFIX}${ownershipToken}`;
-	const fullName = `${owner}/${name}`.toLowerCase();
-	const description = cloudSmokeRepositoryDescription(ownershipToken);
-	const seedDir = join(artifactRoot, "repo-seed");
-	const repo = {
-		fullName,
-		repoUrl: `https://github.com/${fullName}.git`,
-		seedDir,
-		ownershipToken,
-		description,
-	};
-
-	const sleep = options.sleep ?? ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
-	const attempts = options.verificationAttempts ?? 5;
-	let createError;
-	for (let attempt = 1; attempt <= attempts; attempt += 1) {
-		try {
-			command("gh", ["repo", "create", fullName, "--private", "--description", description], {
-				cwd,
-				label: "create private throwaway repository",
-			});
-			createError = undefined;
-			break;
-		} catch (error) {
-			createError = error;
-			const probe = probeRepositoryOwnership(fullName, options);
-			if (probe.exists && probe.description === description && probe.isPrivate) {
-				// Creation was ambiguous but the exact ownership marker is present: expose cleanup only now.
-				onOwned?.(repo);
-				fail(
-					"throwaway repository create failed after ownership marker was observed",
-					[error instanceof Error ? error.message : String(error), error?.details].filter(Boolean).join("\n"),
-				);
-			}
-			if (probe.exists) {
-				const residual = new Error(`throwaway repository name exists without ownership marker; refusing cleanup: ${fullName}`);
-				residual.residualRepositoryName = fullName;
-				residual.details = [error instanceof Error ? error.message : String(error), error?.details].filter(Boolean).join("\n");
-				throw residual;
-			}
-			if (!isTransientCommandFailure(error) || attempt === attempts) throw error;
-			sleep(options.verificationDelayMs ?? 500);
-		}
-	}
-	if (createError) throw createError;
-
-	// A successful create establishes ownership; expose cleanup before later verification/seeding can fail.
-	onOwned?.(repo);
-	verifyOwnedRepository(repo, options);
-
-	command("gh", ["repo", "clone", fullName, seedDir], { cwd, label: "clone throwaway repository" });
-	command("git", ["config", "user.name", "pi-cursor-sdk cloud smoke"], { cwd: seedDir });
-	command("git", ["config", "user.email", "pi-cursor-sdk-cloud-smoke@invalid.example"], { cwd: seedDir });
-	command("git", ["switch", "-c", "main"], { cwd: seedDir });
-	writeFile(join(seedDir, "README.md"), "# pi-cursor-sdk cloud smoke\n");
-	command("git", ["add", "README.md"], { cwd: seedDir });
-	command("git", ["commit", "-m", "seed main"], { cwd: seedDir });
-	command("git", authenticatedGitArgs(["push", "-u", "origin", "main"]), { cwd: seedDir });
-	runRetryableCommand(command, "gh", ["repo", "edit", fullName, "--default-branch", "main"], { cwd, label: "set throwaway default branch" }, options);
-	for (const branch of ["starting-ref", "direct-push"]) {
-		command("git", ["switch", "-c", branch, "main"], { cwd: seedDir });
-		writeFile(join(seedDir, `${branch}.txt`), `${branch} seed\n`);
-		command("git", ["add", `${branch}.txt`], { cwd: seedDir });
-		command("git", ["commit", "-m", `seed ${branch}`], { cwd: seedDir });
-		command("git", authenticatedGitArgs(["push", "-u", "origin", branch]), { cwd: seedDir });
-	}
-	if (command("git", ["status", "--porcelain"], { cwd: seedDir })) fail("throwaway seed repository is not clean");
-	const remoteRefs = command("git", authenticatedGitArgs(["ls-remote", "--heads", repo.repoUrl]), {
-		cwd,
-		label: "verify seeded throwaway branches",
-	});
-	for (const branch of ["main", "starting-ref", "direct-push"]) {
-		if (!remoteRefs.includes(`refs/heads/${branch}`)) fail(`throwaway repository is missing seeded ${branch} branch`);
-	}
-	return repo;
-}
-
-export function deleteThrowawayRepository(repo, options = {}) {
-	const owned = assertOwnedThrowawayRepositoryHandle(repo);
-	const command = options.runCommand ?? ((name, args, opts = {}) => runTimedCommand(name, args, { ...opts, spawnSync: options.spawnSync }));
-	const run = options.spawnSync ?? spawnSync;
-	const sleep = options.sleep ?? ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
-	const attempts = options.verificationAttempts ?? 5;
-	const cwd = options.cwd;
-
-	// Re-check remote ownership marker before any destructive delete.
-	verifyOwnedRepository(owned, options);
-	let deleteError;
-	for (let attempt = 1; attempt <= attempts; attempt += 1) {
-		try {
-			command("gh", ["repo", "delete", owned.fullName, "--yes"], { cwd, label: "delete throwaway repository" });
-			deleteError = undefined;
-			break;
-		} catch (error) {
-			deleteError = error;
-			const probe = probeRepositoryOwnership(owned.fullName, options);
-			if (!probe.exists) return { deleted: true, httpStatus: 404 };
-			if (!probe.isPrivate || probe.description !== owned.description) {
-				fail("throwaway repository ownership changed after delete failed; refusing another delete", error?.details ?? "");
-			}
-			if (attempt < attempts) sleep(options.verificationDelayMs ?? 500);
-		}
-	}
-	if (deleteError) throw deleteError;
-	let output = "";
-	for (let attempt = 1; attempt <= attempts; attempt += 1) {
-		const probe = run("gh", ["api", "-i", `repos/${owned.fullName}`], {
-			cwd,
-			env: options.env ?? process.env,
-			encoding: "utf8",
-			maxBuffer: 1024 * 1024,
-			timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
-		});
-		output = [probe.error?.message, probe.stdout, probe.stderr].filter(Boolean).join("\n");
-		if (!probe.error && probe.status !== 0 && explicitHttpStatus(probe.stdout) === "404") {
-			return { deleted: true, httpStatus: 404 };
-		}
-		if (attempt < attempts) sleep(options.verificationDelayMs ?? 500);
-	}
-	fail("throwaway repository deletion was not independently verified as HTTP 404", output);
-}
-
-export function validatePrUrl(repo, prUrl, options = {}) {
-	const fullName = String(repo?.fullName ?? "").toLowerCase();
-	if (!fullName.includes("/")) fail("throwaway repository fullName is required to validate PR URLs");
-	const command = options.runCommand ?? ((name, args, opts = {}) => runTimedCommand(name, args, { ...opts, spawnSync: options.spawnSync }));
-	let url;
-	try {
-		url = new URL(prUrl);
-	} catch {
-		fail("cloud report returned an invalid PR URL", prUrl);
-	}
-	if (
-		url.protocol !== "https:"
-		|| url.username
-		|| url.password
-		|| url.search
-		|| url.hash
-		|| url.hostname !== "github.com"
-		|| !url.pathname.startsWith(`/${fullName}/pull/`)
-	) {
-		fail("cloud report returned a PR URL outside the throwaway repository", prUrl);
-	}
-	const result = JSON.parse(command("gh", ["pr", "view", prUrl, "--json", "url,state"], {
-		cwd: options.cwd,
-		label: "validate reported PR URL",
-	}));
-	if (result.url !== prUrl || typeof result.state !== "string") fail("gh could not validate reported PR URL", prUrl);
-	return result;
-}

package/scripts/lib/cloud-smoke-pi-runner.d.mts

@@ -1,42 +0,0 @@
-import type { CloudSmokeShutdownController } from "./cloud-smoke-shutdown.mjs";
-
-interface CloudSmokeRpcEvent {
-	type: string;
-	[key: string]: unknown;
-}
-
-interface CloudSmokeRpcResponse extends CloudSmokeRpcEvent {
-	type: "response";
-	id: string;
-	success: boolean;
-	data?: { text?: string; [key: string]: unknown };
-	error?: unknown;
-}
-
-export function createCloudSmokePiRunner(options: {
-	root: string;
-	model: string;
-	shutdown: CloudSmokeShutdownController;
-	buildEnv(artifactDir: string, options?: Record<string, unknown>): NodeJS.ProcessEnv;
-	buildWorkspace(artifactDir: string): string;
-}): {
-	runPi(options: {
-		artifactDir: string;
-		envOptions?: Record<string, unknown>;
-		message: string;
-		sessionId: string;
-		timeoutMs: number;
-	}): Promise<{ code: number | null; signal: NodeJS.Signals | null; stdout: string; stderr: string }>;
-	startRpc(options: {
-		artifactDir: string;
-		contextHandoff?: string;
-		sessionId: string;
-		envOptions?: Record<string, unknown>;
-	}): Promise<{
-		events: CloudSmokeRpcEvent[];
-		send(type: string, extra?: Record<string, unknown>, timeoutMs?: number): Promise<CloudSmokeRpcResponse>;
-		stop(): Promise<void>;
-		throwIfFailed(): void;
-		readonly stderr: string;
-	}>;
-};

package/scripts/lib/cloud-smoke-pi-runner.mjs

@@ -1,214 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import {
-	CHILD_PROCESS_TREE_SPAWN_OPTIONS,
-	terminateChild,
-} from "./cursor-child-process.mjs";
-import {
-	awaitCloudSmokeShutdown,
-	createCloudSmokeTerminalFailureState,
-	installCloudSmokeChildErrorHandlers,
-	routeCloudSmokeChildClose,
-	stopCloudSmokeTrackedChild,
-} from "./cloud-smoke-shutdown.mjs";
-
-export function createCloudSmokePiRunner({ root, model, shutdown, buildEnv, buildWorkspace }) {
-	const findPiBin = () => {
-		const local = join(root, "node_modules", ".bin", process.platform === "win32" ? "pi.cmd" : "pi");
-		return existsSync(local) ? local : process.platform === "win32" ? "pi.cmd" : "pi";
-	};
-
-	const spawnPi = (artifactDir, args, envOptions, stdio) => {
-		const sessionDir = join(artifactDir, "sessions");
-		mkdirSync(sessionDir, { recursive: true });
-		return spawn(findPiBin(), args(sessionDir), {
-			cwd: buildWorkspace(artifactDir),
-			env: buildEnv(artifactDir, envOptions),
-			stdio,
-			...CHILD_PROCESS_TREE_SPAWN_OPTIONS,
-		});
-	};
-
-	const runPi = ({ artifactDir, envOptions = {}, message, sessionId, timeoutMs }) => {
-		shutdown.throwIfRequested();
-		const child = spawnPi(
-			artifactDir,
-			(sessionDir) => ["-e", root, "--model", model, "--approve", "--session-dir", sessionDir, "--session-id", sessionId, "-p", message],
-			envOptions,
-			["ignore", "pipe", "pipe"],
-		);
-		const tracking = shutdown.track(child);
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => { stdout += chunk; });
-		child.stderr.on("data", (chunk) => { stderr += chunk; });
-		return new Promise((resolveRun, rejectRun) => {
-			let settled = false;
-			let timeoutStarted = false;
-			let timeoutTermination = Promise.resolve();
-			const settle = (callback, value) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timer);
-				shutdown.signal.removeEventListener("abort", onShutdown);
-				callback(value);
-			};
-			const onShutdown = () => {
-				const termination = Promise.allSettled([tracking, timeoutTermination]).then((results) => {
-					const failed = results.find((result) => result.status === "rejected");
-					if (failed) throw failed.reason;
-				});
-				void awaitCloudSmokeShutdown(shutdown, termination).then((error) => settle(rejectRun, error));
-			};
-			const timer = setTimeout(() => {
-				if (shutdown.signal.aborted) return onShutdown();
-				timeoutStarted = true;
-				timeoutTermination = terminateChild(child);
-				void timeoutTermination.then(
-					() => shutdown.signal.aborted
-						? onShutdown()
-						: settle(rejectRun, new Error(`pi cloud smoke timed out after ${timeoutMs}ms`)),
-					(error) => shutdown.signal.aborted
-						? onShutdown()
-						: settle(rejectRun, new Error(`pi cloud smoke timed out and cleanup failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error })),
-				);
-			}, timeoutMs);
-			shutdown.signal.addEventListener("abort", onShutdown, { once: true });
-			if (shutdown.signal.aborted) onShutdown();
-			void tracking.catch((error) => shutdown.signal.aborted ? onShutdown() : settle(rejectRun, error));
-			child.once("error", (error) => routeCloudSmokeChildClose(
-				shutdown,
-				timeoutStarted,
-				onShutdown,
-				(failure) => settle(rejectRun, failure),
-				error,
-			));
-			child.once("close", (code, signal) => routeCloudSmokeChildClose(
-				shutdown,
-				timeoutStarted,
-				onShutdown,
-				(result) => settle(resolveRun, result),
-				{ code, signal, stdout, stderr },
-			));
-		});
-	};
-
-	const startRpc = async ({ artifactDir, contextHandoff = "fresh", sessionId, envOptions = {} }) => {
-		shutdown.throwIfRequested();
-		const child = spawnPi(
-			artifactDir,
-			(sessionDir) => ["--mode", "rpc", "-e", root, "--model", model, "--approve", "--session-dir", sessionDir, "--session-id", sessionId],
-			{ contextHandoff, ...envOptions },
-			["pipe", "pipe", "pipe"],
-		);
-		const tracking = shutdown.track(child);
-		let stderr = "";
-		const events = [];
-		const pending = new Map();
-		let requestId = 0;
-		let stdoutBuffer = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (chunk) => { stderr += chunk; });
-		child.stdout.on("data", (chunk) => {
-			stdoutBuffer += chunk;
-			let newlineIndex;
-			while ((newlineIndex = stdoutBuffer.indexOf("\n")) >= 0) {
-				const line = stdoutBuffer.slice(0, newlineIndex);
-				stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
-				if (!line.trim()) continue;
-				let message;
-				try { message = JSON.parse(line); } catch { continue; }
-				if (message.type === "response" && pending.has(message.id)) {
-					if (shutdown.signal.aborted) {
-						rejectAfterShutdown();
-						continue;
-					}
-					const request = pending.get(message.id);
-					pending.delete(message.id);
-					clearTimeout(request.timer);
-					request.resolve(message);
-				} else events.push(message);
-			}
-		});
-		const rejectPending = (error) => {
-			for (const request of pending.values()) {
-				clearTimeout(request.timer);
-				request.reject(error);
-			}
-			pending.clear();
-		};
-		const terminalState = createCloudSmokeTerminalFailureState(rejectPending);
-		const rejectAfterShutdown = () => {
-			void awaitCloudSmokeShutdown(shutdown, tracking).then(rejectPending);
-		};
-		shutdown.signal.addEventListener("abort", rejectAfterShutdown, { once: true });
-		if (shutdown.signal.aborted) rejectAfterShutdown();
-		const routeRpcError = installCloudSmokeChildErrorHandlers(
-			child,
-			shutdown,
-			rejectAfterShutdown,
-			terminalState.record,
-		);
-		child.once("close", () => {
-			shutdown.signal.removeEventListener("abort", rejectAfterShutdown);
-			if (shutdown.signal.aborted) rejectAfterShutdown();
-			else terminalState.record(new Error(`cloud smoke RPC exited. Stderr: ${stderr}`));
-		});
-		const send = (type, extra = {}, timeoutMs = 120000) => new Promise((resolveRequest, rejectRequest) => {
-			try {
-				shutdown.throwIfRequested();
-				terminalState.throwIfFailed();
-			} catch (error) {
-				rejectRequest(error);
-				return;
-			}
-			const id = `cloud_smoke_${++requestId}`;
-			const timer = setTimeout(() => {
-				if (shutdown.signal.aborted) return rejectAfterShutdown();
-				pending.delete(id);
-				rejectRequest(new Error(`timeout waiting for ${type}. Stderr: ${stderr}`));
-			}, timeoutMs);
-			pending.set(id, { resolve: resolveRequest, reject: rejectRequest, timer });
-			try {
-				child.stdin.write(`${JSON.stringify({ id, type, ...extra })}\n`);
-			} catch (error) {
-				routeRpcError(error);
-			}
-		});
-		const stop = async () => {
-			shutdown.signal.removeEventListener("abort", rejectAfterShutdown);
-			if (!shutdown.signal.aborted) terminalState.record(new Error("cloud smoke RPC stopped"));
-			try {
-				const shutdownReason = await stopCloudSmokeTrackedChild(
-					shutdown,
-					tracking,
-					() => terminateChild(child, { graceMs: 15_000 }),
-				);
-				if (shutdownReason) rejectPending(shutdownReason);
-			} catch (error) {
-				rejectPending(error);
-				throw error;
-			}
-		};
-		try {
-			await tracking;
-			if (shutdown.signal.aborted) throw await awaitCloudSmokeShutdown(shutdown, tracking);
-		} catch (error) {
-			rejectPending(error);
-			throw error;
-		}
-		return {
-			events,
-			send,
-			stop,
-			throwIfFailed: terminalState.throwIfFailed,
-			get stderr() { return stderr; },
-		};
-	};
-
-	return { runPi, startRpc };
-}

package/scripts/lib/cloud-smoke-shutdown.d.mts

@@ -1,67 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-export type CloudSmokeShutdownController = {
-	signal: AbortSignal;
-	track(child: ChildProcess): Promise<() => void>;
-	request(signalName: string): Promise<Error>;
-	readonly reason: Error | undefined;
-	wait(): Promise<void>;
-	throwIfRequested(): void;
-};
-
-export function createCloudSmokeShutdownController(
-	terminate: (child: ChildProcess) => void | Promise<void>,
-): CloudSmokeShutdownController;
-
-export function awaitCloudSmokeShutdown(
-	shutdown: CloudSmokeShutdownController,
-	tracking?: Promise<unknown>,
-): Promise<Error>;
-
-export function checkpointCloudSmokeShutdown(
-	shutdown: CloudSmokeShutdownController,
-): Promise<void>;
-
-export function createCloudSmokeTerminalFailureState(
-	rejectPending: (error: Error) => void,
-): {
-	record(error: Error): void;
-	throwIfFailed(): void;
-};
-
-export function stopCloudSmokeTrackedChild(
-	shutdown: CloudSmokeShutdownController,
-	tracking: Promise<unknown>,
-	terminateChild: () => void | Promise<void>,
-): Promise<Error | undefined>;
-
-export function routeCloudSmokeChildError(
-	shutdown: CloudSmokeShutdownController,
-	onShutdown: () => void,
-	onError: (error: Error) => void,
-	error: Error,
-): void;
-
-export function installCloudSmokeChildErrorHandlers(
-	child: ChildProcess,
-	shutdown: CloudSmokeShutdownController,
-	onShutdown: () => void,
-	onError: (error: Error) => void,
-): (error: Error) => void;
-
-export function routeCloudSmokeChildClose<T>(
-	shutdown: CloudSmokeShutdownController,
-	timedOut: boolean,
-	onShutdown: () => void,
-	onClose: (result: T) => void,
-	result: T,
-): void;
-
-export function installCloudSmokeSignalHandlers(
-	shutdown: CloudSmokeShutdownController,
-	processLike?: {
-		on(signalName: string, handler: () => void): unknown;
-		off(signalName: string, handler: () => void): unknown;
-	},
-	onSignal?: (signalName: string) => void,
-): () => void;