void 0.21.9 → 0.23.0

package/dist/{platform-lifecycle-Bs2qx1E3.mjs → platform-lifecycle-BE6C_jxh.mjs}

@@ -1,2 +1,2 @@
-import { r as runPlatformLifecycleCommand } from "./platform-lifecycle-Bc047IeT.mjs";
+import { r as runPlatformLifecycleCommand } from "./platform-lifecycle-9OyBALhH.mjs";
 export { runPlatformLifecycleCommand };

package/dist/{platform-management-CVpGI9Y5.mjs → platform-management-CjwLVQwN.mjs}

@@ -1,7 +1,7 @@
-import { i as createSpinner } from "./output-CCH48AMM.mjs";
 import { a as listInstallationManifests, d as readInstallationRecoverySecrets, h as resolveInstallationManifest, m as removePlatformConnectionForInstallation, p as removeInstallationRecoverySecrets, t as acquirePlatformLifecycleLock, v as writeInstallationManifest } from "./platform-registry-QBa4DK32.mjs";
-import { E as confirm, I as select, N as note, P as outro, W as isCancel, j as log } from "./dist-Dn6nn2IU.mjs";
-import { A as hyperdriveOriginFromConnectionString, C as assertPlatformOperatorCredentialCanApplyPlan, M as verifyPlatformRuntimeTokenPermissions, O as PlatformCloudflareClient, S as platformDatabaseNameFromOwnerUrl, _ as createPlatformInstallPlan, a as REMOTE_INSTALLATION_MANIFEST_KEY, b as platformProvisionIntentHash, d as loadPlatformRuntime, g as trackedPlatformWorkerTraffic, j as hyperdriveOriginMatches, k as hyperdriveOriginConfigHash, l as createPlatformInstallationSecrets, m as resolveBootstrapGitHubId, n as resolvePlatformInstallDatabaseUrl, o as acquirePlatformDatabaseLifecycleLock, t as assertNoninteractivePlatformMutationAcknowledged, u as installPlatform, v as formatPlatformInstallPlan, w as resolvePlatformCloudflareCredential, x as revalidatePlatformInstallAction, y as platformAdoptionIntentHash } from "./platform-lifecycle-Bc047IeT.mjs";
+import { E as confirm, I as select, N as note, P as outro, W as isCancel, j as log } from "./dist-CTBk70IR.mjs";
+import { i as createSpinner } from "./output-Dm_A4Tbv.mjs";
+import { A as PlatformCloudflareClient, C as revalidatePlatformInstallAction, E as resolvePlatformCloudflareCredential, M as hyperdriveOriginFromConnectionString, N as hyperdriveOriginMatches, P as verifyPlatformRuntimeTokenPermissions, S as platformProvisionIntentHash, T as assertPlatformOperatorCredentialCanApplyPlan, a as REMOTE_INSTALLATION_MANIFEST_KEY, b as formatPlatformInstallPlan, d as loadPlatformRuntime, g as assertProjectZeroTrustAllowsUninstall, h as resolveBootstrapGitHubId, j as hyperdriveOriginConfigHash, l as createPlatformInstallationSecrets, n as resolvePlatformInstallDatabaseUrl, o as acquirePlatformDatabaseLifecycleLock, p as readPlatformProjectZeroTrustState, t as assertNoninteractivePlatformMutationAcknowledged, u as installPlatform, v as trackedPlatformWorkerTraffic, w as platformDatabaseNameFromOwnerUrl, x as platformAdoptionIntentHash, y as createPlatformInstallPlan } from "./platform-lifecycle-9OyBALhH.mjs";
 import { createHash } from "node:crypto";
 import { PLATFORM_DISABLED_KEY, PLATFORM_DISABLED_VALUE, PLATFORM_R2_OWNERSHIP_MARKER_KEY, createPlatformResourceOwnershipMarker, parsePlatformInstallationManifest, parsePlatformResourceOwnershipMarker, recordInstallationResource, recordInstallationStep, setInstallationDesiredState, transitionInstallation } from "@void/platform";
 //#region src/cli/platform-management.ts
