reverseport 0.0.0-stage → 1.0.0

package/dist/cli-runtime/SetupHost-CzzRF89z.js

@@ -0,0 +1,842 @@
+import { __esmMin, __exportAll } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, compareUnicodeCodePoints, init_identity, init_unicodeCodePointOrder } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-BXkffc1D.js";
+import { ConfigurationError, init_configurationErrors } from "./configurationErrors-ByuF6gMR.js";
+import { clientEvidencePaths, homeDirectoryFromEnvironment, init_ClientRegistrationIdentity, init_SupportedClients, init_homeDirectory, invokingPackageRunner, npxRegistrationCommand, packageRunnerRegistrationCommand, supportedClients } from "./SupportedClients-BrZ2qZVg.js";
+import { RegularFileCleanupFailure, init_RegularFileRead, readRegularFileText, retryRegularFileCleanup } from "./RegularFileRead-BMh5FMXd.js";
+import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CZqLEfbb.js";
+import { SUPPORTED_NODE_VERSION_PROSE, init_runtimeVersion, supportsNodeVersion } from "./runtimeVersion-CMGd0bDu.js";
+import { MCP_STARTUP_POLICY, init_mcpStartupPolicy } from "./mcpStartupPolicy-Bb7TMLzn.js";
+import { HOPPER_DOWNLOAD_BYTES, downloadHopperPackage, init_Doctor, init_HopperDownload, init_LinuxHopper, installLinuxHopper, readLinuxDistribution, runDoctor, systemDoctorHost, systemLinuxHopperInstallHost } from "./Doctor-CzwYS9nB.js";
+import { DshCordisDocument, OMP_DISABLED_SERVERS_KEY, canonicalSkillNeedsInstall, clientConfigurationValuesEqual, clientRegistrationEntry, clientServerListedDisabled, clientServerPath, dshDocument, init_ClientConfigurationDocument, init_DshCordisPatch, init_SetupSkill, installCanonicalSkill, legacyClientServerPath, parseClientConfiguration, serializeClientConfiguration, skillDestinations, withClientServers } from "./ClientConfigurationDocument-D0ZqgTCv.js";
+import { clientRegistrationEnvironment, init_ClientConfigurationFiles, init_ClientRegistrationEnvironment, init_GeminiClientSettings, readClientConfigurationFiles, readClientPolicyBlock } from "./ClientRegistrationStatus-DGpwJ4ry.js";
+import { init_ClientConfigPath, resolveClientConfigTransactionPath } from "./ClientConfigPath-c6jr6INc.js";
+import { dirname, join, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { access, copyFile, mkdir, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+import writeFileAtomic from "write-file-atomic";
+
+//#region dist/application/MacHopper.js
+var execFileAsync, RELEASES_URL, DOWNLOAD_PREFIX, BUNDLE_IDENTIFIER, macHopperInstallDisclosure, installMacHopper, systemMacHopperInstallHost, parseJson, integrityMatches, commandSucceeds, failureMessage, releaseSchema, releasesSchema;
+function init_MacHopper() {
+	return (init_MacHopper = __esmMin((() => {
+		init_homeDirectory();
+		init_HopperDownload();
+		execFileAsync = promisify(execFile);
+		RELEASES_URL = "https://www.hopperapp.com/include/files-api.php?request=releases&public=true";
+		DOWNLOAD_PREFIX = "https://www.hopperapp.com:443/downloader/public/";
+		BUNDLE_IDENTIFIER = "com.cryptic-apps.hopper-web-4";
+		macHopperInstallDisclosure = {
+			networkOrigins: [RELEASES_URL, DOWNLOAD_PREFIX],
+			commands: [
+				"hdiutil attach -readonly -nobrowse -mountpoint <private-mount> <verified-hopper.dmg>",
+				"codesign --verify --deep --strict <mounted-hopper.app>",
+				"ditto <mounted-hopper.app> <user-Applications-stage>",
+				"open <installed-hopper.app>"
+			]
+		};
+		installMacHopper = async (options = {}, host = systemMacHopperInstallHost(homeDirectoryFromEnvironment(process.env, process.platform), process.env)) => {
+			let temporary;
+			let mounted = false;
+			let result;
+			try {
+				result = await (async () => {
+					const metadata = await host.download(RELEASES_URL);
+					if (!metadata.ok) return {
+						status: "failed",
+						reason: "release_metadata"
+					};
+					const parsed = releasesSchema.safeParse(parseJson(metadata.bytes));
+					if (!parsed.success) return {
+						status: "failed",
+						reason: "release_metadata"
+					};
+					const release = parsed.data["OS X"];
+					if (!release.filename.startsWith(DOWNLOAD_PREFIX)) return {
+						status: "failed",
+						reason: "release_metadata"
+					};
+					const archive = await host.download(release.filename);
+					if (!archive.ok) return {
+						status: "failed",
+						reason: "download"
+					};
+					if (!integrityMatches(archive.bytes, release)) return {
+						status: "failed",
+						reason: "integrity"
+					};
+					const destination = host.destination();
+					const destinationExists = await host.destinationExists(destination);
+					if (destinationExists && options.replaceExisting !== true) return {
+						status: "failed",
+						reason: "destination_exists"
+					};
+					temporary = await host.createTemporaryDirectory();
+					const packagePath = join(temporary, "hopper.dmg");
+					const mountPath = join(temporary, "mounted");
+					await host.createMountDirectory(mountPath);
+					await host.writePackage(packagePath, archive.bytes);
+					if (!await host.mount(packagePath, mountPath)) return {
+						status: "failed",
+						reason: "mount"
+					};
+					mounted = true;
+					const source = await host.appBundle(mountPath);
+					if (source === undefined || !await host.validBundle(source)) return {
+						status: "failed",
+						reason: "bundle"
+					};
+					const stage = `${destination}.rea-stage`;
+					if (!await host.installBundle(source, destination, stage, destinationExists)) return {
+						status: "failed",
+						reason: "copy"
+					};
+					const launcherPath = join(destination, "Contents/MacOS/hopper");
+					if (!await host.launcherReady(launcherPath)) return {
+						status: "failed",
+						reason: "launcher_missing"
+					};
+					await host.openApplication(destination);
+					return {
+						status: "installed",
+						launcherPath
+					};
+				})();
+			} catch (cause) {
+				void cause;
+				result = {
+					status: "failed",
+					reason: "download"
+				};
+			}
+			let cleanupFailure;
+			if (temporary !== undefined) {
+				const temporaryPath = temporary;
+				const mountPath = join(temporary, "mounted");
+				const cleanup = async () => {
+					if (mounted) {
+						await host.unmount(mountPath);
+						mounted = false;
+					}
+					await host.cleanup(temporaryPath);
+				};
+				try {
+					await cleanup();
+				} catch (cause) {
+					cleanupFailure = `Hopper DMG cleanup failed: ${failureMessage(cause)}`;
+					host.retainCleanup?.(cleanup);
+				}
+			}
+			return cleanupFailure === undefined ? result : {
+				...result,
+				cleanupFailure
+			};
+		};
+		systemMacHopperInstallHost = (homeDirectory, environment) => {
+			const pendingCleanup = new Set();
+			return {
+				download: downloadHopperPackage,
+				createTemporaryDirectory: () => mkdtemp(join(tmpdir(), "rea-hopper-mac-")),
+				createMountDirectory: (path) => mkdir(path),
+				writePackage: (path, bytes) => writeFile(path, bytes, { mode: 384 }),
+				async mount(packagePath, mountPath) {
+					return commandSucceeds("hdiutil", [
+						"attach",
+						"-readonly",
+						"-nobrowse",
+						"-mountpoint",
+						mountPath,
+						packagePath
+					], environment);
+				},
+				async unmount(mountPath) {
+					if (!await commandSucceeds("hdiutil", [
+						"detach",
+						mountPath,
+						"-force"
+					], environment)) throw new Error(`hdiutil detach failed for ${JSON.stringify(mountPath)}`);
+				},
+				async appBundle(mountPath) {
+					const entries = await readdir(mountPath, { withFileTypes: true });
+					const app = entries.find((entry) => entry.isDirectory() && /^Hopper.*\.app$/iu.test(entry.name));
+					return app === undefined ? undefined : join(mountPath, app.name);
+				},
+				async validBundle(appPath) {
+					if (!await commandSucceeds("codesign", [
+						"--verify",
+						"--deep",
+						"--strict",
+						appPath
+					], environment)) return false;
+					try {
+						const identifier = (await execFileAsync("/usr/libexec/PlistBuddy", [
+							"-c",
+							"Print :CFBundleIdentifier",
+							join(appPath, "Contents/Info.plist")
+						], { env: environment })).stdout.trim();
+						return identifier === BUNDLE_IDENTIFIER;
+					} catch (cause) {
+						void cause;
+						return false;
+					}
+				},
+				async destinationExists(path) {
+					try {
+						await access(path);
+						return true;
+					} catch (cause) {
+						void cause;
+						return false;
+					}
+				},
+				async installBundle(source, destination, stage, replaceExisting) {
+					const previous = `${stage}-previous`;
+					try {
+						await mkdir(join(homeDirectory, "Applications"), { recursive: true });
+						await rm(stage, {
+							recursive: true,
+							force: true
+						});
+						await rm(previous, {
+							recursive: true,
+							force: true
+						});
+						await execFileAsync("ditto", [source, stage], { env: environment });
+						await access(join(stage, "Contents/MacOS/hopper"));
+						if (replaceExisting) await rename(destination, previous);
+						await rename(stage, destination);
+						if (replaceExisting) await rm(previous, {
+							recursive: true,
+							force: true
+						});
+						return true;
+					} catch (cause) {
+						void cause;
+						await rm(stage, {
+							recursive: true,
+							force: true
+						});
+						if (replaceExisting) {
+							try {
+								await rename(previous, destination);
+							} catch (rollbackCause) {
+								void rollbackCause;
+							}
+						}
+						return false;
+					}
+				},
+				async launcherReady(path) {
+					try {
+						await access(path);
+						return true;
+					} catch (cause) {
+						void cause;
+						return false;
+					}
+				},
+				async openApplication(path) {
+					await execFileAsync("open", [path], { env: environment });
+				},
+				cleanup: (path) => rm(path, {
+					recursive: true,
+					force: true
+				}),
+				retainCleanup: (cleanup) => pendingCleanup.add(cleanup),
+				async close() {
+					let failure;
+					for (const cleanup of pendingCleanup) {
+						try {
+							await cleanup();
+							pendingCleanup.delete(cleanup);
+						} catch (cause) {
+							failure ??= `Hopper DMG cleanup remains incomplete: ${failureMessage(cause)}`;
+						}
+					}
+					return failure;
+				},
+				destination: () => join(homeDirectory, "Applications/Hopper Disassembler.app")
+			};
+		};
+		parseJson = (bytes) => JSON.parse(new TextDecoder().decode(bytes));
+		integrityMatches = (bytes, release) => bytes.byteLength === Number(release.file_length) && bytes.byteLength <= 1e8 && createHash("sha1").update(bytes).digest("hex") === release.file_hash;
+		commandSucceeds = async (command, args, environment) => {
+			try {
+				await execFileAsync(command, args, { env: environment });
+				return true;
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		failureMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		releaseSchema = z.object({
+			filename: z.string().url(),
+			file_length: z.string().regex(/^\d+$/u),
+			file_hash: z.string().regex(/^[a-f0-9]{40}$/u)
+		});
+		releasesSchema = z.object({ "OS X": releaseSchema });
+	})))();
+}
+
+//#endregion
+//#region dist/application/SetupClientConfiguration.js
+var configureClientConfiguration, configureClientDocument, persistClientConfiguration, clientConfigurationAligned, inspectClientConfiguration, isMissing, throwCleanupFailure, preserveConfigBackup, restoreConfig, registrationCurrent, clientConfigurationDesired;
+function init_SetupClientConfiguration() {
+	return (init_SetupClientConfiguration = __esmMin((() => {
+		init_GeminiClientSettings();
+		init_ClientConfigurationFiles();
+		init_ClientConfigurationDocument();
+		init_DshCordisPatch();
+		init_ClientRegistrationEnvironment();
+		init_identity();
+		init_ClientRegistrationIdentity();
+		init_mcpStartupPolicy();
+		init_ClientConfigPath();
+		init_RegularFileRead();
+		configureClientConfiguration = (client, environment = {}, command = npxRegistrationCommand()) => {
+			if (client.configPathError !== undefined) return Promise.resolve({
+				status: "failed",
+				reason: "path"
+			});
+			return configureClientDocument(client, environment, command);
+		};
+		configureClientDocument = async (client, environment, command) => {
+			const format = client.format;
+			if (format === undefined || format === "unsupported") return {
+				status: "failed",
+				reason: "readback"
+			};
+			const files = await readClientConfigurationFiles(client);
+			if (!files.ok) {
+				throwCleanupFailure(files.error);
+				return {
+					status: "failed",
+					reason: "readback"
+				};
+			}
+			const existing = files.value.at(-1);
+			const editabilityError = existing?.dialect === "dsh" ? dshDocument(existing.document).editabilityError : undefined;
+			if (editabilityError !== undefined) return {
+				status: "failed",
+				reason: "readback"
+			};
+			const policy = await readClientPolicyBlock(client, undefined, clientConfigurationDesired(client, environment, command, files.value.at(-1)));
+			if (!policy.ok) {
+				throwCleanupFailure(policy.error);
+				return {
+					status: "failed",
+					reason: "readback"
+				};
+			}
+			if (policy.value !== undefined) return {
+				status: "failed",
+				reason: "readback"
+			};
+			const transactionPath = await resolveClientConfigTransactionPath(client.configPath);
+			if (transactionPath === undefined) return {
+				status: "failed",
+				reason: "path"
+			};
+			let original;
+			try {
+				original = await readRegularFileText(transactionPath);
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				if (!isMissing(cause)) return {
+					status: "failed",
+					reason: "readback"
+				};
+			}
+			let parsed;
+			try {
+				parsed = parseClientConfiguration(original ?? (format === "toml" || format === "grok" || format === "dsh" ? "" : "{}"), format);
+				const policy = await readClientPolicyBlock(client, parsed, clientConfigurationDesired(client, environment, command, parsed));
+				if (!policy.ok) {
+					throwCleanupFailure(policy.error);
+					return {
+						status: "failed",
+						reason: "readback"
+					};
+				}
+				if (policy.value !== undefined) return {
+					status: "failed",
+					reason: "readback"
+				};
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				void cause;
+				return {
+					status: "failed",
+					reason: "readback"
+				};
+			}
+			const desired = clientConfigurationDesired(client, environment, command, parsed);
+			if (registrationCurrent(parsed, desired)) return { status: "unchanged" };
+			return persistClientConfiguration({
+				client,
+				transactionPath,
+				format,
+				original,
+				parsed,
+				desired
+			});
+		};
+		persistClientConfiguration = async ({ client, transactionPath, format, original, parsed, desired }) => {
+			const backupPath = original === undefined ? undefined : `${client.configPath}.rea.backup`;
+			if (backupPath !== undefined && !await preserveConfigBackup(transactionPath, backupPath)) return {
+				status: "failed",
+				reason: "backup"
+			};
+			const legacyPath = legacyClientServerPath(parsed, PRODUCT_IDENTITY.mcpServerKey);
+			const registered = withClientServers(parsed, {
+				...parsed.servers,
+				[PRODUCT_IDENTITY.mcpServerKey]: desired
+			}, PRODUCT_IDENTITY.mcpServerKey);
+			const ompDisabled = parsed.dialect === "omp" ? parsed.document[OMP_DISABLED_SERVERS_KEY] : undefined;
+			const enableOmp = Array.isArray(ompDisabled) && ompDisabled.includes(PRODUCT_IDENTITY.mcpServerKey);
+			const document = enableOmp && Array.isArray(ompDisabled) ? {
+				...registered,
+				[OMP_DISABLED_SERVERS_KEY]: ompDisabled.filter((name) => name !== PRODUCT_IDENTITY.mcpServerKey)
+			} : registered;
+			try {
+				await mkdir(dirname(client.configPath), { recursive: true });
+				await writeFileAtomic(transactionPath, serializeClientConfiguration(document, format, original, [
+					clientServerPath(parsed, PRODUCT_IDENTITY.mcpServerKey),
+					...legacyPath === undefined ? [] : [legacyPath],
+					...enableOmp ? [[OMP_DISABLED_SERVERS_KEY]] : []
+				]), {
+					encoding: "utf8",
+					mode: 384
+				});
+			} catch (cause) {
+				void cause;
+				return {
+					status: "failed",
+					reason: "write"
+				};
+			}
+			try {
+				const readback = parseClientConfiguration(await readRegularFileText(transactionPath), format);
+				if (!registrationCurrent(readback, desired)) {
+					await restoreConfig(transactionPath, original);
+					return {
+						status: "failed",
+						reason: "readback"
+					};
+				}
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				void cause;
+				await restoreConfig(transactionPath, original);
+				return {
+					status: "failed",
+					reason: "readback"
+				};
+			}
+			return {
+				status: "configured",
+				...backupPath === undefined ? {} : { backupPath }
+			};
+		};
+		clientConfigurationAligned = async (client, providerEnvironment, command) => {
+			if (client.configPathError !== undefined) return false;
+			try {
+				const files = await readClientConfigurationFiles(client);
+				if (!files.ok) {
+					throwCleanupFailure(files.error);
+					return false;
+				}
+				const original = await readRegularFileText(client.configPath);
+				const parsed = parseClientConfiguration(original, client.format);
+				const policy = await readClientPolicyBlock(client, parsed, clientConfigurationDesired(client, providerEnvironment, command, parsed));
+				if (!policy.ok) {
+					throwCleanupFailure(policy.error);
+					return false;
+				}
+				return policy.value === undefined && registrationCurrent(parsed, clientConfigurationDesired(client, providerEnvironment, command, parsed));
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				void cause;
+				return false;
+			}
+		};
+		inspectClientConfiguration = async (client, providerEnvironment, command) => {
+			if (client.configPathError !== undefined) return {
+				status: "invalid",
+				remediation: client.configPathError
+			};
+			if (client.format === "unsupported") return { status: "already_current" };
+			const files = await readClientConfigurationFiles(client);
+			if (!files.ok) {
+				throwCleanupFailure(files.error);
+				return {
+					status: "invalid",
+					remediation: files.error.detail
+				};
+			}
+			const existing = files.value.at(-1);
+			const editabilityError = existing?.dialect === "dsh" ? dshDocument(existing.document).editabilityError : undefined;
+			if (editabilityError !== undefined) return {
+				status: "invalid",
+				remediation: editabilityError.message
+			};
+			const policy = await readClientPolicyBlock(client, undefined, clientConfigurationDesired(client, providerEnvironment, command, existing));
+			if (!policy.ok) {
+				throwCleanupFailure(policy.error);
+				return {
+					status: "invalid",
+					remediation: policy.error.detail
+				};
+			}
+			if (policy.value !== undefined) return {
+				status: "invalid",
+				remediation: policy.value
+			};
+			const transactionPath = await resolveClientConfigTransactionPath(client.configPath);
+			if (transactionPath === undefined) return {
+				status: "invalid",
+				remediation: "The configuration path is unsafe or unresolved. Check ownership and symbolic links before rerunning setup."
+			};
+			let original;
+			try {
+				original = await readRegularFileText(transactionPath);
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				if (isMissing(cause)) return { status: "create" };
+				return {
+					status: "invalid",
+					remediation: `The configuration file could not be read. Check its permissions before rerunning setup. ${cause instanceof Error ? cause.message : String(cause)}`
+				};
+			}
+			try {
+				const parsed = parseClientConfiguration(original, client.format);
+				const policy = await readClientPolicyBlock(client, parsed, clientConfigurationDesired(client, providerEnvironment, command, parsed));
+				if (!policy.ok) {
+					throwCleanupFailure(policy.error);
+					return {
+						status: "invalid",
+						remediation: policy.error.detail
+					};
+				}
+				if (policy.value !== undefined) return {
+					status: "invalid",
+					remediation: policy.value
+				};
+				const desired = clientConfigurationDesired(client, providerEnvironment, command, parsed);
+				if (registrationCurrent(parsed, desired)) return { status: "already_current" };
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw cause;
+				void cause;
+				return {
+					status: "invalid",
+					remediation: "The existing configuration is malformed. Repair it before setup applies any other changes."
+				};
+			}
+			return {
+				status: "update",
+				backupPath: `${client.configPath}.rea.backup`
+			};
+		};
+		isMissing = (cause) => cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+		throwCleanupFailure = (error) => {
+			if (error.cleanupFailure !== undefined) throw error.cleanupFailure;
+		};
+		preserveConfigBackup = async (source, destination) => {
+			try {
+				await copyFile(source, destination, constants.COPYFILE_EXCL);
+				return true;
+			} catch (cause) {
+				return cause instanceof Error && "code" in cause && cause.code === "EEXIST";
+			}
+		};
+		restoreConfig = async (path, original) => {
+			try {
+				if (original === undefined) await rm(path, { force: true });
+				else await writeFile(path, original, {
+					encoding: "utf8",
+					mode: 384
+				});
+			} catch (cause) {
+				void cause;
+			}
+		};
+		registrationCurrent = (parsed, desired) => (parsed.dialect !== "dsh" || dshDocument(parsed.document).ready) && clientConfigurationValuesEqual(parsed.servers[PRODUCT_IDENTITY.mcpServerKey], desired) && !Object.hasOwn(parsed.legacyServers, PRODUCT_IDENTITY.mcpServerKey) && !clientServerListedDisabled(parsed, PRODUCT_IDENTITY.mcpServerKey);
+		clientConfigurationDesired = (client, providerEnvironment, command, parsed) => {
+			const format = parsed?.dialect ?? client.format ?? "json";
+			const launcher = command.length === 0 ? [PRODUCT_IDENTITY.cliBinary, "mcp"] : command;
+			if (format === "dsh") {
+				const desired = (parsed === undefined ? new DshCordisDocument("") : dshDocument(parsed.document)).desired(launcher, providerEnvironment);
+				if (!desired.ok) throw desired.error;
+				return desired.value;
+			}
+			const environment = clientRegistrationEnvironment(parsed, providerEnvironment);
+			if (!environment.ok) throw environment.error;
+			const registration = clientRegistrationEntry(format, launcher, environment.value);
+			return {
+				...registration,
+				...client.name === "codex" || client.name === "grok_build" ? { startup_timeout_sec: MCP_STARTUP_POLICY.codexStartupTimeoutSeconds } : {}
+			};
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/SetupInstallFailure.js
+var setupInstallFailure;
+function init_SetupInstallFailure() {
+	return (init_SetupInstallFailure = __esmMin((() => {
+		setupInstallFailure = (reason) => {
+			switch (reason) {
+				case "unsupported_host": return {
+					status: "failed",
+					code: "unsupported_host",
+					remediation: "Use a supported host, then rerun reverseport setup."
+				};
+				case "integrity": return {
+					status: "failed",
+					code: "integrity_mismatch",
+					remediation: "The Hopper download failed integrity verification. Retry setup; if it repeats, update REA before installing."
+				};
+				case "authorization_or_package_manager": return {
+					status: "failed",
+					code: "authorization_or_package_manager_failed",
+					remediation: "Allow the system package-manager operation or install the planned Hopper package and Linux runtime dependencies, then rerun reverseport setup."
+				};
+				case "launcher_missing": return {
+					status: "failed",
+					code: "launcher_missing",
+					remediation: "The package operation completed but Hopper is not runnable. Run reverseport doctor and repair the reported launcher issue."
+				};
+				case "runtime_dependencies": return {
+					status: "failed",
+					code: "runtime_dependency_unavailable",
+					remediation: "Hopper was installed but required shared libraries are missing. Rerun reverseport setup, then apply the hopper-demo-runtime remediation from reverseport doctor."
+				};
+				case "unsupported_hopper_build": return {
+					status: "failed",
+					code: "unsupported_hopper_build",
+					remediation: "The installed Hopper launcher does not match the build supported by this REA release. Unset HOPPER_LAUNCHER_PATH, reinstall through reverseport setup, or update REA."
+				};
+				case "cancelled": return {
+					status: "failed",
+					code: "setup_cancelled",
+					remediation: "Setup was cancelled before Hopper was installed. Rerun reverseport setup when ready."
+				};
+				case "destination_exists": return {
+					status: "failed",
+					code: "destination_exists",
+					remediation: "The Hopper installation destination already exists and was not replaced. Reuse the existing installation or move it aside, then rerun reverseport setup."
+				};
+				case "mount": return {
+					status: "failed",
+					code: "mount_failed",
+					remediation: "The verified Hopper disk image could not be mounted. Eject any stale Hopper image, check local disk access, then rerun reverseport setup."
+				};
+				case "bundle": return {
+					status: "failed",
+					code: "bundle_invalid",
+					remediation: "The mounted package did not contain the expected Hopper application bundle. Retry setup; if it repeats, update REA before installing."
+				};
+				case "copy": return {
+					status: "failed",
+					code: "copy_failed",
+					remediation: "The verified Hopper application could not be copied to the installation destination. Check destination permissions and free space, then rerun reverseport setup."
+				};
+				default: return {
+					status: "failed",
+					code: "download_failed",
+					remediation: "REA could not download or unpack the official Hopper package. Check network and filesystem access, then retry setup."
+				};
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/SetupRegistrationEnvironment.js
+var providerRegistrationEnvironment;
+function init_SetupRegistrationEnvironment() {
+	return (init_SetupRegistrationEnvironment = __esmMin((() => {
+		init_unicodeCodePointOrder();
+		providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections.flatMap(({ registrationEnvironment }) => Object.entries(registrationEnvironment)).sort(([left], [right]) => compareUnicodeCodePoints(left, right)));
+	})))();
+}
+
+//#endregion
+//#region dist/application/SetupHost.js
+var SetupHost_exports = /* @__PURE__ */ __exportAll({
+	detectClients: () => detectClients,
+	filterClientsNeedingConfigure: () => filterClientsNeedingConfigure,
+	hostRemediation: () => hostRemediation,
+	setupRegistrationCommand: () => setupRegistrationCommand,
+	systemSetupHost: () => systemSetupHost
+});
+var setupRegistrationCommand, filterClientsNeedingConfigure, hostRemediation, systemSetupHost, clientConfigurationOperations, closeSetupResources, runClientConfigurationOperation, configurationCleanupError, errorMessage, detectClients, major, clientEvidencePresent, exists;
+function init_SetupHost() {
+	return (init_SetupHost = __esmMin((() => {
+		init_ArtifactResourceScope();
+		init_ArtifactReader();
+		init_configurationErrors();
+		init_identity();
+		init_ClientRegistrationIdentity();
+		init_runtimeVersion();
+		init_Doctor();
+		init_LinuxHopper();
+		init_MacHopper();
+		init_SupportedClients();
+		init_SetupSkill();
+		init_SetupClientConfiguration();
+		init_SetupInstallFailure();
+		init_RegularFileRead();
+		init_SetupRegistrationEnvironment();
+		setupRegistrationCommand = (platform, packageRunner) => packageRunner !== undefined ? packageRunnerRegistrationCommand(packageRunner, platform) : platform === "win32" ? [
+			process.execPath,
+			resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary),
+			"mcp"
+		] : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
+		filterClientsNeedingConfigure = async (host, detectedClients, providerEnvironment, command) => {
+			const needs = await Promise.all(detectedClients.map((client) => host.clientNeedsConfigure(client, providerEnvironment, command)));
+			return detectedClients.filter((_, index) => needs[index]);
+		};
+		hostRemediation = async (host, installHopper) => {
+			if (!supportsNodeVersion(host.nodeVersion)) return `Install ${SUPPORTED_NODE_VERSION_PROSE} and rerun setup.`;
+			if (!installHopper) return undefined;
+			if (host.platform !== "darwin" && host.platform !== "linux") return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
+			if (host.platform === "darwin") {
+				const version = await host.macosVersion();
+				return version === undefined || major(version) < 12 ? "Upgrade to macOS 12 or newer." : undefined;
+			}
+			if ((await host.linuxDistribution())?.supported === true) return undefined;
+			return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, Nobara 44+, 64-bit Arch Linux, CachyOS, and Omarchy; configure an existing supported provider instead.";
+		};
+		systemSetupHost = (selectedDoctorHost = undefined, environment = process.env) => {
+			const doctorHost = selectedDoctorHost ?? systemDoctorHost({ environment });
+			const platform = doctorHost.platform;
+			const { homeDirectory } = doctorHost;
+			const macHopperHost = platform === "darwin" ? systemMacHopperInstallHost(homeDirectory, environment) : undefined;
+			const resources = new ArtifactResourceScope();
+			return {
+				platform,
+				homeDirectory,
+				skillDestinations: (clientIds) => skillDestinations(homeDirectory, clientIds, environment, platform),
+				registrationCommand: setupRegistrationCommand(platform, invokingPackageRunner(environment, platform)),
+				nodeVersion: process.versions.node,
+				macosVersion: () => doctorHost.macosVersion(),
+				linuxDistribution: readLinuxDistribution,
+				close: () => closeSetupResources(resources, macHopperHost, doctorHost),
+				initialSetupState: async (scope) => {
+					const diagnosis = await runDoctor(undefined, doctorHost, scope);
+					return {
+						...diagnosis.hopperPath === undefined ? {} : { hopperPath: diagnosis.hopperPath },
+						providerEnvironment: {
+							...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
+							...diagnosis.hopperPath === undefined ? {} : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }
+						},
+						doctor: diagnosis
+					};
+				},
+				installHopper: async (replaceExisting) => {
+					if (platform === "linux") {
+						const result = await installLinuxHopper(systemLinuxHopperInstallHost(environment));
+						return result.status === "installed" ? result : setupInstallFailure(result.reason);
+					}
+					if (macHopperHost === undefined) return setupInstallFailure("unsupported_host");
+					const result = await installMacHopper({ replaceExisting }, macHopperHost);
+					if (result.status === "installed") return {
+						status: "installed",
+						launcherPath: result.launcherPath,
+						...result.cleanupFailure === undefined ? {} : { cleanupFailure: result.cleanupFailure }
+					};
+					const failure = setupInstallFailure(result.reason);
+					if (result.cleanupFailure === undefined) return failure;
+					return failure.status === "failed" ? {
+						...failure,
+						remediation: `${failure.remediation} ${result.cleanupFailure}`
+					} : failure;
+				},
+				detectedClients: () => detectClients(homeDirectory, platform, environment),
+				supportedClients: () => Promise.resolve(supportedClients(homeDirectory, platform, environment)),
+				...clientConfigurationOperations(resources),
+				skillNeedsInstall: (clientIds) => canonicalSkillNeedsInstall(homeDirectory, clientIds, environment, platform, resources),
+				installSkill: (clientIds) => installCanonicalSkill(homeDirectory, clientIds, environment, platform, undefined, resources),
+				doctor: (scope) => runDoctor(undefined, doctorHost, scope)
+			};
+		};
+		clientConfigurationOperations = (resources) => ({
+			configureClient: (client, providerEnvironment, command) => runClientConfigurationOperation(resources, async () => client.format === "unsupported" ? { status: "skipped" } : configureClientConfiguration(client, providerEnvironment, command)),
+			clientNeedsConfigure: (client, providerEnvironment, command) => runClientConfigurationOperation(resources, async () => client.format === "unsupported" ? false : !await clientConfigurationAligned(client, providerEnvironment, command)),
+			inspectClientConfiguration: (client, providerEnvironment, command) => runClientConfigurationOperation(resources, () => inspectClientConfiguration(client, providerEnvironment, command))
+		});
+		closeSetupResources = async (resources, macHopperHost, doctorHost) => {
+			const [resourceCleanup, hopperCleanup, doctorCleanup] = await Promise.allSettled([
+				resources.close(),
+				Promise.resolve().then(() => macHopperHost?.close()),
+				Promise.resolve().then(() => doctorHost.close?.())
+			]);
+			const failures = [];
+			if (hopperCleanup.status === "rejected") failures.push(`Hopper host cleanup failed: ${errorMessage(hopperCleanup.reason)}`);
+			else if (hopperCleanup.value !== undefined) failures.push(hopperCleanup.value);
+			if (doctorCleanup.status === "rejected") failures.push(`Doctor host cleanup failed: ${errorMessage(doctorCleanup.reason)}`);
+			else if (doctorCleanup.value !== undefined) failures.push(doctorCleanup.value);
+			if (resourceCleanup.status === "rejected") failures.push(errorMessage(resourceCleanup.reason));
+			return failures.length === 0 ? undefined : failures.join("; ");
+		};
+		runClientConfigurationOperation = async (resources, operation) => {
+			try {
+				return await resources.run(async () => {
+					try {
+						return await operation();
+					} catch (cause) {
+						if (!(cause instanceof RegularFileCleanupFailure)) throw cause;
+						const cleanup = await retryRegularFileCleanup(cause, resources);
+						const primary = cleanup.outcome.kind === "failed" ? cleanup.outcome.cause : cause.cleanupCause;
+						throw configurationCleanupError(`Could not safely access client configuration at ${cause.path}: ${errorMessage(primary)}`, cause, cleanup.cleanup);
+					}
+				});
+			} catch (cause) {
+				if (cause instanceof ArtifactReaderFailure) throw configurationCleanupError(cause.message, cause, cause.cleanup);
+				throw cause;
+			}
+		};
+		configurationCleanupError = (message, cause, cleanup) => new ConfigurationError(message, {
+			cause,
+			settings: [{
+				setting: "client configuration",
+				constraint: message
+			}],
+			...cleanup === undefined ? {} : { cleanup }
+		});
+		errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		detectClients = async (home, platform = process.platform, environment = process.env) => {
+			const detected = [];
+			for (const candidate of supportedClients(home, platform, environment)) {
+				if (candidate.configPathError !== undefined) continue;
+				if (await clientEvidencePresent(candidate)) detected.push(candidate);
+			}
+			return detected;
+		};
+		major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
+		clientEvidencePresent = async (client) => {
+			for (const path of clientEvidencePaths(client)) if (await exists(path)) return true;
+			return false;
+		};
+		exists = async (path) => {
+			try {
+				await access(path);
+				return true;
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { SetupHost_exports, filterClientsNeedingConfigure, hostRemediation, init_MacHopper, init_SetupHost, macHopperInstallDisclosure, systemSetupHost };