@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/compact.runtime-Ct3ufShc.js

@@ -0,0 +1,12 @@
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+//#region src/agents/pi-embedded-runner/compact.runtime.ts
+const compactRuntimeLoader = createLazyImportLoader(() => import("./compact-uV1p-Wsg.js"));
+function loadCompactRuntime() {
+	return compactRuntimeLoader.load();
+}
+async function compactEmbeddedPiSessionDirect(...args) {
+	const { compactEmbeddedPiSessionDirect } = await loadCompactRuntime();
+	return compactEmbeddedPiSessionDirect(...args);
+}
+//#endregion
+export { compactEmbeddedPiSessionDirect };

package/dist/compact.runtime.js

@@ -1 +1 @@
-export * from "./compact.runtime-DUkHrkr5.js";
+export * from "./compact.runtime-Ct3ufShc.js";

package/dist/completion-cli-AAlqnWhC.js

@@ -0,0 +1,315 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { a as routeLogsToStderr } from "./console-DkZh-KMc.js";
+import { a as installCompletion, c as resolveCompletionCachePath, s as isCompletionShell, t as COMPLETION_SHELLS, u as resolveShellFromEnv } from "./completion-runtime-BfGS2hGl.js";
+import { n as registerSubCliByName, t as getSubCliEntries } from "./register.subclis-core-5SzOm1NK.js";
+import { n as registerCoreCliByName, t as getCoreCliCommandNames } from "./command-registry-core-CxI25e3E.js";
+import { t as getProgramContext } from "./program-context-qqDjqw9S.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Option } from "commander";
+//#region src/cli/completion-fish.ts
+function escapeFishDescription(value) {
+	return value.replace(/'/g, "'\\''");
+}
+function parseOptionFlags(flags) {
+	const parts = flags.split(/[ ,|]+/);
+	return {
+		long: parts.find((flag) => flag.startsWith("--"))?.replace(/^--/, ""),
+		short: parts.find((flag) => flag.startsWith("-") && !flag.startsWith("--"))?.replace(/^-/, "")
+	};
+}
+function buildFishSubcommandCompletionLine(params) {
+	const desc = escapeFishDescription(params.description);
+	return `complete -c ${params.rootCmd} -n "${params.condition}" -a "${params.name}" -d '${desc}'\n`;
+}
+function buildFishOptionCompletionLine(params) {
+	const { short, long } = parseOptionFlags(params.flags);
+	const desc = escapeFishDescription(params.description);
+	let line = `complete -c ${params.rootCmd} -n "${params.condition}"`;
+	if (short) line += ` -s ${short}`;
+	if (long) line += ` -l ${long}`;
+	line += ` -d '${desc}'\n`;
+	return line;
+}
+//#endregion
+//#region src/cli/completion-cli.ts
+function getCompletionScript(shell, program) {
+	if (shell === "zsh") return generateZshCompletion(program);
+	if (shell === "bash") return generateBashCompletion(program);
+	if (shell === "powershell") return generatePowerShellCompletion(program);
+	return generateFishCompletion(program);
+}
+async function writeCompletionCache(params) {
+	const firstShell = params.shells[0] ?? "zsh";
+	const cacheDir = path.dirname(resolveCompletionCachePath(firstShell, params.binName));
+	await fs.mkdir(cacheDir, { recursive: true });
+	for (const shell of params.shells) {
+		const script = getCompletionScript(shell, params.program);
+		const targetPath = resolveCompletionCachePath(shell, params.binName);
+		await fs.writeFile(targetPath, script, "utf-8");
+	}
+}
+function writeCompletionRegistrationWarning(message) {
+	process.stderr.write(`[completion] ${message}\n`);
+}
+async function registerSubcommandsForCompletion(program) {
+	const entries = getSubCliEntries();
+	for (const entry of entries) {
+		if (entry.name === "completion") continue;
+		try {
+			await registerSubCliByName(program, entry.name, process.argv, { purpose: "completion" });
+		} catch (error) {
+			writeCompletionRegistrationWarning(`skipping subcommand \`${entry.name}\` while building completion cache: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+}
+function registerCompletionCli(program) {
+	program.command("completion").description("Generate shell completion script").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/completion", "docs.openclaw.ai/cli/completion")}\n`).addOption(new Option("-s, --shell <shell>", "Shell to generate completion for (default: zsh)").choices(COMPLETION_SHELLS)).option("-i, --install", "Install completion script to shell profile").option("--write-state", "Write completion scripts to $DAOCORE_STATE_DIR/completions (no stdout)").option("-y, --yes", "Skip confirmation (non-interactive)", false).action(async (options) => {
+		routeLogsToStderr();
+		const shell = options.shell ?? "zsh";
+		const ctx = getProgramContext(program);
+		if (ctx) for (const name of getCoreCliCommandNames()) await registerCoreCliByName(program, ctx, name);
+		await registerSubcommandsForCompletion(program);
+		if (process.env["DAOCORE_COMPLETION_SKIP_PLUGIN_COMMANDS"] !== "1") {
+			const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-L5ejswzt.js");
+			await registerPluginCliCommandsFromValidatedConfig(program, void 0, void 0, { mode: "eager" });
+		}
+		if (options.writeState) await writeCompletionCache({
+			program,
+			shells: options.shell ? [shell] : [...COMPLETION_SHELLS],
+			binName: program.name()
+		});
+		if (options.install) {
+			await installCompletion(options.shell ?? resolveShellFromEnv(), Boolean(options.yes), program.name());
+			return;
+		}
+		if (options.writeState) return;
+		if (!isCompletionShell(shell)) throw new Error(`Unsupported shell: ${shell}`);
+		const script = getCompletionScript(shell, program);
+		process.stdout.write(script + "\n");
+	});
+}
+function generateZshCompletion(program) {
+	const rootCmd = program.name();
+	return `
+#compdef ${rootCmd}
+
+_${rootCmd}_root_completion() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(program)} \\
+    ${generateZshSubcmdList(program)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${program.commands.map((cmd) => `(${cmd.name()}) _${rootCmd}_${cmd.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+
+${generateZshSubcommands(program, rootCmd)}
+
+_${rootCmd}_register_completion() {
+  if (( ! $+functions[compdef] )); then
+    return 0
+  fi
+
+  compdef _${rootCmd}_root_completion ${rootCmd}
+  precmd_functions=(\${precmd_functions:#_${rootCmd}_register_completion})
+  unfunction _${rootCmd}_register_completion 2>/dev/null
+}
+
+_${rootCmd}_register_completion
+if (( ! $+functions[compdef] )); then
+  typeset -ga precmd_functions
+  if [[ -z "\${precmd_functions[(r)_${rootCmd}_register_completion]}" ]]; then
+    precmd_functions+=(_${rootCmd}_register_completion)
+  fi
+fi
+`;
+}
+function generateZshArgs(cmd) {
+	return (cmd.options || []).map((opt) => {
+		const flags = opt.flags.split(/[ ,|]+/);
+		const name = flags.find((f) => f.startsWith("--")) || flags[0];
+		const short = flags.find((f) => f.startsWith("-") && !f.startsWith("--"));
+		const desc = opt.description.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		if (short) return `"(${name} ${short})"{${name},${short}}"[${desc}]"`;
+		return `"${name}[${desc}]"`;
+	}).join(" \\\n    ");
+}
+function generateZshSubcmdList(cmd) {
+	return `"1: :_values 'command' ${cmd.commands.map((c) => {
+		const desc = c.description().replace(/\\/g, "\\\\").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		return `'${c.name()}[${desc}]'`;
+	}).join(" ")}"`;
+}
+function generateZshSubcommands(program, prefix) {
+	const segments = [];
+	const visit = (current, currentPrefix) => {
+		for (const cmd of current.commands) {
+			const nextPrefix = `${currentPrefix}_${cmd.name().replace(/-/g, "_")}`;
+			const funcName = `_${nextPrefix}`;
+			visit(cmd, nextPrefix);
+			const subCommands = cmd.commands;
+			if (subCommands.length > 0) {
+				segments.push(`
+${funcName}() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(cmd)} \\
+    ${generateZshSubcmdList(cmd)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${subCommands.map((sub) => `(${sub.name()}) ${funcName}_${sub.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+`);
+				continue;
+			}
+			segments.push(`
+${funcName}() {
+  _arguments -C \\
+    ${generateZshArgs(cmd)}
+}
+`);
+		}
+	};
+	visit(program, prefix);
+	return segments.join("");
+}
+function generateBashCompletion(program) {
+	const rootCmd = program.name();
+	return `
+_${rootCmd}_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Simple top-level completion for now
+    opts="${program.commands.map((c) => c.name()).join(" ")} ${program.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+    
+    case "\${prev}" in
+      ${program.commands.map((cmd) => generateBashSubcommand(cmd)).join("\n      ")}
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+    
+    COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+}
+
+complete -F _${rootCmd}_completion ${rootCmd}
+`;
+}
+function generateBashSubcommand(cmd) {
+	return `${cmd.name()})
+        opts="${cmd.commands.map((c) => c.name()).join(" ")} ${cmd.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+        ;;`;
+}
+function generatePowerShellCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, pathSegments) => {
+		const fullPath = pathSegments.join(" ");
+		const subCommands = cmd.commands.map((c) => c.name());
+		const options = cmd.options.map((o) => o.flags.split(/[ ,|]+/)[0]);
+		const allCompletions = [...subCommands, ...options].map((s) => `'${s}'`).join(",");
+		if (fullPath.length > 0 && allCompletions.length > 0) segments.push(`
+            if ($commandPath -eq '${fullPath}') {
+                $completions = @(${allCompletions})
+                $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+                }
+            }
+`);
+		for (const sub of cmd.commands) visit(sub, [...pathSegments, sub.name()]);
+	};
+	visit(program, []);
+	const rootBody = segments.join("");
+	return `
+Register-ArgumentCompleter -Native -CommandName ${rootCmd} -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    
+    $commandElements = $commandAst.CommandElements
+    $commandPath = ""
+    
+    # Reconstruct command path (simple approximation)
+    # Skip the executable name
+    for ($i = 1; $i -lt $commandElements.Count; $i++) {
+        $element = $commandElements[$i].Extent.Text
+        if ($element -like "-*") { break }
+        if ($i -eq $commandElements.Count - 1 -and $wordToComplete -ne "") { break } # Don't include current word being typed
+        $commandPath += "$element "
+    }
+    $commandPath = $commandPath.Trim()
+    
+    # Root command
+    if ($commandPath -eq "") {
+         $completions = @(${program.commands.map((c) => `'${c.name()}'`).join(",")}, ${program.options.map((o) => `'${o.flags.split(" ")[0]}'`).join(",")}) 
+         $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+         }
+    }
+    
+    ${rootBody}
+}
+`;
+}
+function generateFishCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, parents) => {
+		const cmdName = cmd.name();
+		if (parents.length === 0) {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				flags: opt.flags,
+				description: opt.description
+			}));
+		} else {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				flags: opt.flags,
+				description: opt.description
+			}));
+		}
+		for (const sub of cmd.commands) visit(sub, [...parents, cmdName]);
+	};
+	visit(program, []);
+	return segments.join("");
+}
+//#endregion
+export { getCompletionScript, registerCompletionCli };

