@gakr-gakr/codex 0.1.0 → 0.1.1

package/dist/compact-CDboBy7o.js

@@ -0,0 +1,329 @@
+import { c as resolveCodexAppServerRuntimeOptions } from "./config-CLMSw0p2.js";
+import { t as isJsonObject } from "./protocol-C9UWI98H.js";
+import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-e2GFp9VH.js";
+import { t as defaultCodexAppServerClientFactory } from "./client-factory-Bu9OClHJ.js";
+import { compactContextEngineWithSafetyTimeout, embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, resolveCompactionTimeoutMs, resolveContextEngineOwnerPluginId, runHarnessContextEngineMaintenance } from "autobot/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/compact.ts
+const DEFAULT_CODEX_COMPACTION_WAIT_TIMEOUT_MS = 300 * 1e3;
+const warnedIgnoredCompactionOverrides = /* @__PURE__ */ new Set();
+async function maybeCompactCodexAppServerSession(params, options = {}) {
+	const activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
+	if (activeContextEngine?.info.ownsCompaction) return await compactOwningContextEngine(params, activeContextEngine);
+	warnIfIgnoringAutoBotCompactionOverrides(params);
+	const nativeResult = await compactCodexNativeThread(params, options);
+	if (activeContextEngine && nativeResult?.ok && nativeResult.compacted) try {
+		await runHarnessContextEngineMaintenance({
+			contextEngine: activeContextEngine,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			sessionFile: params.sessionFile,
+			reason: "compaction",
+			runtimeContext: params.contextEngineRuntimeContext,
+			config: params.config
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("context engine compaction maintenance failed after Codex compaction", {
+			sessionId: params.sessionId,
+			engineId: activeContextEngine.info.id,
+			error: formatErrorMessage(error)
+		});
+	}
+	return nativeResult;
+}
+async function compactOwningContextEngine(params, contextEngine) {
+	embeddedAgentLog.info("starting context-engine-owned Codex app-server compaction", {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		engineId: contextEngine.info.id,
+		tokenBudget: params.contextTokenBudget,
+		currentTokenCount: params.currentTokenCount,
+		trigger: params.trigger,
+		compactionTarget: params.trigger === "manual" ? "threshold" : "budget",
+		force: params.trigger === "manual"
+	});
+	let result;
+	try {
+		result = await compactContextEngineWithSafetyTimeout(contextEngine, {
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			sessionFile: params.sessionFile,
+			tokenBudget: params.contextTokenBudget,
+			currentTokenCount: params.currentTokenCount,
+			compactionTarget: params.trigger === "manual" ? "threshold" : "budget",
+			customInstructions: params.customInstructions,
+			force: params.trigger === "manual",
+			runtimeContext: params.contextEngineRuntimeContext
+		}, resolveCompactionTimeoutMs(params.config), params.abortSignal);
+	} catch (error) {
+		embeddedAgentLog.warn("context-engine-owned Codex app-server compaction failed", {
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			engineId: contextEngine.info.id,
+			error: formatErrorMessage(error)
+		});
+		return {
+			ok: false,
+			compacted: false,
+			reason: `context engine compaction failed: ${formatErrorMessage(error)}`
+		};
+	}
+	if (result.ok && result.compacted) {
+		const compactedSessionId = result.result?.sessionId ?? params.sessionId;
+		const compactedSessionFile = result.result?.sessionFile ?? params.sessionFile;
+		try {
+			await runHarnessContextEngineMaintenance({
+				contextEngine,
+				sessionId: compactedSessionId,
+				sessionKey: params.sessionKey,
+				sessionFile: compactedSessionFile,
+				reason: "compaction",
+				runtimeContext: params.contextEngineRuntimeContext,
+				config: params.config
+			});
+		} catch (error) {
+			embeddedAgentLog.warn("context engine compaction maintenance failed", {
+				sessionId: compactedSessionId,
+				engineId: contextEngine.info.id,
+				error: formatErrorMessage(error)
+			});
+		}
+		await clearCodexAppServerBinding(params.sessionFile);
+		if (compactedSessionFile !== params.sessionFile) await clearCodexAppServerBinding(compactedSessionFile);
+	}
+	embeddedAgentLog.info("completed context-engine-owned Codex app-server compaction", {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		engineId: contextEngine.info.id,
+		ok: result.ok,
+		compacted: result.compacted,
+		reason: result.reason,
+		codexThreadBindingInvalidated: result.ok && result.compacted
+	});
+	return {
+		ok: result.ok,
+		compacted: result.compacted,
+		reason: result.reason,
+		result: result.result ? {
+			...result.result,
+			summary: result.result.summary ?? "",
+			firstKeptEntryId: result.result.firstKeptEntryId ?? "",
+			details: mergeContextEngineCompactionDetails(result.result.details, { codexThreadBindingInvalidated: result.ok && result.compacted })
+		} : result.ok && result.compacted ? {
+			summary: "",
+			firstKeptEntryId: "",
+			tokensBefore: params.currentTokenCount ?? 0,
+			details: { codexThreadBindingInvalidated: true }
+		} : void 0
+	};
+}
+function mergeContextEngineCompactionDetails(details, extra) {
+	if (details && typeof details === "object" && !Array.isArray(details)) return {
+		...details,
+		...extra
+	};
+	return extra;
+}
+function warnIfIgnoringAutoBotCompactionOverrides(params) {
+	const ignoredConfig = readIgnoredCompactionOverridePaths(params, isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0);
+	if (ignoredConfig.length === 0) return;
+	const warningKey = ignoredConfig.join("\0");
+	if (warnedIgnoredCompactionOverrides.has(warningKey)) return;
+	warnedIgnoredCompactionOverrides.add(warningKey);
+	embeddedAgentLog.warn("ignoring AutoBot compaction overrides for Codex app-server compaction; Codex uses native server-side compaction", {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		ignoredConfig
+	});
+}
+function readIgnoredCompactionOverridePaths(params, activeContextEngine) {
+	const ignored = /* @__PURE__ */ new Set();
+	const configuredContextEngine = readStringPath(params.config, [
+		"plugins",
+		"slots",
+		"contextEngine"
+	]);
+	const runtimeContextEnginePlugin = typeof params.contextEngineRuntimeContext?.contextEnginePluginId === "string" ? params.contextEngineRuntimeContext.contextEnginePluginId.trim() : "";
+	const activeContextEnginePlugin = resolveContextEngineOwnerPluginId(activeContextEngine);
+	for (const entry of readCompactionOverrideEntries(params)) {
+		const localProvider = typeof entry.record.provider === "string" ? entry.record.provider.trim() : "";
+		const inheritedProvider = !localProvider && typeof entry.inheritedRecord?.provider === "string" ? entry.inheritedRecord.provider.trim() : "";
+		const provider = localProvider || inheritedProvider;
+		const providerPath = localProvider ? `${entry.path}.compaction.provider` : inheritedProvider && entry.inheritedPath ? `${entry.inheritedPath}.compaction.provider` : void 0;
+		if (provider.toLowerCase() === "lossless-claw" && (activeContextEnginePlugin === "lossless-claw" || runtimeContextEnginePlugin.toLowerCase() === "lossless-claw" || configuredContextEngine?.toLowerCase() === "lossless-claw")) continue;
+		if (typeof entry.record.model === "string" && entry.record.model.trim()) ignored.add(`${entry.path}.compaction.model`);
+		if (providerPath) ignored.add(providerPath);
+	}
+	return [...ignored];
+}
+function readCompactionOverrideEntries(params) {
+	const entries = [];
+	const defaultCompaction = readRecord(readRecord(params.config?.agents)?.defaults)?.compaction;
+	const defaultRecord = readRecord(defaultCompaction);
+	if (defaultRecord) entries.push({
+		path: "agents.defaults",
+		record: defaultRecord
+	});
+	const agentId = readAgentIdFromSessionKey(params.sessionKey ?? params.sandboxSessionKey);
+	if (!agentId) return entries;
+	const agentCompaction = readRecord((Array.isArray(params.config?.agents?.list) ? params.config.agents.list : []).find((agent) => {
+		return (typeof agent?.id === "string" ? agent.id.trim().toLowerCase() : "") === agentId;
+	}))?.compaction;
+	const agentRecord = readRecord(agentCompaction);
+	if (agentRecord) entries.push({
+		path: `agents.list.${agentId}`,
+		record: agentRecord,
+		inheritedRecord: defaultRecord,
+		inheritedPath: "agents.defaults"
+	});
+	return entries;
+}
+function readAgentIdFromSessionKey(sessionKey) {
+	const parts = sessionKey?.trim().toLowerCase().split(":").filter(Boolean) ?? [];
+	if (parts.length < 3 || parts[0] !== "agent") return;
+	return parts[1]?.trim() || void 0;
+}
+function readRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readStringPath(value, path) {
+	let current = value;
+	for (const segment of path) current = readRecord(current)?.[segment];
+	return typeof current === "string" && current.trim() ? current.trim() : void 0;
+}
+async function compactCodexNativeThread(params, options = {}) {
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const binding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
+	if (!binding?.threadId) return {
+		ok: false,
+		compacted: false,
+		reason: "no codex app-server thread binding"
+	};
+	const requestedAuthProfileId = params.authProfileId?.trim() || void 0;
+	if (requestedAuthProfileId && binding.authProfileId && binding.authProfileId !== requestedAuthProfileId) return {
+		ok: false,
+		compacted: false,
+		reason: "auth profile mismatch for session binding"
+	};
+	const client = await (options.clientFactory ?? defaultCodexAppServerClientFactory)(appServer.start, requestedAuthProfileId ?? binding.authProfileId, params.agentDir, params.config);
+	const waiter = createCodexNativeCompactionWaiter(client, binding.threadId);
+	let completion;
+	try {
+		await client.request("thread/compact/start", { threadId: binding.threadId });
+		embeddedAgentLog.info("started codex app-server compaction", {
+			sessionId: params.sessionId,
+			threadId: binding.threadId
+		});
+		waiter.startTimeout();
+		completion = await waiter.promise;
+	} catch (error) {
+		waiter.cancel();
+		return {
+			ok: false,
+			compacted: false,
+			reason: formatCompactionError(error)
+		};
+	}
+	embeddedAgentLog.info("completed codex app-server compaction", {
+		sessionId: params.sessionId,
+		threadId: binding.threadId,
+		signal: completion.signal,
+		turnId: completion.turnId,
+		itemId: completion.itemId
+	});
+	return {
+		ok: true,
+		compacted: true,
+		result: {
+			summary: "",
+			firstKeptEntryId: "",
+			tokensBefore: params.currentTokenCount ?? 0,
+			details: {
+				backend: "codex-app-server",
+				threadId: binding.threadId,
+				signal: completion.signal,
+				turnId: completion.turnId,
+				itemId: completion.itemId
+			}
+		}
+	};
+}
+function createCodexNativeCompactionWaiter(client, threadId) {
+	let settled = false;
+	let removeHandler = () => {};
+	let timeout;
+	let failWaiter = () => {};
+	return {
+		promise: new Promise((resolve, reject) => {
+			const cleanup = () => {
+				removeHandler();
+				if (timeout) clearTimeout(timeout);
+			};
+			const complete = (completion) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(completion);
+			};
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(error);
+			};
+			failWaiter = fail;
+			const handler = (notification) => {
+				const completion = readNativeCompactionCompletion(notification, threadId);
+				if (completion) complete(completion);
+			};
+			removeHandler = client.addNotificationHandler(handler);
+		}),
+		startTimeout() {
+			if (settled || timeout) return;
+			timeout = setTimeout(() => {
+				failWaiter(/* @__PURE__ */ new Error(`timed out waiting for codex app-server compaction for ${threadId}`));
+			}, resolveCompactionWaitTimeoutMs());
+			timeout.unref?.();
+		},
+		cancel() {
+			if (settled) return;
+			settled = true;
+			removeHandler();
+			if (timeout) clearTimeout(timeout);
+		}
+	};
+}
+function readNativeCompactionCompletion(notification, threadId) {
+	const params = notification.params;
+	if (!isJsonObject(params) || readString(params, "threadId", "thread_id") !== threadId) return;
+	if (notification.method === "thread/compacted") return {
+		signal: "thread/compacted",
+		turnId: readString(params, "turnId", "turn_id")
+	};
+	if (notification.method !== "item/completed") return;
+	const item = isJsonObject(params.item) ? params.item : void 0;
+	if (readString(item, "type") !== "contextCompaction") return;
+	return {
+		signal: "item/completed",
+		turnId: readString(params, "turnId", "turn_id"),
+		itemId: readString(item, "id") ?? readString(params, "itemId", "item_id", "id")
+	};
+}
+function resolveCompactionWaitTimeoutMs() {
+	const raw = process.env.AUTOBOT_CODEX_COMPACTION_WAIT_TIMEOUT_MS?.trim();
+	const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+	if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	return DEFAULT_CODEX_COMPACTION_WAIT_TIMEOUT_MS;
+}
+function readString(params, ...keys) {
+	if (!params) return;
+	for (const key of keys) {
+		const value = params[key];
+		if (typeof value === "string") return value;
+	}
+}
+function formatCompactionError(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+//#endregion
+export { maybeCompactCodexAppServerSession };

package/dist/computer-use-DCZB46Sw.js

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