reverseport 0.0.0-stage → 1.2.0

package/dist/cli-runtime/SupportedClients-BrZ2qZVg.js

@@ -0,0 +1,671 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, analysisProviderSelectorSchema, compareUnicodeCodePoints, err, init_identity, init_providerSelection, init_result, init_unicodeCodePointOrder, ok } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { ConfigurationError, init_configurationErrors } from "./configurationErrors-ByuF6gMR.js";
+import { DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS, DEFAULT_HOPPER_STARTUP_TIMEOUT_MS, init_providerStartupTimeout, providerStartupTimeoutSchema } from "./providerStartupTimeout-Be8B1Ro8.js";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
+import { z } from "zod";
+import { lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { userInfo } from "node:os";
+import { valid } from "semver";
+
+//#region dist/config/ghidraLanguageOverride.js
+var ghidraLanguageIdSchema, ghidraCompilerSpecIdSchema;
+function init_ghidraLanguageOverride() {
+	return (init_ghidraLanguageOverride = __esmMin((() => {
+		ghidraLanguageIdSchema = z.string().regex(/^[A-Za-z0-9_.+-]+:(?:LE|BE):[1-9]\d*:[A-Za-z0-9_.+-](?:[A-Za-z0-9_.+ -]*[A-Za-z0-9_.+-])?$/u, "must be a Ghidra language ID such as x86:LE:32:default");
+		ghidraCompilerSpecIdSchema = z.string().regex(/^[A-Za-z0-9_.+-]+$/u, "must be a Ghidra compiler-spec ID such as default or borlandcpp");
+	})))();
+}
+
+//#endregion
+//#region dist/config/ghidraDisabledAnalyzers.js
+var MAX_GHIDRA_DISABLED_ANALYZER_NAMES, MAX_GHIDRA_DISABLED_ANALYZER_NAME_LENGTH, ghidraAnalyzerNamePattern, ghidraDisabledAnalyzersSchema;
+function init_ghidraDisabledAnalyzers() {
+	return (init_ghidraDisabledAnalyzers = __esmMin((() => {
+		MAX_GHIDRA_DISABLED_ANALYZER_NAMES = 32;
+		MAX_GHIDRA_DISABLED_ANALYZER_NAME_LENGTH = 120;
+		ghidraAnalyzerNamePattern = /^[A-Za-z0-9][A-Za-z0-9 ._-]*$/u;
+		ghidraDisabledAnalyzersSchema = z.string().transform((value) => value.split(",").map((name) => name.trim()).filter((name) => name.length > 0)).refine((names) => names.length <= 32, `must list at most ${32} analyzer names`).refine((names) => names.every((name) => name.length <= 120), `must keep every analyzer name at most ${120} characters`).refine((names) => names.every((name) => ghidraAnalyzerNamePattern.test(name)), "must be Ghidra analyzer names starting with a letter or digit and containing only letters, digits, spaces, periods, underscores, and hyphens").transform((names) => names.length === 0 ? undefined : names);
+	})))();
+}
+
+//#endregion
+//#region dist/config/mcpInputSchemaProfile.js
+var COMPACT_INPUT_SCHEMA_BUDGET_BYTES, mcpInputSchemaProfileSchema, profileConstraint, parseMcpInputSchemaProfile;
+function init_mcpInputSchemaProfile() {
+	return (init_mcpInputSchemaProfile = __esmMin((() => {
+		init_configurationErrors();
+		init_result();
+		COMPACT_INPUT_SCHEMA_BUDGET_BYTES = 13 * 1024;
+		mcpInputSchemaProfileSchema = z.enum(["full", "compact"]);
+		profileConstraint = "REA_MCP_INPUT_SCHEMA_PROFILE must be \"full\" (default) or \"compact\". The compact profile advertises input schemas without nested annotation prose for providers that cap each tool schema's serialized size.";
+		parseMcpInputSchemaProfile = (value) => {
+			if (value === undefined) return ok(undefined);
+			const parsed = mcpInputSchemaProfileSchema.safeParse(value);
+			return parsed.success ? ok(parsed.data) : err(new ConfigurationError(profileConstraint, { settings: [{
+				setting: "REA_MCP_INPUT_SCHEMA_PROFILE",
+				constraint: profileConstraint
+			}] }));
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/config/mcpResponseBudget.js
+var MINIMUM_RESPONSE_BYTES, mcpResponseBudgetSchema, budgetConstraint, parseMcpResponseBudget;
+function init_mcpResponseBudget() {
+	return (init_mcpResponseBudget = __esmMin((() => {
+		init_configurationErrors();
+		init_result();
+		MINIMUM_RESPONSE_BYTES = 10 * 1024 * 1024;
+		mcpResponseBudgetSchema = z.string().regex(/^[1-9]\d*$/u).transform(Number).pipe(z.number().int().safe().min(MINIMUM_RESPONSE_BYTES));
+		budgetConstraint = `REA_MCP_MAX_RESPONSE_BYTES must be a decimal safe integer at least ${String(MINIMUM_RESPONSE_BYTES)} bytes, the default stdio receive-buffer size.`;
+		parseMcpResponseBudget = (value) => {
+			if (value === undefined) return ok(undefined);
+			const parsed = mcpResponseBudgetSchema.safeParse(value);
+			return parsed.success ? ok(parsed.data) : err(new ConfigurationError(budgetConstraint, { settings: [{
+				setting: "REA_MCP_MAX_RESPONSE_BYTES",
+				constraint: budgetConstraint
+			}] }));
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/config/environment.js
+var environmentSchema, parseEnvironment;
+function init_environment() {
+	return (init_environment = __esmMin((() => {
+		init_configurationErrors();
+		init_result();
+		init_providerSelection();
+		init_ghidraLanguageOverride();
+		init_ghidraDisabledAnalyzers();
+		init_providerStartupTimeout();
+		init_mcpInputSchemaProfile();
+		init_mcpResponseBudget();
+		environmentSchema = z.object({
+			REA_ANALYSIS_PROVIDER: analysisProviderSelectorSchema.default("auto"),
+			REA_MCP_MAX_RESPONSE_BYTES: mcpResponseBudgetSchema.optional(),
+			REA_MCP_INPUT_SCHEMA_PROFILE: mcpInputSchemaProfileSchema.optional(),
+			REA_IDA_MCP_CONFIG: z.string().min(1).refine(isAbsolute, "REA_IDA_MCP_CONFIG must be absolute").optional(),
+			GHIDRA_INSTALL_DIR: z.string().min(1).refine(isAbsolute, "GHIDRA_INSTALL_DIR must be absolute").optional(),
+			JAVA_HOME: z.string().min(1).refine(isAbsolute, "JAVA_HOME must be absolute").optional(),
+			REA_GHIDRA_NATIVEAOT_JAR: z.string().min(1).refine(isAbsolute, "REA_GHIDRA_NATIVEAOT_JAR must be absolute").optional(),
+			REA_GHIDRA_STARTUP_TIMEOUT_MS: providerStartupTimeoutSchema.default(DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS),
+			REA_HOPPER_STARTUP_TIMEOUT_MS: providerStartupTimeoutSchema.default(DEFAULT_HOPPER_STARTUP_TIMEOUT_MS),
+			REA_GHIDRA_LANGUAGE_ID: ghidraLanguageIdSchema.optional(),
+			REA_GHIDRA_COMPILER_SPEC_ID: ghidraCompilerSpecIdSchema.optional(),
+			REA_GHIDRA_DISABLED_ANALYZERS: ghidraDisabledAnalyzersSchema.optional(),
+			REA_GHIDRA_SEED_FILE: z.string().min(1).refine(isAbsolute, "REA_GHIDRA_SEED_FILE must be absolute").optional(),
+			REA_ILSPY_CMD_PATH: z.string().min(1).refine(isAbsolute, "REA_ILSPY_CMD_PATH must be absolute").optional(),
+			HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
+			HOPPER_TARGET_PATH: z.string().min(1).optional(),
+			HOPPER_TARGET_KIND: z.enum(["executable", "database"]).default("executable"),
+			HOPPER_LOADER_ARGS_JSON: z.string().optional(),
+			REA_LOG_LEVEL: z.enum([
+				"trace",
+				"debug",
+				"info",
+				"warn",
+				"error",
+				"fatal",
+				"silent"
+			]).default("info"),
+			REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]")
+		});
+		parseEnvironment = (environment) => {
+			const parsed = environmentSchema.safeParse(environment);
+			if (!parsed.success) {
+				const settings = parsed.error.issues.map((issue) => ({
+					setting: String(issue.path[0] ?? "environment"),
+					constraint: issue.message
+				}));
+				return err(new ConfigurationError("Invalid REA environment configuration", {
+					cause: parsed.error,
+					settings
+				}));
+			}
+			return ok(parsed.data);
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/config/homeDirectory.js
+var homeDirectoryFromEnvironment;
+function init_homeDirectory() {
+	return (init_homeDirectory = __esmMin((() => {
+		homeDirectoryFromEnvironment = (environment, platform) => {
+			const selected = platform === "win32" ? environment.USERPROFILE ?? (environment.HOMEDRIVE !== undefined && environment.HOMEPATH !== undefined ? `${environment.HOMEDRIVE}${environment.HOMEPATH}` : environment.HOME) : environment.HOME ?? environment.USERPROFILE;
+			return selected ?? userInfo().homedir;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/ClientRegistrationIdentity.js
+var environmentValue, invokingPackageRunner, withoutPackageRunnerIdentity, packageRunnerRegistrationCommand, npxRegistrationCommand, unwrapCmdCommand, packageRunnerReference, isOwnedPackageReference, isOwnedClientRegistrationCommand;
+function init_ClientRegistrationIdentity() {
+	return (init_ClientRegistrationIdentity = __esmMin((() => {
+		init_identity();
+		environmentValue = (environment, name, platform) => {
+			if (platform !== "win32") return environment[name];
+			const key = Object.keys(environment).find((candidate) => candidate.toLowerCase() === name);
+			return key === undefined ? undefined : environment[key];
+		};
+		invokingPackageRunner = (environment, platform = process.platform) => {
+			if (environmentValue(environment, "npm_command", platform) !== "exec") return undefined;
+			return environmentValue(environment, "npm_config_user_agent", platform)?.startsWith("bun/") === true ? "bunx" : "npx";
+		};
+		withoutPackageRunnerIdentity = (environment, platform = process.platform) => Object.fromEntries(Object.entries(environment).filter(([key]) => platform === "win32" ? key.toLowerCase() !== "npm_command" : key !== "npm_command"));
+		packageRunnerRegistrationCommand = (runner, platform = process.platform) => {
+			const command = runner === "npx" ? [
+				"npx",
+				"-y",
+				PRODUCT_IDENTITY.registrationPackageSpecifier,
+				"mcp"
+			] : [
+				"bunx",
+				PRODUCT_IDENTITY.registrationPackageSpecifier,
+				"mcp"
+			];
+			return platform === "win32" ? [
+				"cmd.exe",
+				"/d",
+				"/c",
+				...command
+			] : command;
+		};
+		npxRegistrationCommand = (platform = process.platform) => packageRunnerRegistrationCommand("npx", platform);
+		unwrapCmdCommand = (command) => {
+			const executable = command[0]?.toLowerCase();
+			if (executable !== "cmd" && executable !== "cmd.exe") return command;
+			if (command[1]?.toLowerCase() === "/c") return command.slice(2);
+			if (command[1]?.toLowerCase() === "/d" && command[2]?.toLowerCase() === "/c") return command.slice(3);
+			return [];
+		};
+		packageRunnerReference = (command) => {
+			if (command.length === 4 && command[0] === "npx" && command[1] === "-y" && command[3] === "mcp") return command[2];
+			if (command.length === 3 && command[0] === "bunx" && command[2] === "mcp") return command[1];
+			return undefined;
+		};
+		isOwnedPackageReference = (packageReference) => {
+			if (packageReference === PRODUCT_IDENTITY.packageName || packageReference === PRODUCT_IDENTITY.packageSpecifier || packageReference === PRODUCT_IDENTITY.registrationPackageSpecifier) return true;
+			const versionPrefix = `${PRODUCT_IDENTITY.packageName}@`;
+			return packageReference.startsWith(versionPrefix) && valid(packageReference.slice(versionPrefix.length)) !== null;
+		};
+		isOwnedClientRegistrationCommand = (command, currentCommandPath = resolve(process.argv[1] ?? "unknown")) => {
+			if (command.length === 3 && command[2] === "mcp" && resolve(command[0] ?? "") === resolve(process.execPath) && resolve(command[1] ?? "") === currentCommandPath) return true;
+			if (command.length === 2 && command[1] === "mcp") {
+				const executable = command[0] ?? "";
+				if (executable === PRODUCT_IDENTITY.cliBinary || isAbsolute(executable) && basename(executable) === PRODUCT_IDENTITY.cliBinary || resolve(executable) === currentCommandPath) return true;
+			}
+			const packageReference = packageRunnerReference(unwrapCmdCommand(command));
+			return packageReference !== undefined && isOwnedPackageReference(packageReference);
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/HermesClientHome.js
+var HermesClientPathError, defaultDirectory, expandedDirectory, physicalPath, within, PROFILE_MARKERS, RESERVED_PROFILES, liveProfile, resolveHermesClientHome;
+function init_HermesClientHome() {
+	return (init_HermesClientHome = __esmMin((() => {
+		HermesClientPathError = class extends Error {
+			path;
+			constructor(path, message) {
+				super(message);
+				this.path = path;
+				this.name = "HermesClientPathError";
+			}
+		};
+		defaultDirectory = (home, platform, env) => {
+			const suffix = env.HERMES_DATA_DIR_SUFFIX ?? "";
+			return platform === "win32" ? join(env.LOCALAPPDATA?.trim() || join(home, "AppData", "Local"), `hermes${suffix}`) : join(home, `.hermes${suffix}`);
+		};
+		expandedDirectory = (home, platform, env) => {
+			const override = env.HERMES_HOME?.trim();
+			if (!override) return undefined;
+			const variables = override.replace(/\$(\w+|\{[^}]*\})/gu, (match, variable) => {
+				const key = variable.startsWith("{") ? variable.slice(1, -1) : variable;
+				return env[key] ?? match;
+			});
+			const expanded = platform === "win32" ? variables.replace(/%([^%]+)%/gu, (match, variable) => env[variable] ?? match) : variables;
+			if (expanded === "~") return home;
+			if (expanded.startsWith("~/") || platform === "win32" && expanded.startsWith("~\\")) return join(home, expanded.slice(2));
+			return resolve(expanded);
+		};
+		physicalPath = (path) => {
+			try {
+				return realpathSync(path);
+			} catch {
+				return resolve(path);
+			}
+		};
+		within = (root, path) => {
+			const difference = relative(physicalPath(root), physicalPath(path));
+			return difference === "" || !isAbsolute(difference) && difference !== ".." && !difference.startsWith(`..${sep}`);
+		};
+		PROFILE_MARKERS = [
+			"config.yaml",
+			".env",
+			"SOUL.md",
+			"profile.yaml",
+			"auth.json",
+			"state.db"
+		];
+		RESERVED_PROFILES = new Set([
+			"hermes",
+			"test",
+			"tmp",
+			"root",
+			"sudo"
+		]);
+		liveProfile = (path) => {
+			try {
+				if (!statSync(path).isDirectory()) return false;
+				try {
+					statSync(join(dirname(path), ".deleted", basename(path)));
+					return false;
+				} catch {}
+				return PROFILE_MARKERS.some((marker) => {
+					try {
+						const status = lstatSync(join(path, marker));
+						return status.isFile() || status.isSymbolicLink();
+					} catch {
+						return false;
+					}
+				});
+			} catch {
+				return false;
+			}
+		};
+		resolveHermesClientHome = (home, platform, env) => {
+			const native = defaultDirectory(home, platform, env);
+			const root = expandedDirectory(home, platform, env) ?? native;
+			if (basename(dirname(root)) === "profiles") return root;
+			const stickyRoot = within(native, root) ? native : root;
+			let name;
+			try {
+				name = new TextDecoder("utf-8", { fatal: true }).decode(readFileSync(join(stickyRoot, "active_profile"))).trim();
+			} catch {
+				return root;
+			}
+			if (name === "" || name === "default") return root;
+			const canonical = name.toLowerCase();
+			if (canonical === "default") return root;
+			if (!/^[a-z0-9][a-z0-9_-]{0,63}$/u.test(canonical) || RESERVED_PROFILES.has(canonical)) throw new HermesClientPathError(join(stickyRoot, "active_profile"), `Invalid saved Hermes profile ${JSON.stringify(name)}. Run 'hermes profile use default' or repair active_profile.`);
+			const selected = join(root, "profiles", canonical);
+			if (!liveProfile(selected)) throw new HermesClientPathError(selected, `Saved Hermes profile ${JSON.stringify(name)} is missing, deleted, or has no profile identity. Run 'hermes profile use default' or restore that profile before configuring it.`);
+			return selected;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/SupportedClients.js
+var vscodeUserDirectory, claudeDesktopDirectory, claudeCodeConfigDirectory, claudeCodeMarkerDirectory, codexDirectory, qwenCodeDirectory, grokDirectory, dshHomeDirectory, dshPatchDirectory, hermesDirectory, grokBotDirectory, GROK_BOT_MANUAL_REGISTRATION_REMEDIATION, manualRegistrationRemediation, OMP_PROFILE_NAME, OMP_RESERVED_PROFILE, ompAgentDirectory, piAgentDirectory, copilotDirectory, commandCodeDirectory, openCodeOverrideDirectory, opencodeDirectory, openCodeConfigurationPaths, existingOpenCodeConfigPath, geminiSettings, devinDirectory, SUPPORTED_CLIENT_DEFINITIONS, clientEvidencePaths, resolvePath, supportedClients, clientSkillDirectories;
+function init_SupportedClients() {
+	return (init_SupportedClients = __esmMin((() => {
+		init_result();
+		init_HermesClientHome();
+		init_unicodeCodePointOrder();
+		vscodeUserDirectory = ({ home, platform, env }) => {
+			if (platform === "win32") return join(env.APPDATA ?? join(home, "AppData", "Roaming"), "Code", "User");
+			if (platform === "darwin") return join(home, "Library", "Application Support", "Code", "User");
+			return join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "Code", "User");
+		};
+		claudeDesktopDirectory = ({ home, platform, env }) => {
+			if (platform === "win32") return join(env.APPDATA ?? join(home, "AppData", "Roaming"), "Claude");
+			if (platform === "linux") return join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "Claude");
+			return join(home, "Library", "Application Support", "Claude");
+		};
+		claudeCodeConfigDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? home;
+		claudeCodeMarkerDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
+		codexDirectory = ({ home, env }) => env.CODEX_HOME || join(home, ".codex");
+		qwenCodeDirectory = ({ home, env }) => {
+			const override = env.QWEN_HOME;
+			if (!override) return join(home, ".qwen");
+			const expanded = override === "~" ? home : override.startsWith("~/") || override.startsWith("~\\") ? join(home, ...override.slice(2).split(/[/\\]+/).filter(Boolean)) : override;
+			return isAbsolute(expanded) ? expanded : resolve(expanded);
+		};
+		grokDirectory = ({ home, env }) => env.GROK_HOME || join(home, ".grok");
+		dshHomeDirectory = ({ home, env }) => env.DSH_HOME ?? join(home, ".dsh");
+		dshPatchDirectory = (context) => join(dshHomeDirectory(context), "cordis.patch.yml");
+		hermesDirectory = ({ home, platform, env }) => resolveHermesClientHome(home, platform, env);
+		grokBotDirectory = ({ home, env }) => {
+			const root = env.SAND_DATA_ROOT;
+			return root !== undefined && root !== "" && isAbsolute(root) ? root : join(home, ".grokbot");
+		};
+		GROK_BOT_MANUAL_REGISTRATION_REMEDIATION = "Grok Bot keeps connectors in the signed-in account and runs them on its hosted computer. Setup does not write that account store, and a data-directory mcp.json is not a registration. In the Grok Bot chat, add a custom MCP server named rea that runs on the Bot's computer with `npx -y reverseport@<version> mcp`. Do not put credentials in the command or arguments. A stdio server on this machine is not attached.";
+		manualRegistrationRemediation = (clientName) => clientName === "grok_bot" ? GROK_BOT_MANUAL_REGISTRATION_REMEDIATION : undefined;
+		OMP_PROFILE_NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+		OMP_RESERVED_PROFILE = /^(?:CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\..*)?$/iu;
+		ompAgentDirectory = (context) => {
+			const root = join(context.home, context.env.PI_CONFIG_DIR || ".omp");
+			const profile = (context.env.OMP_PROFILE ?? context.env.PI_PROFILE)?.trim();
+			if (profile !== undefined && profile !== "" && profile !== "default") {
+				if (!OMP_PROFILE_NAME.test(profile) || profile.endsWith(".") || OMP_RESERVED_PROFILE.test(profile)) return err({
+					path: root,
+					message: `Invalid OMP profile ${JSON.stringify(profile)}: names must match ^[a-z0-9][a-z0-9._-]{0,63}$, cannot end with ".", and cannot be a Windows reserved device name (CON, PRN, AUX, NUL, COM0-9, LPT0-9, including extensions). Repair OMP_PROFILE or PI_PROFILE before configuring OMP.`
+				});
+				return ok(join(root, "profiles", profile, "agent"));
+			}
+			const override = context.env.PI_CODING_AGENT_DIR;
+			return ok(override ? resolve(override) : join(root, "agent"));
+		};
+		piAgentDirectory = ({ home, platform, env }) => {
+			const paths = platform === "win32" ? win32 : { join };
+			let directory = env.PI_CODING_AGENT_DIR;
+			if (!directory) return paths.join(home, ".pi", "agent");
+			if (platform === "win32" && directory.startsWith("/") && !directory.startsWith("//") && !directory.includes("\\")) {
+				const drive = /^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/iu.exec(directory);
+				if (drive !== null) directory = `${drive[1]?.toUpperCase()}:\\${drive[2]?.replaceAll("/", "\\") ?? ""}`;
+			}
+			if (directory === "~") return home;
+			if (directory.startsWith("~/") || platform === "win32" && directory.startsWith("~\\")) return paths.join(home, directory.slice(2));
+			if (directory.startsWith("file://")) return fileURLToPath(directory, { windows: platform === "win32" });
+			return directory;
+		};
+		copilotDirectory = ({ home, env }) => env.COPILOT_HOME ?? join(home, ".copilot");
+		commandCodeDirectory = ({ home }) => join(home, ".commandcode");
+		openCodeOverrideDirectory = (env) => {
+			const directory = env.OPENCODE_CONFIG_DIR;
+			return directory === undefined || directory === "" ? undefined : directory;
+		};
+		opencodeDirectory = (context) => openCodeOverrideDirectory(context.env) ?? join(context.env.XDG_CONFIG_HOME ?? join(context.home, ".config"), "opencode");
+		openCodeConfigurationPaths = (context) => {
+			const directory = join(context.env.XDG_CONFIG_HOME ?? join(context.home, ".config"), "opencode");
+			const overrideDirectory = openCodeOverrideDirectory(context.env);
+			const paths = [
+				join(directory, "config.json"),
+				join(directory, "opencode.json"),
+				join(directory, "opencode.jsonc"),
+				...context.env.OPENCODE_CONFIG ? [context.env.OPENCODE_CONFIG] : [],
+				...overrideDirectory !== undefined ? [join(overrideDirectory, "opencode.json"), join(overrideDirectory, "opencode.jsonc")] : []
+			];
+			const resolved = paths.map((path) => resolve(path));
+			return resolved.filter((path, index) => resolved.lastIndexOf(path) === index);
+		};
+		existingOpenCodeConfigPath = (context) => {
+			const overrideDirectory = openCodeOverrideDirectory(context.env);
+			const candidates = overrideDirectory !== undefined ? [join(overrideDirectory, "opencode.json"), join(overrideDirectory, "opencode.jsonc")].map((path) => resolve(path)) : context.env.OPENCODE_CONFIG ? [resolve(context.env.OPENCODE_CONFIG)] : [join(opencodeDirectory(context), "opencode.json"), join(opencodeDirectory(context), "opencode.jsonc")].map((path) => resolve(path));
+			return [...candidates].reverse().find((path) => {
+				try {
+					lstatSync(path);
+					return true;
+				} catch (cause) {
+					return !(cause instanceof Error && "code" in cause && cause.code === "ENOENT");
+				}
+			}) ?? resolve(overrideDirectory !== undefined ? join(overrideDirectory, "opencode.json") : context.env.OPENCODE_CONFIG || join(opencodeDirectory(context), "opencode.json"));
+		};
+		geminiSettings = ({ home, platform, env }) => {
+			const system = env.GEMINI_CLI_SYSTEM_SETTINGS_PATH || (platform === "darwin" ? "/Library/Application Support/GeminiCli/settings.json" : platform === "win32" ? "C:\\ProgramData\\gemini-cli\\settings.json" : "/etc/gemini-cli/settings.json");
+			const trustOverride = env.GEMINI_RESTRICTED_MODE === "true" || env.GEMINI_CLI_TRUST_WORKSPACE === "false" ? false : env.GEMINI_CLI_TRUST_WORKSPACE === "true" ? true : undefined;
+			return {
+				systemPath: system,
+				defaultsPath: env.GEMINI_CLI_SYSTEM_DEFAULTS_PATH || join(dirname(system), "system-defaults.json"),
+				workspaceDirectory: process.cwd(),
+				trustedFoldersPath: env.GEMINI_CLI_TRUSTED_FOLDERS_PATH || join(env.GEMINI_CLI_HOME || home, ".gemini", "trustedFolders.json"),
+				...trustOverride === undefined ? {} : { trustOverride },
+				platform
+			};
+		};
+		devinDirectory = ({ home, platform, env }) => platform === "win32" ? join(env.APPDATA ?? join(home, "AppData", "Roaming"), "devin") : join(env.XDG_CONFIG_HOME || join(home, ".config"), "devin");
+		SUPPORTED_CLIENT_DEFINITIONS = [
+			{
+				name: "claude_code",
+				displayName: "Claude Code",
+				skillPath: ({ home, env }) => join(env.CLAUDE_CONFIG_DIR ?? join(home, ".claude"), "skills"),
+				configPath: (context) => join(claudeCodeConfigDirectory(context), ".claude.json"),
+				markerPath: claudeCodeMarkerDirectory,
+				format: "json"
+			},
+			{
+				name: "claude_desktop",
+				displayName: "Claude Desktop",
+				configPath: (context) => join(claudeDesktopDirectory(context), "claude_desktop_config.json"),
+				markerPath: claudeDesktopDirectory,
+				format: "json"
+			},
+			{
+				name: "codex",
+				displayName: "Codex",
+				configPath: (context) => join(codexDirectory(context), "config.toml"),
+				markerPath: codexDirectory,
+				format: "toml"
+			},
+			{
+				name: "cursor",
+				displayName: "Cursor",
+				configPath: [".cursor", "mcp.json"],
+				markerPath: [".cursor"],
+				format: "json"
+			},
+			{
+				name: "gemini_cli",
+				displayName: "Gemini CLI",
+				geminiSettings,
+				configPath: ({ home, env }) => join(env.GEMINI_CLI_HOME || home, ".gemini", "settings.json"),
+				markerPath: ({ home, env }) => join(env.GEMINI_CLI_HOME || home, ".gemini"),
+				skillPath: ({ home, env }) => join(env.GEMINI_CLI_HOME || home, ".agents", "skills"),
+				format: "json"
+			},
+			{
+				name: "windsurf",
+				displayName: "Windsurf",
+				configPath: [
+					".codeium",
+					"windsurf",
+					"mcp_config.json"
+				],
+				markerPath: [".codeium", "windsurf"],
+				format: "json"
+			},
+			{
+				name: "devin",
+				displayName: "Devin",
+				configPath: ({ home, platform, env }) => join(devinDirectory({
+					home,
+					platform,
+					env
+				}), "mcp_config.json"),
+				markerPath: devinDirectory,
+				format: "json"
+			},
+			{
+				name: "opencode",
+				displayName: "OpenCode",
+				configPath: existingOpenCodeConfigPath,
+				configPaths: openCodeConfigurationPaths,
+				markerPath: opencodeDirectory,
+				format: "opencode"
+			},
+			{
+				name: "antigravity",
+				displayName: "Antigravity",
+				skillPath: [
+					".gemini",
+					"config",
+					"skills"
+				],
+				configPath: [
+					".gemini",
+					"config",
+					"mcp_config.json"
+				],
+				markerPath: [".gemini", "config"],
+				format: "json"
+			},
+			{
+				name: "copilot_cli",
+				displayName: "GitHub Copilot CLI",
+				configPath: (context) => join(copilotDirectory(context), "mcp-config.json"),
+				markerPath: copilotDirectory,
+				format: "copilot_cli"
+			},
+			{
+				name: "commandcode",
+				displayName: "Command Code",
+				configPath: (context) => join(commandCodeDirectory(context), "mcp.json"),
+				markerPath: commandCodeDirectory,
+				format: "commandcode"
+			},
+			{
+				name: "qwen_code",
+				displayName: "Qwen Code",
+				configPath: (context) => join(qwenCodeDirectory(context), "settings.json"),
+				markerPath: qwenCodeDirectory,
+				format: "json"
+			},
+			{
+				name: "vscode",
+				displayName: "VS Code",
+				configPath: (context) => join(vscodeUserDirectory(context), "mcp.json"),
+				markerPath: vscodeUserDirectory,
+				format: "vscode"
+			},
+			{
+				name: "grok_build",
+				displayName: "Grok Build",
+				configPath: (context) => join(grokDirectory(context), "config.toml"),
+				markerPath: grokDirectory,
+				format: "grok"
+			},
+			{
+				name: "omp",
+				displayName: "OMP",
+				configPath: (context) => {
+					const directory = ompAgentDirectory(context);
+					return directory.ok ? ok(join(directory.value, "mcp.json")) : directory;
+				},
+				markerPath: ompAgentDirectory,
+				format: "omp"
+			},
+			{
+				name: "pi",
+				displayName: "Pi",
+				configPath: (context) => (context.platform === "win32" ? win32 : { join }).join(piAgentDirectory(context), "mcp.json"),
+				markerPath: piAgentDirectory,
+				format: "pi"
+			},
+			{
+				name: "hermes",
+				displayName: "Hermes",
+				skillPath: (context) => join(hermesDirectory(context), "skills"),
+				configPath: (context) => join(hermesDirectory(context), "config.yaml"),
+				markerPath: hermesDirectory,
+				format: "hermes"
+			},
+			{
+				name: "dsh",
+				displayName: "DeepSeek Harness",
+				skillPath: ({ home, env }) => join(env.DSH_AGENTS_HOME ?? join(home, ".agents"), "skills"),
+				configPath: dshPatchDirectory,
+				markerPath: dshHomeDirectory,
+				format: "dsh"
+			},
+			{
+				name: "grok_bot",
+				displayName: "Grok Bot",
+				configPath: grokBotDirectory,
+				markerPath: grokBotDirectory,
+				format: "unsupported"
+			}
+		];
+		clientEvidencePaths = (client) => [...new Set([
+			client.configPath,
+			...client.configPaths ?? [],
+			client.markerPath
+		].filter((path) => path !== undefined && path.length > 0))];
+		resolvePath = (path, context) => {
+			const resolved = typeof path === "function" ? path(context) : join(context.home, ...path);
+			return typeof resolved === "string" ? ok(resolved) : resolved;
+		};
+		supportedClients = (home, platform = process.platform, env = process.env) => {
+			const context = {
+				home,
+				platform,
+				env
+			};
+			const definitions = SUPPORTED_CLIENT_DEFINITIONS;
+			return definitions.map((definition) => {
+				try {
+					const config = resolvePath(definition.configPath, context);
+					const marker = config.ok ? resolvePath(definition.markerPath, context) : config;
+					if (!config.ok) return {
+						name: definition.name,
+						displayName: definition.displayName,
+						format: definition.format,
+						configPath: config.error.path,
+						configPathError: config.error.message
+					};
+					if (!marker.ok) return {
+						name: definition.name,
+						displayName: definition.displayName,
+						format: definition.format,
+						configPath: marker.error.path,
+						configPathError: marker.error.message
+					};
+					const configPath = config.value;
+					return {
+						name: definition.name,
+						displayName: definition.displayName,
+						configPath,
+						...definition.geminiSettings === undefined ? {} : { geminiSettings: definition.geminiSettings(context) },
+						...definition.configPaths === undefined ? {} : { configPaths: [...new Set([...definition.configPaths(context), configPath])] },
+						markerPath: marker.value,
+						format: definition.format
+					};
+				} catch (cause) {
+					if (cause instanceof HermesClientPathError) return {
+						name: definition.name,
+						displayName: definition.displayName,
+						format: definition.format,
+						configPath: cause.path,
+						configPathError: cause.message
+					};
+					if (definition.name !== "pi") throw cause;
+					return {
+						name: definition.name,
+						displayName: definition.displayName,
+						format: definition.format,
+						configPath: env.PI_CODING_AGENT_DIR ?? "",
+						configPathError: `Invalid PI_CODING_AGENT_DIR: ${cause instanceof Error ? cause.message : String(cause)}. Repair the override before configuring Pi.`
+					};
+				}
+			});
+		};
+		clientSkillDirectories = (home, clientIds, environment = {}, platform = process.platform) => {
+			const definitions = SUPPORTED_CLIENT_DEFINITIONS;
+			const selected = clientIds === undefined ? ["shared", ...definitions.filter(({ skillPath }) => skillPath !== undefined).map(({ name }) => name)] : clientIds.length === 0 ? ["shared"] : clientIds;
+			const destinations = new Map();
+			for (const client of selected) {
+				const definition = definitions.find(({ name }) => name === client);
+				let directory;
+				try {
+					const resolved = definition?.skillPath === undefined ? ok(join(home, ".agents", "skills")) : resolvePath(definition.skillPath, {
+						home,
+						platform,
+						env: environment
+					});
+					if (!resolved.ok) continue;
+					directory = resolved.value;
+				} catch (cause) {
+					if (cause instanceof HermesClientPathError) continue;
+					throw cause;
+				}
+				if (!destinations.has(directory)) destinations.set(directory, {
+					client: directory === join(home, ".agents", "skills") ? "shared" : client,
+					directory
+				});
+			}
+			return [...destinations.values()].sort((left, right) => compareUnicodeCodePoints(left.directory, right.directory));
+		};
+	})))();
+}
+
+//#endregion
+export { SUPPORTED_CLIENT_DEFINITIONS, clientEvidencePaths, clientSkillDirectories, homeDirectoryFromEnvironment, init_ClientRegistrationIdentity, init_SupportedClients, init_environment, init_homeDirectory, invokingPackageRunner, isOwnedClientRegistrationCommand, manualRegistrationRemediation, npxRegistrationCommand, packageRunnerRegistrationCommand, parseEnvironment, supportedClients, withoutPackageRunnerIdentity };