@gaodefa/daocore 2026.5.73 → 2026.5.75

package/dist/compact.runtime-CtoOHiEB.js

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

package/dist/completion-cli-CAHVBBDJ.js

@@ -1,315 +0,0 @@
-import { t as formatDocsLink } from "./links-738LMw6G.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-B5LkL2i6.js";
-import { n as registerCoreCliByName, t as getCoreCliCommandNames } from "./command-registry-core-D11J7oB_.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", "daocore-ai.vercel.app/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-BETu1LsL.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-CdIz1WHr.js

@@ -1,367 +0,0 @@
-import { l as resolveCodexAppServerRuntimeOptions, u as resolveCodexComputerUseConfig } from "./config-vVEQHNjq.js";
-import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-hp0T5HDv.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 };