void 0.10.13 → 0.20.1

package/dist/platform-cmd-DxJ2FRwR.mjs

@@ -0,0 +1,123 @@
+import { D as log, F as isCancel, G as normalizePlatformApiUrl, N as text, V as getActivePlatformConnection, W as listPlatformConnections, c as import_picocolors, et as savePlatformConnection, j as select, tt as selectPlatformConnection } from "./output-tFQLLj26.mjs";
+import { t as cfAccessHeaders } from "./cf-access-AJ1ehiFR.mjs";
+import { t as ensureCloudflaredToken } from "./cf-access-DsSsZUPr.mjs";
+import { parsePlatformDiscoveryDocument } from "@void/platform";
+//#region src/cli/platform-cmd.ts
+async function discoverPlatform(input, fetcher = fetch) {
+	const apiUrl = normalizePlatformApiUrl(input);
+	ensureCloudflaredToken(apiUrl);
+	const response = await fetcher(`${apiUrl}/.well-known/void-platform`, {
+		headers: {
+			Accept: "application/json",
+			...cfAccessHeaders(process.env, apiUrl)
+		},
+		redirect: "manual",
+		signal: AbortSignal.timeout(15e3)
+	});
+	if (!response.ok) throw new Error(`platform: Discovery failed at ${apiUrl} (HTTP ${response.status}).`);
+	let value;
+	try {
+		value = await response.json();
+	} catch {
+		throw new Error(`platform: ${apiUrl} returned invalid discovery metadata.`);
+	}
+	let discovery;
+	try {
+		discovery = parsePlatformDiscoveryDocument(value);
+	} catch (error) {
+		throw new Error(`platform: ${apiUrl} returned invalid discovery metadata: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const finalOrigin = normalizePlatformApiUrl(response.url ? new URL(response.url).origin : apiUrl);
+	if (discovery.apiUrl !== finalOrigin) throw new Error(`platform: Discovery origin mismatch. The response came from ${finalOrigin}, but identifies ${discovery.apiUrl}.`);
+	return discovery;
+}
+async function promptPlatformUrl() {
+	if (!process.stdin.isTTY) throw new Error("platform: A platform URL is required in non-interactive mode.");
+	const value = await text({
+		message: "Void platform API URL:",
+		placeholder: "https://platform.example.com",
+		validate: (input) => {
+			if (!input) return "Enter a platform URL.";
+			try {
+				normalizePlatformApiUrl(input);
+			} catch (error) {
+				return error instanceof Error ? error.message : String(error);
+			}
+		}
+	});
+	if (isCancel(value) || typeof value === "symbol") throw new Error("platform: Cancelled.");
+	return value;
+}
+async function resolveConnection(selector) {
+	if (selector) return selectPlatformConnection(selector);
+	const connections = listPlatformConnections();
+	if (connections.length === 0) throw new Error("platform: No platforms configured. Run `void connect <url>`.");
+	if (connections.length === 1) return selectPlatformConnection(connections[0].id);
+	if (!process.stdin.isTTY) throw new Error("platform: Multiple platforms are configured; specify an id or URL.");
+	const picked = await select({
+		message: "Select a Void platform:",
+		options: connections.map((connection) => ({
+			label: connection.displayName,
+			hint: connection.apiUrl,
+			value: connection.id
+		}))
+	});
+	if (isCancel(picked)) throw new Error("platform: Cancelled.");
+	return selectPlatformConnection(String(picked));
+}
+function showConnection(connection, activeId) {
+	const marker = connection.id === activeId ? import_picocolors.default.green("●") : import_picocolors.default.dim("○");
+	console.log(`${marker} ${import_picocolors.default.bold(connection.displayName)}  ${import_picocolors.default.dim(connection.id)}`);
+	console.log(`  ${connection.apiUrl}`);
+	if (connection.applicationDomain) console.log(connection.applicationDomain.endsWith(".workers.dev") ? "  apps: workers.dev (testing)" : `  apps: *.${connection.applicationDomain}`);
+}
+function saveDiscoveredPlatform(discovery) {
+	return savePlatformConnection({
+		accountId: null,
+		apiUrl: discovery.apiUrl,
+		applicationDomain: discovery.applicationDomain,
+		displayName: discovery.displayName,
+		installationId: discovery.installationId,
+		kind: discovery.installationId ? "installed" : "connected",
+		proxyUrl: discovery.proxyUrl
+	});
+}
+async function runPlatformCommand(_root, args) {
+	if (args.subcommand === "operator") {
+		const { runOperatorCommand } = await import("./operator-cmd-DYWRbWUA.mjs");
+		await runOperatorCommand(args);
+		return;
+	}
+	if (args.subcommand === "list") {
+		const connections = listPlatformConnections();
+		if (connections.length === 0) {
+			log.info("No platforms configured. Run `void connect <url>`.");
+			return;
+		}
+		const activeId = getActivePlatformConnection()?.id ?? null;
+		for (const connection of connections) showConnection(connection, activeId);
+		return;
+	}
+	if (args.subcommand === "use") {
+		const connection = await resolveConnection(args.selector);
+		log.success(`Using ${import_picocolors.default.bold(connection.displayName)} (${connection.apiUrl}).`);
+		return;
+	}
+	if (args.subcommand === "status") {
+		const discovery = await discoverPlatform((await resolveConnection(args.selector)).apiUrl);
+		log.success(`${discovery.displayName} is reachable.`);
+		console.log(`API: ${discovery.apiUrl}`);
+		console.log(`Proxy: ${discovery.proxyUrl}`);
+		if (discovery.applicationRouting?.workersDev && !discovery.applicationRouting.zoneName) {
+			console.log("Application domain: workers.dev (testing)");
+			console.log("Add a domain: void platform domain set <domain>");
+		} else console.log(`Applications: *.${discovery.applicationDomain}`);
+		console.log(`Version: ${discovery.platformVersion}`);
+		console.log(`Capabilities: ${Object.entries(discovery.capabilities).filter(([, enabled]) => enabled).map(([name]) => name).join(", ")}`);
+		return;
+	}
+	const { runPlatformLifecycleCommand } = await import("./platform-lifecycle-DN4MzJF_.mjs");
+	await runPlatformLifecycleCommand(args);
+}
+//#endregion
+export { discoverPlatform, promptPlatformUrl, runPlatformCommand, saveDiscoveredPlatform };

package/dist/platform-domain-ChvbJkdy.mjs

@@ -0,0 +1,228 @@
+import { D as log, F as isCancel, N as text, O as note, Y as readInstallationRecoverySecrets, et as savePlatformConnection, nt as writeInstallationManifest, w as confirm, z as acquirePlatformLifecycleLock } from "./output-tFQLLj26.mjs";
+import { t as cfAccessHeaders } from "./cf-access-AJ1ehiFR.mjs";
+import { S as resolvePlatformCloudflareCredential, assertNoninteractivePlatformMutationAcknowledged, d as createPlatformInstallPlan, g as PlatformCloudflareClient, l as recordPlatformWorkerTraffic, n as acquirePlatformDatabaseLifecycleLock, r as createPlatformHealthProbeToken, resolvePlatformInstallDatabaseUrl, s as recordResource, x as assertPlatformOperatorCredentialCanApplyPlan } from "./platform-lifecycle-DN4MzJF_.mjs";
+import { resolveInstalledPlatformManifest, selectAuthoritativePlatformManifest, verifyPlatformInstallationOwnership } from "./platform-management-Db2PXw0B.mjs";
+import { randomUUID } from "node:crypto";
+import { PLATFORM_APPLICATION_KEY, PLATFORM_REMOTE_INSTALLATION_MANIFEST_KEY, createApplicationRoutes, createPlatformDeploymentManifest, normalizeApplicationDomain } from "@void/platform";
+//#region src/cli/platform-domain.ts
+function platformDomainTarget(manifest, domain, zone, dedicatedZone) {
+	const current = manifest.deployment.application;
+	if (!current.workersDev) throw new Error("platform: This command adds a domain to a workers.dev test installation.");
+	if (!["installed", "disabled"].includes(manifest.status)) throw new Error("platform: Finish the interrupted platform lifecycle operation before adding a domain.");
+	if (current.zoneName && current.baseDomain !== domain) throw new Error(`platform: This installation already uses ${current.baseDomain}. Replacing an existing application domain is not supported.`);
+	if (manifest.pendingDomain && (manifest.pendingDomain.baseDomain !== domain || manifest.pendingDomain.zoneName !== zone)) throw new Error(`platform: Finish the pending setup with void platform domain set ${manifest.pendingDomain.baseDomain}.`);
+	return createPlatformDeploymentManifest({
+		...manifest.deployment,
+		application: {
+			baseDomain: domain,
+			zoneName: zone,
+			dedicatedZone: manifest.pendingDomain?.dedicatedZone ?? (current.zoneName ? current.dedicatedZone : dedicatedZone),
+			workersDev: current.workersDev,
+			...current.zoneId ? { zoneId: current.zoneId } : {}
+		}
+	}).application;
+}
+async function applyPlatformDomain(client, original, target, plan, dependencies) {
+	let manifest = original;
+	const now = () => (/* @__PURE__ */ new Date()).toISOString();
+	const save = async (next) => {
+		await dependencies.checkpoint(next);
+		manifest = next;
+	};
+	await dependencies.verifyOwnership(manifest);
+	await save({
+		...manifest,
+		pendingDomain: target,
+		updatedAt: now()
+	});
+	const zoneAction = plan.actions.find((action) => action.key === "zone");
+	if (!zoneAction) throw new Error("platform: Domain plan has no zone.");
+	let zone = plan.zone;
+	if (!zone) zone = await client.createZone(manifest.account.id, target.zoneName);
+	await save(recordResource(manifest, zoneAction, zone.id, zoneAction.action === "create" ? "created" : manifest.resources.some((resource) => resource.key === "zone") ? void 0 : "adopted", now()));
+	if (zone.status !== "active") return {
+		manifest,
+		waitingForDns: true,
+		nameServers: zone.nameServers
+	};
+	await dependencies.verifyRuntimeToken(zone.id);
+	const dnsAction = plan.actions.find((action) => action.key === "application-dns");
+	if (!dnsAction) throw new Error("platform: Domain plan has no application DNS record.");
+	if (dnsAction.action === "create") {
+		if ((await client.listDnsRecords(zone.id, dnsAction.name)).length) throw new Error("platform: DNS changed since the plan. Rerun the command to review it.");
+		const dns = await client.createDnsRecord(zone.id, dnsAction.name);
+		await save(recordResource(manifest, dnsAction, dns.id, "created", now()));
+	} else {
+		if (!dnsAction.id) throw new Error("platform: Domain DNS record has no identity.");
+		await save(recordResource(manifest, dnsAction, dnsAction.id, dnsAction.action === "adopt" ? "adopted" : void 0, now()));
+	}
+	await dependencies.verifyOwnership(manifest);
+	const patterns = createApplicationRoutes(target).map((route) => route.pattern);
+	await client.publishWorkerRoutesSafely(zone.id, manifest.deployment.resources.dispatchWorker, patterns);
+	const routes = await client.listWorkerRoutes(zone.id);
+	const deployment = createPlatformDeploymentManifest({
+		...manifest.deployment,
+		application: {
+			...target,
+			zoneId: zone.id
+		}
+	});
+	const observed = recordPlatformWorkerTraffic({
+		...manifest,
+		deployment
+	}, deployment.resources.dispatchWorker, {
+		customDomains: [],
+		routes
+	}, now());
+	await save({
+		...manifest,
+		resources: observed.resources,
+		updatedAt: now()
+	});
+	await (dependencies.probe ?? probePlatformDomain)(`void-check-${randomUUID().slice(0, 8)}.${target.baseDomain}`, manifest);
+	await dependencies.verifyOwnership(manifest);
+	const routing = manifest.resources.find((resource) => resource.key === "routing-kv" && resource.state === "ready");
+	if (!routing) throw new Error("platform: Routing storage is missing. Run platform repair first.");
+	await client.putKvValue(manifest.account.id, routing.id, PLATFORM_APPLICATION_KEY, JSON.stringify(deployment.application));
+	const { pendingDomain: _pending, ...ready } = manifest;
+	await save({
+		...ready,
+		deployment,
+		updatedAt: now()
+	});
+	return {
+		manifest,
+		waitingForDns: false,
+		nameServers: []
+	};
+}
+async function probePlatformDomain(hostname, manifest) {
+	const url = `https://${hostname}/health`;
+	try {
+		const response = await fetch(url, {
+			redirect: "manual",
+			signal: AbortSignal.timeout(3e4),
+			headers: {
+				"X-Void-Platform-Probe": createPlatformHealthProbeToken(manifest.ownershipNonce),
+				...cfAccessHeaders(process.env, url)
+			}
+		});
+		const body = await response.json();
+		if (!response.ok || body.ok !== true || body.installationId !== manifest.id) throw new Error("Identity or health did not match.");
+	} catch {
+		throw new Error(`platform: HTTPS is not ready for *.${manifest.pendingDomain.baseDomain}. Existing URLs remain active. Wait for DNS/certificate activation and rerun the same domain set command.`);
+	}
+}
+async function runPlatformDomainCommand(args) {
+	assertNoninteractivePlatformMutationAcknowledged(args, process.stdin.isTTY === true);
+	const selected = await resolveInstalledPlatformManifest(args.selector);
+	const credential = await resolvePlatformCloudflareCredential();
+	const client = new PlatformCloudflareClient(credential.token);
+	const domainInput = args.domain || await text({
+		message: "Application domain:",
+		placeholder: "example.com"
+	});
+	if (isCancel(domainInput)) throw new Error("platform: Cancelled.");
+	const domain = normalizeApplicationDomain(String(domainInput));
+	const execute = async (manifest, checkpoint) => {
+		const existingZone = args.zone ? null : await client.findZoneForHostname(manifest.account.id, domain);
+		const zoneName = normalizeApplicationDomain(args.zone || manifest.pendingDomain?.zoneName || existingZone?.name || domain);
+		const target = platformDomainTarget(manifest, domain, zoneName, args.dedicatedZone);
+		const deployment = createPlatformDeploymentManifest({
+			...manifest.deployment,
+			application: target
+		});
+		const candidate = {
+			...manifest,
+			deployment
+		};
+		const plan = await createPlatformInstallPlan(client, {
+			accountId: manifest.account.id,
+			applicationDomain: domain,
+			controlPlaneDomain: deployment.controlPlane.apiHostname ?? "",
+			dedicatedZone: target.dedicatedZone,
+			displayName: deployment.displayName,
+			installationSlug: deployment.installationSlug,
+			zoneName
+		}, candidate, { authoritativeProvisionIntents: true });
+		note([
+			`Applications: *.${domain}`,
+			`API stays at ${manifest.endpoints.apiUrl}`,
+			"Existing workers.dev app URLs keep working.",
+			...plan.actions.filter((action) => action.kind === "zone" || action.kind === "dns-record").map((action) => `${action.action} ${action.kind}: ${action.name}`),
+			...createApplicationRoutes(target).map((route) => `route ${route.pattern}`)
+		].join("\n"), "Application domain plan");
+		if (args.plan) return;
+		assertPlatformOperatorCredentialCanApplyPlan(credential, plan);
+		if (!args.yes) {
+			const accepted = await confirm({
+				message: "Set up this application domain?",
+				initialValue: false
+			});
+			if (isCancel(accepted) || !accepted) return;
+		}
+		const routingId = manifest.resources.find((resource) => resource.key === "routing-kv")?.id;
+		if (!routingId || !checkpoint) throw new Error("platform: Verified routing storage and lifecycle lock are required.");
+		const result = await applyPlatformDomain(client, manifest, target, plan, {
+			checkpoint: async (next) => {
+				await checkpoint(next);
+				writeInstallationManifest(next);
+				await client.putKvValue(next.account.id, routingId, PLATFORM_REMOTE_INSTALLATION_MANIFEST_KEY, JSON.stringify(next));
+			},
+			verifyOwnership: (next) => verifyPlatformInstallationOwnership(client, next),
+			verifyRuntimeToken: async (zoneId) => {
+				const url = `${manifest.endpoints.apiUrl}/internal/platform/domain-preflight`;
+				const response = await fetch(url, {
+					method: "POST",
+					redirect: "manual",
+					signal: AbortSignal.timeout(3e4),
+					headers: {
+						"Content-Type": "application/json",
+						"X-Void-Platform-Probe": createPlatformHealthProbeToken(manifest.ownershipNonce),
+						...cfAccessHeaders(process.env, url)
+					},
+					body: JSON.stringify({
+						zoneId,
+						domain
+					})
+				});
+				const body = await response.json();
+				if (!response.ok || body.ok !== true || body.installationId !== manifest.id) throw new Error(`platform: The running platform could not verify cache-purge access for ${domain}. Grant its existing runtime token Cache Purge: Purge on this zone, then rerun this command.`);
+			}
+		});
+		if (result.waitingForDns) {
+			note(`Set the domain's nameservers at its registrar to:\n${result.nameServers.join("\n")}\nThen rerun: void platform domain set ${domain}`, "Waiting for DNS");
+			return;
+		}
+		savePlatformConnection({
+			accountId: manifest.account.id,
+			apiUrl: manifest.endpoints.apiUrl,
+			applicationDomain: domain,
+			displayName: deployment.displayName,
+			installationId: manifest.id,
+			kind: "installed",
+			proxyUrl: manifest.endpoints.proxyUrl
+		});
+		log.success(`Apps now use *.${domain}. Existing workers.dev URLs remain available; the API connection is unchanged.`);
+	};
+	if (args.plan) {
+		await execute(selected);
+		return;
+	}
+	const release = acquirePlatformLifecycleLock(selected.account.id, selected.deployment.installationSlug);
+	try {
+		const recovery = readInstallationRecoverySecrets(selected);
+		const databaseUrl = resolvePlatformInstallDatabaseUrl(recovery, selected);
+		if (!databaseUrl) throw new Error("platform: Supply VOID_PLATFORM_DATABASE_URL to coordinate domain setup.");
+		const databaseLock = await acquirePlatformDatabaseLifecycleLock(databaseUrl, selected.id, selected.ownershipNonce);
+		try {
+			await execute(selectAuthoritativePlatformManifest(selected, databaseLock.authoritativeManifest), databaseLock.checkpoint);
+		} finally {
+			await databaseLock();
+		}
+	} finally {
+		release();
+	}
+}
+//#endregion
+export { runPlatformDomainCommand };