package/dist/computer-use-CLHOvbCu.js

@@ -0,0 +1,367 @@
+import { l as resolveCodexAppServerRuntimeOptions, u as resolveCodexComputerUseConfig } from "./config-vVEQHNjq.js";
+import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-C67a33Eo.js";
+import { existsSync } from "node:fs";
+//#region extensions/codex/src/app-server/computer-use.ts
+var CodexComputerUseSetupError = class extends Error {
+	constructor(status) {
+		super(status.message);
+		this.name = "CodexComputerUseSetupError";
+		this.status = status;
+	}
+};
+const CURATED_MARKETPLACE_POLL_INTERVAL_MS = 2e3;
+const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
+	"openai-bundled",
+	"openai-curated",
+	"local"
+];
+const DEFAULT_CODEX_BUNDLED_MARKETPLACE_PATH = "/Applications/Codex.app/Contents/Resources/plugins/openai-bundled";
+async function readCodexComputerUseStatus(params = {}) {
+	const config = resolveComputerUseConfig(params);
+	if (!config.enabled) return disabledStatus(config);
+	try {
+		return await inspectCodexComputerUse({
+			...params,
+			config,
+			installPlugin: false
+		});
+	} catch (error) {
+		return unavailableStatus(config, "check_failed", `Computer Use check failed: ${describeControlFailure(error)}`);
+	}
+}
+async function ensureCodexComputerUse(params = {}) {
+	const config = resolveComputerUseConfig(params);
+	if (!config.enabled) return disabledStatus(config);
+	const status = await inspectCodexComputerUse({
+		...params,
+		config,
+		installPlugin: false
+	});
+	if (status.ready) return status;
+	if (config.autoInstall) {
+		const blockedAutoInstallStatus = blockUnsafeAutoInstallStatus(config);
+		if (blockedAutoInstallStatus) throw new CodexComputerUseSetupError(blockedAutoInstallStatus);
+		const installedStatus = await inspectCodexComputerUse({
+			...params,
+			config,
+			installPlugin: true
+		});
+		if (!installedStatus.ready) throw new CodexComputerUseSetupError(installedStatus);
+		return installedStatus;
+	}
+	if (!status.ready) throw new CodexComputerUseSetupError(status);
+	return status;
+}
+async function installCodexComputerUse(params = {}) {
+	const config = resolveComputerUseConfig({
+		...params,
+		forceEnable: true,
+		overrides: {
+			...params.overrides,
+			enabled: true,
+			autoInstall: true
+		}
+	});
+	const status = await inspectCodexComputerUse({
+		...params,
+		config,
+		installPlugin: true
+	});
+	if (!status.ready) throw new CodexComputerUseSetupError(status);
+	return status;
+}
+async function inspectCodexComputerUse(params) {
+	const request = createComputerUseRequest(params);
+	if (params.installPlugin) await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
+	const marketplace = await resolveMarketplaceRef({
+		request,
+		config: params.config,
+		allowAdd: params.installPlugin,
+		signal: params.signal,
+		defaultBundledMarketplacePath: params.defaultBundledMarketplacePath
+	});
+	if (!marketplace.marketplace) return unavailableStatus(params.config, "marketplace_missing", marketplace.message ?? `No Codex marketplace containing ${params.config.pluginName} is registered. Configure computerUse.marketplaceSource or computerUse.marketplacePath, then run /codex computer-use install.`);
+	const pluginInspection = await ensureComputerUsePlugin({
+		request,
+		config: params.config,
+		marketplace: marketplace.marketplace,
+		installPlugin: params.installPlugin
+	});
+	if (!pluginInspection.ok) return pluginInspection.status;
+	return await readComputerUseTools({
+		request,
+		config: params.config,
+		plugin: pluginInspection.plugin,
+		installPlugin: params.installPlugin
+	});
+}
+async function ensureComputerUsePlugin(params) {
+	let plugin = await readComputerUsePlugin(params.request, params.marketplace, params.config.pluginName);
+	if (!plugin.summary.installed || !plugin.summary.enabled) {
+		if (!params.installPlugin) return {
+			ok: false,
+			status: statusFromPlugin({
+				config: params.config,
+				plugin,
+				tools: [],
+				reason: pluginSetupReason(plugin, params.marketplace),
+				message: pluginSetupMessage(params.config, plugin, params.marketplace)
+			})
+		};
+		if (params.marketplace.kind === "remote") return {
+			ok: false,
+			status: statusFromPlugin({
+				config: params.config,
+				plugin,
+				tools: [],
+				reason: "remote_install_unsupported",
+				message: remoteInstallUnsupportedMessage(plugin, params.marketplace)
+			})
+		};
+		await params.request("plugin/install", pluginRequestParams(params.marketplace, params.config.pluginName));
+		await reloadMcpServers(params.request);
+		plugin = await readComputerUsePlugin(params.request, params.marketplace, params.config.pluginName);
+	}
+	if (!plugin.summary.installed || !plugin.summary.enabled) return {
+		ok: false,
+		status: statusFromPlugin({
+			config: params.config,
+			plugin,
+			tools: [],
+			reason: pluginSetupReason(plugin, params.marketplace),
+			message: pluginSetupMessage(params.config, plugin, params.marketplace)
+		})
+	};
+	return {
+		ok: true,
+		plugin
+	};
+}
+async function readComputerUseTools(params) {
+	let server = await readMcpServerStatus(params.request, params.config.mcpServerName);
+	if (!server && params.installPlugin) {
+		await reloadMcpServers(params.request);
+		server = await readMcpServerStatus(params.request, params.config.mcpServerName);
+	}
+	if (!server) return statusFromPlugin({
+		config: params.config,
+		plugin: params.plugin,
+		tools: [],
+		reason: "mcp_missing",
+		message: `Computer Use is installed, but the ${params.config.mcpServerName} MCP server is not available.`
+	});
+	return statusFromPlugin({
+		config: params.config,
+		plugin: params.plugin,
+		tools: Object.keys(server.tools).toSorted(),
+		reason: "ready",
+		message: "Computer Use is ready."
+	});
+}
+async function resolveMarketplaceRef(params) {
+	let preferredMarketplaceName = params.config.marketplaceName;
+	if (params.config.marketplaceSource && params.allowAdd) {
+		const added = await params.request("marketplace/add", { source: params.config.marketplaceSource });
+		preferredMarketplaceName ??= added.marketplaceName;
+	}
+	if (params.config.marketplacePath) return { marketplace: preferredMarketplaceName ? {
+		kind: "local",
+		name: preferredMarketplaceName,
+		path: params.config.marketplacePath
+	} : {
+		kind: "local",
+		path: params.config.marketplacePath
+	} };
+	let candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
+	if (candidates.length === 0 && shouldAddBundledComputerUseMarketplace(params)) {
+		const bundledMarketplacePath = params.defaultBundledMarketplacePath ?? DEFAULT_CODEX_BUNDLED_MARKETPLACE_PATH;
+		const added = await params.request("marketplace/add", { source: bundledMarketplacePath });
+		preferredMarketplaceName ??= added.marketplaceName;
+		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
+	}
+	const waitUntil = marketplaceDiscoveryWaitUntil(params);
+	while (candidates.length === 0) {
+		if (Date.now() >= waitUntil) break;
+		await delay(Math.min(CURATED_MARKETPLACE_POLL_INTERVAL_MS, waitUntil - Date.now()), params.signal);
+		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
+	}
+	if (preferredMarketplaceName) {
+		const preferred = candidates.find((candidate) => candidate.name === preferredMarketplaceName);
+		if (preferred) return { marketplace: preferred };
+		return { message: `Configured Codex marketplace ${preferredMarketplaceName} was not found or does not contain ${params.config.pluginName}. Run /codex computer-use install with a source or path to install from a new marketplace.` };
+	}
+	if (candidates.length > 1) {
+		const preferred = chooseKnownComputerUseMarketplace(candidates);
+		if (preferred) return { marketplace: preferred };
+		return { message: `Multiple Codex marketplaces contain ${params.config.pluginName}. Configure computerUse.marketplaceName or computerUse.marketplacePath to choose one.` };
+	}
+	if (params.config.marketplaceSource && !params.allowAdd && candidates.length === 0) return { message: "Computer Use marketplace source is configured but has not been registered. Run /codex computer-use install to register it." };
+	const marketplace = candidates[0];
+	return marketplace ? { marketplace } : {};
+}
+async function listComputerUseMarketplaceCandidates(request, config) {
+	return findComputerUseMarketplaces(await request("plugin/list", { cwds: [] }), config.pluginName);
+}
+function blockUnsafeAutoInstallStatus(config) {
+	if (!config.marketplaceSource) return;
+	return unavailableStatus(config, "auto_install_blocked", "Computer Use auto-install only uses marketplaces Codex app-server has already discovered. Run /codex computer-use install to install from a configured marketplace source.");
+}
+function shouldAddBundledComputerUseMarketplace(params) {
+	const bundledMarketplacePath = params.defaultBundledMarketplacePath ?? DEFAULT_CODEX_BUNDLED_MARKETPLACE_PATH;
+	return params.allowAdd && !params.config.marketplaceSource && !params.config.marketplacePath && !params.config.marketplaceName && existsSync(bundledMarketplacePath);
+}
+function findComputerUseMarketplaces(listed, pluginName) {
+	return listed.marketplaces.filter((marketplace) => marketplace.plugins.some((plugin) => plugin.name === pluginName || plugin.id === pluginName || plugin.id === `${pluginName}@${marketplace.name}`)).map((marketplace) => {
+		if (marketplace.path) return {
+			kind: "local",
+			name: marketplace.name,
+			path: marketplace.path
+		};
+		return {
+			kind: "remote",
+			name: marketplace.name,
+			remoteMarketplaceName: marketplace.name
+		};
+	});
+}
+function chooseKnownComputerUseMarketplace(candidates) {
+	for (const marketplaceName of COMPUTER_USE_MARKETPLACE_NAME_PRIORITY) {
+		const candidate = candidates.find((marketplace) => marketplace.name === marketplaceName);
+		if (candidate) return candidate;
+	}
+}
+function marketplaceDiscoveryWaitUntil(params) {
+	if (params.allowAdd && !params.config.marketplaceSource && !params.config.marketplacePath && !params.config.marketplaceName) return Date.now() + params.config.marketplaceDiscoveryTimeoutMs;
+	return 0;
+}
+async function delay(ms, signal) {
+	if (signal?.aborted) throw abortError(signal);
+	await new Promise((resolve, reject) => {
+		let timer;
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			reject(abortError(signal));
+		};
+		timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function abortError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error ? reason : /* @__PURE__ */ new Error("Computer Use setup was aborted.");
+}
+async function readComputerUsePlugin(request, marketplace, pluginName) {
+	return (await request("plugin/read", pluginRequestParams(marketplace, pluginName))).plugin;
+}
+async function readMcpServerStatus(request, serverName) {
+	let cursor;
+	do {
+		const response = await request("mcpServerStatus/list", {
+			cursor,
+			limit: 100,
+			detail: "toolsAndAuthOnly"
+		});
+		const found = response.data.find((server) => server.name === serverName);
+		if (found) return found;
+		cursor = response.nextCursor;
+	} while (cursor);
+}
+async function reloadMcpServers(request) {
+	await request("config/mcpServer/reload", void 0);
+}
+function pluginRequestParams(marketplace, pluginName) {
+	return {
+		...marketplace.kind === "local" ? { marketplacePath: marketplace.path } : {},
+		...marketplace.kind === "remote" ? { remoteMarketplaceName: marketplace.remoteMarketplaceName } : {},
+		pluginName
+	};
+}
+function pluginSetupReason(plugin, marketplace) {
+	if (marketplace.kind === "remote") return "remote_install_unsupported";
+	return plugin.summary.installed ? "plugin_disabled" : "plugin_not_installed";
+}
+function pluginSetupMessage(config, plugin, marketplace) {
+	if (marketplace.kind === "remote") return remoteInstallUnsupportedMessage(plugin, marketplace);
+	if (!plugin.summary.installed) return "Computer Use is available but not installed. Run /codex computer-use install or enable computerUse.autoInstall.";
+	return `Computer Use is installed, but the ${config.pluginName} plugin is disabled. Run /codex computer-use install or enable computerUse.autoInstall to re-enable it.`;
+}
+function remoteInstallUnsupportedMessage(plugin, marketplace) {
+	const marketplaceName = marketplace.name ?? plugin.marketplaceName;
+	return `Computer Use is ${plugin.summary.installed ? "installed but disabled" : "available"} in remote Codex marketplace ${marketplaceName}, but Codex app-server does not support remote plugin install yet. Configure computerUse.marketplaceSource or computerUse.marketplacePath for a local marketplace, then run /codex computer-use install.`;
+}
+function statusFromPlugin(params) {
+	return {
+		enabled: true,
+		ready: params.plugin.summary.installed && params.plugin.summary.enabled && params.tools.length > 0,
+		reason: params.reason,
+		installed: params.plugin.summary.installed,
+		pluginEnabled: params.plugin.summary.enabled,
+		mcpServerAvailable: params.tools.length > 0,
+		pluginName: params.config.pluginName,
+		mcpServerName: params.config.mcpServerName,
+		marketplaceName: params.plugin.marketplaceName,
+		...params.plugin.marketplacePath ? { marketplacePath: params.plugin.marketplacePath } : {},
+		tools: params.tools,
+		message: params.message
+	};
+}
+function disabledStatus(config) {
+	return {
+		enabled: false,
+		ready: false,
+		reason: "disabled",
+		installed: false,
+		pluginEnabled: false,
+		mcpServerAvailable: false,
+		pluginName: config.pluginName,
+		mcpServerName: config.mcpServerName,
+		tools: [],
+		message: "Computer Use is disabled."
+	};
+}
+function unavailableStatus(config, reason, message) {
+	return {
+		enabled: true,
+		ready: false,
+		reason,
+		installed: false,
+		pluginEnabled: false,
+		mcpServerAvailable: false,
+		pluginName: config.pluginName,
+		mcpServerName: config.mcpServerName,
+		...config.marketplaceName ? { marketplaceName: config.marketplaceName } : {},
+		...config.marketplacePath ? { marketplacePath: config.marketplacePath } : {},
+		tools: [],
+		message
+	};
+}
+function createComputerUseRequest(params) {
+	if (params.request) return params.request;
+	if (params.client) return async (method, requestParams) => await params.client.request(method, requestParams, {
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.pluginConfig });
+	return async (method, requestParams) => await requestCodexAppServerJson({
+		method,
+		requestParams,
+		timeoutMs: params.timeoutMs ?? runtime.requestTimeoutMs,
+		startOptions: runtime.start
+	});
+}
+function resolveComputerUseConfig(params) {
+	const overrides = params.forceEnable ? {
+		...params.overrides,
+		enabled: true
+	} : params.overrides;
+	return resolveCodexComputerUseConfig({
+		pluginConfig: params.pluginConfig,
+		overrides
+	});
+}
+//#endregion
+export { installCodexComputerUse as n, readCodexComputerUseStatus as r, ensureCodexComputerUse as t };