@@ -58,7 +58,11 @@ async function runInstalledPlatformCommand(args) {
 		if (args.subcommand === "uninstall") {
 			await uninstallPlatform(client, manifest, args, {
 				checkpoint: databaseLock?.checkpoint,
-				databaseUrl
+				databaseUrl,
+				readProjectZeroTrust: databaseLock ? databaseLock.readProjectZeroTrust : () => readPlatformProjectZeroTrustState(databaseUrl, manifest.id, manifest.ownershipNonce),
+				lockProjectZeroTrust: databaseLock?.lockProjectZeroTrust,
+				fenceProjectZeroTrust: databaseLock?.fenceProjectZeroTrust,
+				liftProjectZeroTrustFence: databaseLock?.liftProjectZeroTrustFence
 			});
 			return;
 		}
@@ -73,6 +77,7 @@ async function runInstalledPlatformCommand(args) {
 			...args.subcommand === "upgrade" && process.env.VOID_EMAIL_SENDER_DOMAIN ? { emailSenderDomain: process.env.VOID_EMAIL_SENDER_DOMAIN } : {},
 			applicationDomain: deployment.application.baseDomain,
 			controlPlaneDomain: deployment.controlPlane.apiHostname ?? "",
+			...args.subcommand !== "rollback" && args.dashboardUrl !== void 0 ? { dashboardUrl: args.dashboardUrl } : {},
 			dedicatedZone: deployment.application.dedicatedZone,
 			displayName: deployment.displayName,
 			installationSlug: deployment.installationSlug,
@@ -83,7 +88,8 @@ async function runInstalledPlatformCommand(args) {
 			repairMissing: args.subcommand === "repair",
 			allowUnverifiedAiGateway: args.plan,
 			includeEmailGateway: runtime.manifest.artifacts.emailGateway !== void 0,
-			enableSandbox: runtime.manifest.safetyProtocols.sandboxDrain >= 3
+			enableSandbox: runtime.manifest.safetyProtocols.sandboxDrain >= 3,
+			deploymentExecution: runtime.manifest.deploymentExecution === 1
 		});
 		markPhase("plan");
 		note(formatPlatformInstallPlan(plan), args.subcommand === "upgrade" ? "Upgrade plan" : args.subcommand === "rollback" ? "Rollback plan" : args.subcommand === "enable" ? "Enable plan" : "Repair plan");
@@ -145,6 +151,7 @@ async function runInstalledPlatformCommand(args) {
 		const result = await installPlatform(plan, secrets, installation, {
 			acquireDatabaseLifecycleLock: async () => Object.assign(async () => {}, {
 				checkpoint: databaseLock?.checkpoint,
+				liftProjectZeroTrustFence: databaseLock?.liftProjectZeroTrustFence,
 				prepareDatabase: databaseLock?.prepareDatabase,
 				prepareSandboxDrain: databaseLock?.prepareSandboxDrain,
 				readAuthenticationState: databaseLock?.readAuthenticationState,
@@ -162,9 +169,13 @@ async function runInstalledPlatformCommand(args) {
 				authoritativeProvisionIntents: true,
 				repairMissing: true,
 				includeEmailGateway: runtime.manifest.artifacts.emailGateway !== void 0,
-				enableSandbox: runtime.manifest.safetyProtocols.sandboxDrain >= 3
+				enableSandbox: runtime.manifest.safetyProtocols.sandboxDrain >= 3,
+				deploymentExecution: runtime.manifest.deploymentExecution === 1
 			})).actions.filter((action) => action.kind === "worker"),
-			revalidateBeforeWorkerDeploy: (manifest, action) => revalidatePlatformInstallAction(client, plan, manifest, action, { repairMissing: args.subcommand === "repair" })
+			revalidateBeforeWorkerDeploy: (manifest, action) => revalidatePlatformInstallAction(client, plan, manifest, action, {
+				repairMissing: args.subcommand === "repair",
+				stableWorkerUpdate: args.subcommand === "upgrade"
+			})
 		});
 		progress.message("Finalizing platform changes");
 		markPhase("installer complete");
@@ -315,8 +326,9 @@ async function uninstallPlatform(client, initialManifest, args, dependencies = {
 	const interactive = dependencies.interactive ?? process.stdin.isTTY;
 	const confirmAction = dependencies.confirm ?? promptForConfirmation;
 	if (createdZone && args.deleteZone === true) throw new Error(`platform: Refusing to delete Cloudflare zone ${JSON.stringify(createdZone.name)} automatically. A zone can contain unrelated DNS, settings, and products that the installer cannot exhaustively prove ownership of. Uninstall with --keep-zone, inspect the retained zone in Cloudflare, and delete it manually if appropriate.`);
+	await assertProjectZeroTrustAllowsUninstall(dependencies.readProjectZeroTrust);
 	const dataMessage = retainData ? "Retain installer-owned Workers, storage, dispatch, AI logs, and Hyperdrive by default." : args.purgeData ? "Delete safely identifiable installer-owned data (--purge-data); retain Workers, R2, AI Gateway, and external PostgreSQL for manual cleanup." : "Retain installer-owned data; external PostgreSQL is never deleted.";
-	note(`Disable all platform traffic through installation-owned routing storage.\nRetain DNS records, routes, and custom domains for explicit dashboard cleanup.\nDelete installer-owned Queues.\n${dataMessage}\n${createdZone ? `Keep zone ${createdZone.name} for explicit manual cleanup.` : "Never delete the adopted application zone."}${(manifest.authenticationResources ?? []).length ? "\nRetain Access resources for deliberate cleanup:\n" + manifest.authenticationResources.map((resource) => `  ${resource.ownership} ${resource.kind}: ${resource.name} (${resource.id}, account ${resource.accountId})`).join("\n") : ""}`, "Uninstall plan");
+	note(`Disable all platform traffic through installation-owned routing storage.\nRetain DNS records, routes, and custom domains for explicit dashboard cleanup.\nDelete installer-owned Queues unless a retained Worker still uses them.\n${dataMessage}\n${createdZone ? `Keep zone ${createdZone.name} for explicit manual cleanup.` : "Never delete the adopted application zone."}${(manifest.authenticationResources ?? []).length ? "\nRetain Access resources for deliberate cleanup:\n" + manifest.authenticationResources.map((resource) => `  ${resource.ownership} ${resource.kind}: ${resource.name} (${resource.id}, account ${resource.accountId})`).join("\n") : ""}`, "Uninstall plan");
 	if (args.plan) {
 		outro("No Cloudflare or local installation state was changed.");
 		return;
@@ -345,12 +357,34 @@ async function uninstallPlatform(client, initialManifest, args, dependencies = {
 		await verifyPlatformInstallationOwnership(client, manifest, { databaseUrl: dependencies.databaseUrl });
 		missingResources = /* @__PURE__ */ new Set();
 	}
-	let next = transitionInstallation(manifest, "uninstalling", (/* @__PURE__ */ new Date()).toISOString());
-	writeInstallationManifest(next);
+	const { fenceProjectZeroTrust, liftProjectZeroTrustFence, lockProjectZeroTrust } = dependencies;
+	if (!lockProjectZeroTrust || !fenceProjectZeroTrust || !liftProjectZeroTrustFence) throw new Error("platform: Refusing to uninstall because no platform database connection is available to hold off project Zero Trust changes.");
+	const releaseProjectZeroTrust = await lockProjectZeroTrust();
+	let fenced = false;
+	let disablingTraffic = false;
+	const stopProjectZeroTrustHold = async () => {
+		if (fenced && !disablingTraffic) await liftProjectZeroTrustFence().catch((error) => {
+			log.warn(`Could not reopen project Zero Trust changes after the uninstall stopped: ${error instanceof Error ? error.message : String(error)}\nRun \`void platform uninstall\` again, or \`void platform repair\` to keep the platform.`);
+		});
+		await releaseProjectZeroTrust();
+	};
+	let next = manifest;
+	try {
+		await assertProjectZeroTrustAllowsUninstall(dependencies.readProjectZeroTrust);
+		fenced = true;
+		await fenceProjectZeroTrust();
+		next = transitionInstallation(manifest, "uninstalling", (/* @__PURE__ */ new Date()).toISOString());
+		writeInstallationManifest(next);
+	} catch (error) {
+		await stopProjectZeroTrustHold();
+		throw error;
+	}
 	try {
 		await writeRemoteManifestIfPresent(client, next);
 		const routing = next.resources.find((resource) => resource.key === "routing-kv" && resource.state === "ready");
+		disablingTraffic = true;
 		if (routing) await client.putKvValue(next.account.id, routing.id, PLATFORM_DISABLED_KEY, PLATFORM_DISABLED_VALUE);
+		await releaseProjectZeroTrust();
 		for (const key of missingResources) {
 			const resource = requireResource(next, key);
 			next = updateResourceState(next, key, resource.ownership === "created" ? "deleted" : "retained");
@@ -383,6 +417,7 @@ async function uninstallPlatform(client, initialManifest, args, dependencies = {
 			zone: 8
 		};
 		const resources = [...next.resources].sort((left, right) => resourceDeletionPriority(left, deletionPriority) - resourceDeletionPriority(right, deletionPriority));
+		const queuesInUse = hasRoutingCheckpoint && resources.some((resource) => resource.kind === "queue" && shouldDeleteResource(resource, retainData)) && await hasLiveInstallationWorker(client, next);
 		for (const resource of resources) {
 			if (resource.state !== "ready") continue;
 			if (!hasRoutingCheckpoint && resource.kind !== "zone") {
@@ -395,7 +430,7 @@ async function uninstallPlatform(client, initialManifest, args, dependencies = {
 				await writeLifecycleCheckpoint(client, next);
 				continue;
 			}
-			if (resource.kind === "dns-record" && !zone) {
+			if (resource.kind === "dns-record" && !zone || resource.kind === "queue" && queuesInUse) {
 				next = updateResourceState(next, resource.key, "retained");
 				await writeLifecycleCheckpoint(client, next);
 				continue;
@@ -420,6 +455,7 @@ async function uninstallPlatform(client, initialManifest, args, dependencies = {
 		removePlatformConnectionForInstallation(next.id);
 		log.success(retainData ? `${next.deployment.displayName} was uninstalled; data resources were retained and recorded in ${next.id}.` : `${next.deployment.displayName} was uninstalled.`);
 	} catch (error) {
+		await stopProjectZeroTrustHold().catch(() => {});
 		next = transitionInstallation(next, "failed", (/* @__PURE__ */ new Date()).toISOString());
 		writeInstallationManifest(next);
 		await writeRemoteManifestIfPresent(client, next).catch(() => {});
@@ -505,6 +541,18 @@ function shouldDeleteResource(resource, retainData) {
 	if (resource.kind === "worker-route" || resource.kind === "worker-custom-domain") return false;
 	return !(retainData && DATA_RESOURCE_KINDS.has(resource.kind));
 }
+async function hasLiveInstallationWorker(client, manifest) {
+	const names = manifest.deployment.resources;
+	const installationWorkers = /* @__PURE__ */ new Set([
+		names.apiWorker,
+		names.proxyWorker,
+		names.emailGatewayWorker,
+		names.tailWorker,
+		names.dispatchWorker,
+		...manifest.resources.filter((resource) => resource.kind === "worker").map((resource) => resource.name)
+	]);
+	return (await client.listWorkerNames(manifest.account.id)).some((name) => installationWorkers.has(name));
+}
 function resourceDeletionPriority(resource, priorities) {
 	return resource.key === "routing-kv" ? 100 : priorities[resource.kind] ?? 99;
 }

package/dist/{platform-management-C8tt6D8h.mjs → platform-management-CnyTdcWX.mjs}

@@ -1,2 +1,2 @@
-import { c as selectAuthoritativePlatformManifest, s as runInstalledPlatformCommand, u as verifyPlatformInstallationOwnership } from "./platform-management-CVpGI9Y5.mjs";
+import { c as selectAuthoritativePlatformManifest, s as runInstalledPlatformCommand, u as verifyPlatformInstallationOwnership } from "./platform-management-CjwLVQwN.mjs";
 export { runInstalledPlatformCommand, selectAuthoritativePlatformManifest, verifyPlatformInstallationOwnership };

package/dist/platform-plans-config-BNGKGr4P.mjs

@@ -0,0 +1,359 @@
+import { B as text, E as confirm, I as select, W as isCancel } from "./dist-CTBk70IR.mjs";
+import { n as OperatorClient, r as OperatorClientError } from "./operator-client-DUwumHpQ.mjs";
+import { a as resolveOperatorOrigin, r as readOperatorToken } from "./operator-auth-8KnOVXVd.mjs";
+import { stripVTControlCharacters } from "node:util";
+import { PLAN_EDITABLE_LIMIT_KEYS, PLAN_LIMITS, parseBuildInstanceType, parsePlanLimitsPatch, parsePlanName, parsePlatformPlanId } from "@void/platform/plans";
+import { readFile } from "node:fs/promises";
+//#region src/cli/platform-plans-config.ts
+const limitLabels = {
+	requestsPerMonth: "Requests per billing month",
+	cpuMsPerRequest: "Default CPU per request (ms)",
+	maxCpuMsPerRequest: "Maximum app CPU per request (ms)",
+	subRequestsPerInvocation: "Subrequests per invocation",
+	deploysPerDay: "Deployments per day",
+	aiNeuronsPerMonth: "AI neurons per billing month",
+	retainedDeployments: "Retained Worker deployments",
+	sandboxRuntimeSecondsPerMonth: "Sandbox runtime per billing month (seconds)",
+	sandboxMaxConcurrentInstances: "Concurrent Sandbox instances",
+	concurrentBuilds: "Concurrent builds",
+	buildTimeoutMinutes: "Build timeout (minutes)"
+};
+function limitValue(value, key) {
+	if (value === 0 && key === "buildTimeoutMinutes") return "platform maximum (60 minutes)";
+	return value === 0 ? "unlimited" : value.toLocaleString("en-US");
+}
+function showListing(listing, json) {
+	if (json) {
+		print(listing);
+		return;
+	}
+	console.log(`Default for new accounts: ${listing.catalog.defaultPlanId}`);
+	for (const plan of listing.catalog.plans) {
+		const count = listing.accounts.find((entry) => entry.planId === plan.id)?.count ?? 0;
+		console.log(`${label(plan)} — ${count} accounts`);
+	}
+	if (listing.catalog.reconciliation && !listing.catalog.reconciliation.complete) console.log("Account updates are pending. Run void platform config plans sync --yes.");
+}
+function showPreview(preview, before, write = console.error) {
+	const after = preview.catalog;
+	write(`Change: ${preview.action} ${preview.target}`);
+	write(`Accounts affected: ${preview.affectedAccounts}`);
+	for (const warning of preview.warnings ?? []) write(stripVTControlCharacters(warning));
+	if (typeof preview.usageSampleSize === "number" && preview.usageSampleSize > 0) write(`Usage preview samples ${preview.usageSampleSize} accounts.`);
+	if (before.defaultPlanId !== after.defaultPlanId) write(`Default for new accounts: ${before.defaultPlanId} → ${after.defaultPlanId}`);
+	for (const plan of after.plans) {
+		const previous = before.plans.find((entry) => entry.id === plan.id);
+		if (!previous) {
+			write(`Add ${label(plan)}; build size ${plan.buildInstanceType}`);
+			for (const key of PLAN_EDITABLE_LIMIT_KEYS) write(`  ${limitLabels[key]}: ${limitValue(plan.limits[key], key)}`);
+			write(`  Short project slugs: ${plan.allowShortSlugs ? "allowed" : "not allowed"}`);
+			continue;
+		}
+		if (previous.name !== plan.name) write(`Name: ${previous.name} → ${plan.name}`);
+		if (previous.archived !== plan.archived) write(`${plan.id}: ${plan.archived ? "archive for new assignments" : "restore assignments"}`);
+		if (previous.buildInstanceType !== plan.buildInstanceType) write(`Build size: ${previous.buildInstanceType} → ${plan.buildInstanceType}`);
+		if (previous.allowShortSlugs !== plan.allowShortSlugs) write(`Short project slugs: ${previous.allowShortSlugs ? "allowed" : "not allowed"} → ${plan.allowShortSlugs ? "allowed" : "not allowed"}`);
+		for (const key of PLAN_EDITABLE_LIMIT_KEYS) if (previous.limits[key] !== plan.limits[key]) write(`${limitLabels[key]}: ${limitValue(previous.limits[key], key)} → ${limitValue(plan.limits[key], key)}`);
+	}
+	for (const plan of before.plans) if (!after.plans.some((entry) => entry.id === plan.id)) {
+		write(`Remove ${label(plan)}`);
+		const replacement = after.plans.find((entry) => entry.id === preview.replacementPlanId);
+		if (replacement) {
+			write(`Move accounts to ${label(replacement)}`);
+			if (plan.buildInstanceType !== replacement.buildInstanceType) write(`Build size: ${plan.buildInstanceType} → ${replacement.buildInstanceType}`);
+			if (plan.allowShortSlugs !== replacement.allowShortSlugs) write(`Short project slugs: ${plan.allowShortSlugs ? "allowed" : "not allowed"} → ${replacement.allowShortSlugs ? "allowed" : "not allowed"}`);
+			for (const key of PLAN_EDITABLE_LIMIT_KEYS) if (plan.limits[key] !== replacement.limits[key]) write(`${limitLabels[key]}: ${limitValue(plan.limits[key], key)} → ${limitValue(replacement.limits[key], key)}`);
+		}
+	}
+	for (const account of preview.overLimitAccounts ?? []) write(`Already above proposed limits: ${stripVTControlCharacters(account.login)} (${account.id}): ${account.reasons.join(", ")}`);
+}
+function value(input) {
+	if (isCancel(input) || typeof input === "symbol") throw new Error("platform: Cancelled.");
+	return input;
+}
+function print(result) {
+	console.log(JSON.stringify(result, null, 2));
+}
+function label(plan) {
+	return `${stripVTControlCharacters(plan.name)} (${plan.id}${plan.archived ? ", archived" : ""})`;
+}
+async function choosePlan(catalog, message, options = {}) {
+	const plans = catalog.plans.filter((plan) => plan.id !== options.exclude && (!options.activeOnly || !plan.archived));
+	if (!plans.length) throw new Error("platform: No eligible plans are available.");
+	return value(await select({
+		message,
+		options: plans.map((plan) => ({
+			value: plan.id,
+			label: label(plan)
+		}))
+	}));
+}
+async function changesInput(args, plan) {
+	if (args.file) {
+		const input = JSON.parse(await readFile(args.file, "utf8"));
+		if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("platform: A plan file must contain a JSON object.");
+		const object = input;
+		for (const key of Object.keys(object)) if (![
+			"name",
+			"limits",
+			"buildInstanceType",
+			"allowShortSlugs"
+		].includes(key)) throw new Error(`platform: Unknown plan field ${key}. Use name, limits, buildInstanceType, or allowShortSlugs.`);
+		if (object.allowShortSlugs !== void 0 && typeof object.allowShortSlugs !== "boolean") throw new Error("platform: allowShortSlugs must be a boolean.");
+		return {
+			...object,
+			...object.name !== void 0 ? { name: parsePlanName(object.name) } : {},
+			...object.buildInstanceType !== void 0 ? { buildInstanceType: parseBuildInstanceType(object.buildInstanceType) } : {},
+			...object.limits !== void 0 ? { limits: parsePlanLimitsPatch(object.limits) } : {},
+			...args.name ? { name: parsePlanName(args.name) } : {}
+		};
+	}
+	if (args.name) return { name: parsePlanName(args.name) };
+	if (!process.stdin.isTTY || args.json) {
+		if (args.action === "add") throw new Error("platform: Supply --name or --file when adding a plan in non-interactive mode.");
+		throw new Error("platform: Supply --name or --file with the changes in non-interactive mode.");
+	}
+	if (args.action === "add") return { name: parsePlanName(value(await text({
+		message: "Plan name:",
+		initialValue: args.target
+	}))) };
+	const field = value(await select({
+		message: "What would you like to change?",
+		options: [
+			{
+				value: "name",
+				label: "Plan name"
+			},
+			...PLAN_EDITABLE_LIMIT_KEYS.map((key) => ({
+				value: key,
+				label: `${limitLabels[key]}: ${limitValue(plan.limits[key], key)}`
+			})),
+			{
+				value: "buildInstanceType",
+				label: "Build instance size"
+			}
+		]
+	}));
+	if (field === "name") return { name: parsePlanName(value(await text({
+		message: "Plan name:",
+		initialValue: plan.name
+	}))) };
+	if (field === "buildInstanceType") return { buildInstanceType: value(await select({
+		message: "Build instance size:",
+		initialValue: plan.buildInstanceType,
+		options: [{
+			value: "standard-3",
+			label: "Standard: 2 vCPU, 8 GiB"
+		}, {
+			value: "standard-4",
+			label: "Large: 4 vCPU, 12 GiB"
+		}]
+	})) };
+	const current = plan.limits[field];
+	const input = value(await text({
+		message: `${limitLabels[field]} (${field === "buildTimeoutMinutes" ? "0 uses the platform maximum of 60 minutes" : "0 means unlimited"}):`,
+		initialValue: String(current),
+		validate: (value) => /^\d+$/.test(value ?? "") && Number.isSafeInteger(Number(value)) ? void 0 : "Enter a nonnegative whole number."
+	}));
+	return { limits: parsePlanLimitsPatch({ [field]: Number(input) }) };
+}
+async function apply(client, path, body, args, catalog) {
+	if (!args.plan && !args.yes && (!process.stdin.isTTY || args.json)) throw new Error("platform: Configuration changes require --yes or --plan in non-interactive mode.");
+	const preview = await client.request(path, {
+		method: "POST",
+		body: {
+			...body,
+			dryRun: true
+		}
+	});
+	if (args.plan) {
+		if (args.json) print(preview);
+		else showPreview(preview, catalog, console.log);
+		return;
+	}
+	if (!Number.isSafeInteger(preview.expectedRevision)) throw new Error("platform: The platform returned an invalid plan revision.");
+	if (!args.yes) {
+		showPreview(preview, catalog);
+		if (!value(await confirm({
+			message: `Apply this change to ${client.origin}?`,
+			initialValue: false
+		}))) throw new Error("platform: Cancelled.");
+	}
+	let result = await client.request(path, {
+		method: "POST",
+		body: {
+			...body,
+			expectedRevision: preview.expectedRevision
+		}
+	});
+	const committedCatalog = result.catalog;
+	if (!Number.isSafeInteger(committedCatalog?.revision)) throw new Error("platform: The platform returned an invalid saved plan revision. Inspect the catalog before retrying.");
+	const committedRevision = committedCatalog.revision;
+	const applied = result;
+	let previousCursor = catalog.reconciliation?.cursor ?? null;
+	while (true) {
+		const reconciliation = result.reconciliation;
+		if (!reconciliation || reconciliation.complete !== false) break;
+		const currentCatalog = result.catalog;
+		const cursor = currentCatalog.reconciliation?.cursor ?? null;
+		if (reconciliation.error || !Number.isSafeInteger(reconciliation.processed) || reconciliation.processed <= 0 || cursor === previousCursor || currentCatalog.revision !== committedRevision) {
+			const pending = {
+				...applied,
+				...result
+			};
+			print(pending);
+			throw new OperatorClientError("Plan configuration was saved, but account updates are pending. Run void platform config plans sync --yes.", "plan_sync_pending", void 0, pending);
+		}
+		previousCursor = cursor;
+		result = await client.request("/config/plans/sync", {
+			method: "POST",
+			body: { expectedRevision: committedRevision }
+		});
+	}
+	const completed = {
+		...applied,
+		...result
+	};
+	if (args.json) print(completed);
+	else console.log(`Saved ${applied.action ?? "plans.sync"} ${applied.target ?? ""}. Account updates complete.`);
+}
+async function runPlatformPlansConfig(args) {
+	const origin = resolveOperatorOrigin(args.connection);
+	const client = new OperatorClient(origin, readOperatorToken(origin));
+	const listing = await client.request("/config/plans");
+	const { catalog } = listing;
+	if (!args.action) {
+		if (!process.stdin.isTTY || args.json) {
+			showListing(listing, args.json);
+			return;
+		}
+		const selected = value(await select({
+			message: "Platform plans:",
+			options: [
+				...catalog.plans.map((plan) => ({
+					value: plan.id,
+					label: `${label(plan)}${plan.id === catalog.defaultPlanId ? " — default" : ""}`,
+					hint: `${listing.accounts.find((entry) => entry.planId === plan.id)?.count ?? 0} accounts`
+				})),
+				{
+					value: ":add",
+					label: "Add a plan by copying an existing plan"
+				},
+				{
+					value: ":default",
+					label: "Choose the default for new accounts"
+				},
+				...catalog.reconciliation && !catalog.reconciliation.complete ? [{
+					value: ":sync",
+					label: "Continue pending account updates"
+				}] : []
+			]
+		}));
+		if (selected === ":sync") return runPlatformPlansConfig({
+			...args,
+			action: "sync"
+		});
+		if (selected === ":default") {
+			const target = await choosePlan(catalog, "Default plan for new accounts:", { activeOnly: true });
+			return runPlatformPlansConfig({
+				...args,
+				action: "default",
+				target
+			});
+		}
+		if (selected === ":add") {
+			const target = parsePlatformPlanId(value(await text({ message: "New plan ID (stable; lowercase letters, digits, and hyphens):" })));
+			const copy = await choosePlan(catalog, "Copy limits and build size from:");
+			return runPlatformPlansConfig({
+				...args,
+				action: "add",
+				target,
+				copy
+			});
+		}
+		const plan = catalog.plans.find((entry) => entry.id === selected);
+		const action = value(await select({
+			message: label(plan),
+			options: [
+				{
+					value: "show",
+					label: "Show limits and account count"
+				},
+				{
+					value: "set",
+					label: "Edit name or limits"
+				},
+				{
+					value: plan.archived ? "restore" : "archive",
+					label: plan.archived ? "Restore assignments to this plan" : "Archive for new assignments"
+				},
+				...Object.hasOwn(PLAN_LIMITS, plan.id) ? [{
+					value: "reset",
+					label: "Reset to original limits and build size"
+				}] : [],
+				{
+					value: "remove",
+					label: "Remove this plan"
+				}
+			]
+		}));
+		return runPlatformPlansConfig({
+			...args,
+			action,
+			target: selected
+		});
+	}
+	if (args.action === "show") {
+		if (!args.target) showListing(listing, args.json);
+		else {
+			const result = await client.request(`/config/plans/${encodeURIComponent(args.target)}`);
+			if (args.json) print(result);
+			else {
+				const plan = result.plan;
+				console.log(`${label(plan)}${result.default ? " — default for new accounts" : ""}`);
+				console.log(`Accounts: ${result.accounts}; build size: ${plan.buildInstanceType}`);
+				console.log(`Short project slugs: ${plan.allowShortSlugs ? "allowed" : "not allowed"}`);
+				for (const key of PLAN_EDITABLE_LIMIT_KEYS) console.log(`${limitLabels[key]}: ${limitValue(plan.limits[key], key)}`);
+			}
+		}
+		return;
+	}
+	let body = {};
+	let path = `/config/plans/${encodeURIComponent(args.target)}/${args.action}`;
+	const plan = catalog.plans.find((entry) => entry.id === args.target);
+	if (args.action === "add") {
+		let copy = args.copy;
+		if (!copy) {
+			if (!process.stdin.isTTY || args.json) throw new Error("platform: Adding a plan requires --copy <plan-id> in non-interactive mode.");
+			copy = await choosePlan(catalog, "Copy limits and build size from:");
+		}
+		body = {
+			id: args.target,
+			copyFrom: copy,
+			...await changesInput(args)
+		};
+		path = "/config/plans/add";
+	} else if (args.action === "default") {
+		body = { planId: args.target };
+		path = "/config/plans/default";
+	} else if (args.action === "sync") path = "/config/plans/sync";
+	else {
+		if (!plan) throw new Error("platform: Plan not found. Run void platform config plans show.");
+		if (args.action === "set") body = await changesInput(args, plan);
+		else if (args.action === "archive" || args.action === "restore") {
+			path = `/config/plans/${encodeURIComponent(args.target)}/archive`;
+			body = { archived: args.action === "archive" };
+		} else if (args.action === "remove") {
+			let replacement = args.replacement;
+			const needsReplacement = args.target === catalog.defaultPlanId || (listing.accounts.find((entry) => entry.planId === args.target)?.count ?? 0) > 0;
+			if (!replacement && needsReplacement && process.stdin.isTTY && !args.json) replacement = await choosePlan(catalog, "Move accounts and any default to:", {
+				activeOnly: true,
+				exclude: args.target
+			});
+			body = replacement ? { replacementPlanId: replacement } : {};
+		}
+	}
+	await apply(client, path, body, args, catalog);
+}
+//#endregion
+export { runPlatformPlansConfig };

package/dist/{platform-recovery-dvUaptLr.mjs → platform-recovery-D6KSpuFm.mjs}

@@ -1,7 +1,7 @@
 import { t as cfAccessHeaders } from "./cf-access-DRsQRe6k.mjs";
 import { a as listInstallationManifests, g as savePlatformConnection, t as acquirePlatformLifecycleLock, v as writeInstallationManifest } from "./platform-registry-QBa4DK32.mjs";
-import { _ as createPlatformInstallPlan, a as REMOTE_INSTALLATION_MANIFEST_KEY } from "./platform-lifecycle-Bc047IeT.mjs";
-import { i as recoverDurablyMarkedProvisionIntents, r as isPlatformManifestMonotonicExtension, u as verifyPlatformInstallationOwnership } from "./platform-management-CVpGI9Y5.mjs";
+import { a as REMOTE_INSTALLATION_MANIFEST_KEY, y as createPlatformInstallPlan } from "./platform-lifecycle-9OyBALhH.mjs";
+import { i as recoverDurablyMarkedProvisionIntents, r as isPlatformManifestMonotonicExtension, u as verifyPlatformInstallationOwnership } from "./platform-management-CjwLVQwN.mjs";
 import { parsePlatformInstallationManifest, setInstallationEndpoints } from "@void/platform";
 //#region src/cli/platform-recovery.ts
 async function recoverPlatformInstallations(client, accountId, verifyEndpoint = verifyInstallationEndpoint, selector = "") {