@openclaw/codex 2026.6.5 → 2026.6.6-beta.1

package/dist/{native-hook-relay-DHwz_ICg.js → native-hook-relay-CmUUO3Eu.js}

@@ -1,12 +1,14 @@
-import { l as isJsonObject } from "./client-kMCtlApt.js";
-import { S as invalidInlineImageText, w as sanitizeInlineImageDataUrl } from "./thread-lifecycle-BJsazZ8j.js";
-import { s as formatCodexDisplayText } from "./notification-correlation-o8quHmTK.js";
+import { c as isTrustedCodexModelBackedOpenAIProvider } from "./config-DJXpBkGf.js";
+import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
+import { E as sanitizeInlineImageDataUrl, w as invalidInlineImageText } from "./thread-lifecycle-Cq1-IfZB.js";
+import { l as formatCodexDisplayText } from "./notification-correlation-D-MYfJwV.js";
 import { addTimerTimeoutGraceMs, finiteSecondsToTimerSafeMilliseconds, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { createHash } from "node:crypto";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, callGatewayTool, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, formatApprovalDisplayPath, hasNativeHookRelayInvocation, invokeNativeHookRelay, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveNativeHookRelayDeferredToolApproval, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { buildExecAutoReviewInputForShellCommand, reviewExecRequestWithConfiguredModel } from "openclaw/plugin-sdk/agent-harness-exec-review-runtime";
 /** Default idle timeout while waiting for app-server turn completion. */
 const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
 /** Short guard after apparent assistant completion. */
@@ -235,6 +237,27 @@ async function handleCodexAppServerApprovalRequest(params) {
 			});
 			return buildApprovalResponse(params.method, context.requestParams, "approved-session");
 		}
+		const autoReviewOutcome = await runInternalExecAutoReviewForApprovalRequest({
+			enabled: params.internalExecAutoReview === true && params.execPolicy?.mode === "auto",
+			method: params.method,
+			requestParams,
+			paramsForRun: params.paramsForRun,
+			context,
+			agentId: params.execReviewerAgentId,
+			signal: params.signal
+		});
+		if (autoReviewOutcome?.outcome === "approved-once") {
+			emitApprovalEvent(params.paramsForRun, {
+				phase: "resolved",
+				kind: context.kind,
+				status: "approved",
+				title: context.title,
+				...context.eventDetails,
+				...approvalEventScope(params.method, autoReviewOutcome.outcome),
+				message: autoReviewOutcome.reason
+			});
+			return buildApprovalResponse(params.method, context.requestParams, autoReviewOutcome.outcome);
+		}
 		const requestResult = await requestPluginApproval({
 			paramsForRun: params.paramsForRun,
 			title: context.title,
@@ -350,6 +373,132 @@ function buildApprovalContext(params) {
 		}
 	};
 }
+async function runInternalExecAutoReviewForApprovalRequest(params) {
+	if (!params.enabled || params.method !== "item/commandExecution/requestApproval") return;
+	if (hasCommandApprovalCapabilityAmendments(params.requestParams)) return;
+	const input = await buildAppServerExecAutoReviewInput({
+		requestParams: params.requestParams,
+		paramsForRun: params.paramsForRun
+	});
+	if (!input) return;
+	const reviewerConfig = resolveExecReviewerConfig(params.paramsForRun, params.agentId);
+	if (!canUseInternalExecAutoReviewReviewer(reviewerConfig, params.paramsForRun.config, process.env, params.paramsForRun.agentDir)) return;
+	const decision = await waitForInternalExecAutoReviewDecision({
+		signal: params.signal,
+		promise: reviewExecRequestWithConfiguredModel({
+			cfg: params.paramsForRun.config,
+			agentId: params.agentId ?? params.paramsForRun.agentId,
+			reviewer: reviewerConfig,
+			input
+		})
+	});
+	if (decision.decision !== "allow-once") return;
+	return {
+		outcome: "approved-once",
+		reason: `Codex app-server command approval granted by OpenClaw exec auto-reviewer: ${formatCodexDisplayText(decision.rationale)}`
+	};
+}
+async function waitForInternalExecAutoReviewDecision(params) {
+	if (!params.signal) return params.promise;
+	if (params.signal.aborted) throw toCodexAppServerApprovalCancellationError(params.signal.reason);
+	let onAbort;
+	const abortPromise = new Promise((_, reject) => {
+		onAbort = () => reject(toCodexAppServerApprovalCancellationError(params.signal?.reason));
+		params.signal?.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([params.promise, abortPromise]);
+	} finally {
+		if (onAbort) params.signal.removeEventListener("abort", onAbort);
+	}
+}
+function toCodexAppServerApprovalCancellationError(reason) {
+	if (reason instanceof Error) return reason;
+	return new Error(typeof reason === "string" && reason.trim() ? reason : "Codex app-server approval cancelled.");
+}
+async function buildAppServerExecAutoReviewInput(params) {
+	const command = readString$1(params.requestParams, "command");
+	if (!command) return;
+	return buildExecAutoReviewInputForShellCommand({
+		command,
+		cwd: readString$1(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir ?? null,
+		host: "codex-app-server",
+		agent: {
+			id: params.paramsForRun.agentId ?? null,
+			sessionKey: params.paramsForRun.sessionKey ?? null
+		}
+	});
+}
+function hasCommandApprovalCapabilityAmendments(requestParams) {
+	return hasNonEmptyJsonObject(requestParams?.additionalPermissions) || hasNonEmptyJsonObject(requestParams?.networkApprovalContext) || hasNonEmptyJsonObject(requestParams?.proposedExecpolicyAmendment) || hasNonEmptyArray(requestParams?.proposedExecpolicyAmendment) || hasNonEmptyArray(requestParams?.proposedNetworkPolicyAmendments) || findAvailableCommandAmendmentDecision(requestParams) !== void 0 || commandAcceptDecisionUnavailable(requestParams);
+}
+function commandAcceptDecisionUnavailable(requestParams) {
+	const available = requestParams?.availableDecisions;
+	return Array.isArray(available) && !available.includes("accept");
+}
+function hasNonEmptyJsonObject(value) {
+	return isJsonObject(value) && Object.keys(value).length > 0;
+}
+function hasNonEmptyArray(value) {
+	return Array.isArray(value) && value.length > 0;
+}
+function resolveExecReviewerConfig(params, agentId) {
+	const configRoot = readUnknownRecord(params.config);
+	const globalExec = readUnknownRecord(readUnknownRecord(configRoot?.tools)?.exec);
+	return readUnknownRecord(resolveAgentExecConfig(configRoot, agentId ?? params.agentId)?.reviewer) ?? readUnknownRecord(globalExec?.reviewer);
+}
+function canUseInternalExecAutoReviewReviewer(reviewerConfig, config, env, agentDir) {
+	const model = readExecReviewerModelRef(reviewerConfig);
+	const slashIndex = model?.indexOf("/") ?? -1;
+	if (!model || slashIndex <= 0) return false;
+	if (configuredAgentModelAliasMatches(config, model)) return false;
+	if (model.slice(0, slashIndex).trim().toLowerCase() !== "openai") return false;
+	return isTrustedCodexModelBackedOpenAIProvider({
+		config,
+		env,
+		agentDir,
+		model: model.slice(slashIndex + 1).trim()
+	});
+}
+function readExecReviewerModelRef(reviewerConfig) {
+	const model = reviewerConfig?.model;
+	if (typeof model === "string") return model.trim() || void 0;
+	const primary = readUnknownRecord(model)?.primary;
+	return typeof primary === "string" && primary.trim() ? primary.trim() : void 0;
+}
+function configuredAgentModelAliasMatches(config, modelRef) {
+	const normalizedModelRef = normalizeExecReviewerAliasRef(modelRef);
+	return agentModelAliasMatches(readUnknownRecord(readUnknownRecord(readUnknownRecord(config)?.agents)?.defaults), normalizedModelRef);
+}
+function agentModelAliasMatches(agentConfig, normalizedModelRef) {
+	const models = readUnknownRecord(agentConfig?.models);
+	if (!models) return false;
+	for (const entry of Object.values(models)) {
+		const alias = readUnknownRecord(entry)?.alias;
+		if (typeof alias === "string" && normalizeExecReviewerAliasRef(alias) === normalizedModelRef) return true;
+	}
+	return false;
+}
+function normalizeExecReviewerAliasRef(modelRef) {
+	const trimmed = modelRef.trim().toLowerCase();
+	const slashIndex = trimmed.indexOf("/");
+	const authProfileIndex = trimmed.indexOf("@", slashIndex + 1);
+	return authProfileIndex > 0 ? trimmed.slice(0, authProfileIndex) : trimmed;
+}
+function resolveAgentExecConfig(configRoot, agentId) {
+	const normalizedAgentId = agentId ? normalizeAgentId(agentId) : void 0;
+	if (!normalizedAgentId) return;
+	const agentList = readUnknownRecord(configRoot?.agents)?.list;
+	if (!Array.isArray(agentList)) return;
+	for (const entry of agentList) {
+		const record = readUnknownRecord(entry);
+		if (typeof record?.id !== "string" || normalizeAgentId(record.id) !== normalizedAgentId) continue;
+		return readUnknownRecord(readUnknownRecord(record.tools)?.exec);
+	}
+}
+function readUnknownRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 async function runOpenClawToolPolicyForApprovalRequest(params) {
 	const policyRequest = buildOpenClawToolPolicyRequest(params.method, params.requestParams);
 	if (!policyRequest) return;
@@ -2122,6 +2271,8 @@ const CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS = CODEX_NATIVE_HO
 const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 6e4;
 /** Extra relay lifetime after the expected turn budget, preventing late hook drops. */
 const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 6e4;
+const CODEX_NATIVE_HOOK_RELAY_COMMAND_MIN_PARENT_MARGIN_MS = 250;
+const CODEX_NATIVE_HOOK_RELAY_COMMAND_MAX_PARENT_MARGIN_MS = 1e3;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS = 1e4;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS = 5e3;
 const pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
@@ -2229,8 +2380,8 @@ function buildCodexNativeHookRelayConfig(params) {
 			if (params.clearOmittedEvents) for (const sourcePath of CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS) hookState[`${sourcePath}:${CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[event]}:0:0`] = { enabled: false };
 			continue;
 		}
-		const command = params.relay.commandForEvent(event);
 		const timeout = normalizeHookTimeoutSec(params.hookTimeoutSec);
+		const command = params.relay.commandForEvent(event, { timeoutMs: resolveCodexNativeHookRelayCommandTimeoutMs(timeout) });
 		config[`hooks.${codexEvent}`] = [{ hooks: [{
 			type: "command",
 			command,
@@ -2265,6 +2416,11 @@ function buildCodexNativeHookRelayDisabledConfig() {
 function normalizeHookTimeoutSec(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
 }
+function resolveCodexNativeHookRelayCommandTimeoutMs(hookTimeoutSec) {
+	const parentTimeoutMs = finiteSecondsToTimerSafeMilliseconds(normalizeHookTimeoutSec(hookTimeoutSec)) ?? 5e3;
+	const parentMarginMs = Math.min(CODEX_NATIVE_HOOK_RELAY_COMMAND_MAX_PARENT_MARGIN_MS, Math.max(CODEX_NATIVE_HOOK_RELAY_COMMAND_MIN_PARENT_MARGIN_MS, Math.floor(parentTimeoutMs / 5)));
+	return Math.max(1, parentTimeoutMs - parentMarginMs);
+}
 function codexCommandHookTrustedHash(params) {
 	const identity = {
 		event_name: CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[params.event],

package/dist/notification-correlation-D-MYfJwV.js

@@ -0,0 +1,382 @@
+import { n as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-DJXpBkGf.js";
+import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
+import { a as hasCodexRateLimitSnapshots, c as summarizeCodexAccountRateLimits, u as summarizeCodexRateLimits } from "./provider-Cs6kWhDQ.js";
+//#region extensions/codex/src/command-formatters.ts
+/** Formats the combined `/codex status` probe result. */
+function formatCodexStatus(probes) {
+	const lines = [`Codex app-server: ${probes.models.ok || probes.account.ok || probes.limits.ok || probes.mcps.ok || probes.skills.ok ? "connected" : "unavailable"}`];
+	if (probes.models.ok) lines.push(`Models: ${probes.models.value.models.map((model) => formatCodexDisplayText(model.id)).slice(0, 8).join(", ") || "none"}`);
+	else lines.push(`Models: ${formatCodexDisplayText(probes.models.error)}`);
+	lines.push(`Account: ${probes.account.ok ? formatCodexAccountSummary(probes.account.value) : formatCodexDisplayText(probes.account.error)}`);
+	lines.push(`Rate limits: ${probes.limits.ok ? formatCodexRateLimitSummary(probes.limits.value) : formatCodexDisplayText(probes.limits.error)}`);
+	lines.push(`MCP servers: ${probes.mcps.ok ? summarizeArrayLike(probes.mcps.value) : formatCodexDisplayText(probes.mcps.error)}`);
+	lines.push(`Skills: ${probes.skills.ok ? summarizeCodexSkills(probes.skills.value) : formatCodexDisplayText(probes.skills.error)}`);
+	return lines.join("\n");
+}
+/** Formats Codex model-list results for `/codex models`. */
+function formatModels(result) {
+	if (result.models.length === 0) return "No Codex app-server models returned.";
+	const lines = ["Codex models:", ...result.models.map((model) => `- ${formatCodexDisplayText(model.id)}${model.isDefault ? " (default)" : ""}`)];
+	if (result.truncated) lines.push("- More models available; output truncated.");
+	return lines.join("\n");
+}
+/** Formats Codex thread-list responses with safe resume hints. */
+function formatThreads(response) {
+	const threads = extractArray(response);
+	if (threads.length === 0) return "No Codex threads returned.";
+	return ["Codex threads:", ...threads.slice(0, 10).map((thread) => {
+		const record = isJsonObject(thread) ? thread : {};
+		const id = readString$1(record, "threadId") ?? readString$1(record, "id") ?? "<unknown>";
+		const title = readString$1(record, "title") ?? readString$1(record, "name") ?? readString$1(record, "summary");
+		const details = [
+			readString$1(record, "model"),
+			readString$1(record, "cwd"),
+			readString$1(record, "updatedAt") ?? readString$1(record, "lastUpdatedAt")
+		].filter((value) => Boolean(value));
+		return `- ${formatCodexDisplayText(id)}${title ? ` - ${formatCodexDisplayText(title)}` : ""}${details.length > 0 ? ` (${details.map(formatCodexDisplayText).join(", ")})` : ""}\n  Resume: ${formatCodexResumeHint(id)}`;
+	})].join("\n");
+}
+/** Formats account and rate-limit output for `/codex account`. */
+function formatAccount(account, limits, authOverview) {
+	if (authOverview) return formatAccountAuthOverview(authOverview);
+	const formattedLimits = limits.ok ? formatCodexRateLimitDetails(limits.value) : formatCodexDisplayText(limits.error);
+	const rateLimitBlock = formattedLimits.startsWith("Codex is ") ? formattedLimits : formattedLimits.includes("\n") ? `Rate limits:\n${formattedLimits}` : `Rate limits: ${formattedLimits}`;
+	return [`Account: ${account.ok ? formatCodexAccountSummary(account.value) : formatCodexDisplayText(account.error)}`, rateLimitBlock].join("\n\n");
+}
+function formatAccountAuthOverview(overview) {
+	const lines = [];
+	if (overview.currentLine) lines.push(overview.currentLine, "");
+	if (overview.subscriptionLabel) {
+		lines.push(`Subscription  ${overview.subscriptionLabel}`);
+		if (overview.subscriptionUsage) lines.push(`  ${overview.subscriptionUsage}`);
+		lines.push("");
+	}
+	if (overview.rows.length > 0) {
+		lines.push(overview.orderTitle);
+		for (const [index, row] of overview.rows.entries()) lines.push(`  ${index + 1}. ${row.label}   ${row.kind}   — ${formatAuthRowStatus(row)}`);
+	}
+	while (lines.at(-1) === "") lines.pop();
+	return lines.map(formatCodexAccountLine).join("\n");
+}
+function formatAuthRowStatus(row) {
+	return row.billingNote ? `${row.status} · ${row.billingNote}` : row.status;
+}
+/** Formats Codex Computer Use readiness and plugin/MCP availability. */
+function formatComputerUseStatus(status) {
+	const lines = [`Computer Use: ${status.ready ? "ready" : status.enabled ? "not ready" : "disabled"}`];
+	lines.push(`Plugin: ${formatCodexDisplayText(status.pluginName)} (${computerUsePluginState(status)})`);
+	lines.push(`MCP server: ${formatCodexDisplayText(status.mcpServerName)}${status.mcpServerAvailable ? ` (${status.tools.length} tools)` : " (unavailable)"}`);
+	if (status.marketplaceName) lines.push(`Marketplace: ${formatCodexDisplayText(status.marketplaceName)}`);
+	if (status.tools.length > 0) lines.push(`Tools: ${status.tools.slice(0, 8).map(formatCodexDisplayText).join(", ")}`);
+	lines.push(formatCodexDisplayText(status.message));
+	return lines.join("\n");
+}
+function computerUsePluginState(status) {
+	if (!status.installed) return "not installed";
+	return status.pluginEnabled ? "installed" : "installed, disabled";
+}
+/** Formats generic array-like Codex app-server responses. */
+function formatList(response, label) {
+	const entries = extractArray(response);
+	if (entries.length === 0) return `${label}: none returned.`;
+	return [`${label}:`, ...entries.slice(0, 25).map((entry) => {
+		const record = isJsonObject(entry) ? entry : {};
+		return `- ${formatCodexDisplayText(readString$1(record, "name") ?? readString$1(record, "id") ?? JSON.stringify(entry))}`;
+	})].join("\n");
+}
+/** Formats Codex skills grouped by scope, omitting disabled entries. */
+function formatSkills(response) {
+	const groups = isJsonObject(response) && Array.isArray(response.data) ? response.data : [];
+	if (groups.length === 0) return "Codex skills: none returned.";
+	const lines = ["Codex skills:"];
+	let renderedSkills = 0;
+	let loadErrors = 0;
+	for (const group of groups) {
+		const record = isJsonObject(group) ? group : {};
+		if (Array.isArray(record.errors)) loadErrors += record.errors.length;
+		const skills = Array.isArray(record.skills) ? record.skills : [];
+		if (skills.length === 0) continue;
+		for (const skill of skills) {
+			if (isJsonObject(skill) && skill.enabled === false) continue;
+			lines.push(`- ${formatCodexSkillEntry(skill)}`);
+			renderedSkills += 1;
+		}
+	}
+	if (renderedSkills === 0) {
+		if (loadErrors > 0) return `Codex skills: none returned (${loadErrors} load ${loadErrors === 1 ? "error" : "errors"}).`;
+		return "Codex skills: none returned.";
+	}
+	return lines.join("\n");
+}
+function formatCodexSkillEntry(entry) {
+	return `\`${formatCodexDisplayText(readString$1(isJsonObject(entry) ? entry : {}, "name") ?? "<unknown>")}\``;
+}
+const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
+function formatCodexResumeHint(threadId) {
+	const safe = formatCodexTextForDisplay(threadId);
+	if (!CODEX_RESUME_SAFE_THREAD_ID_PATTERN.test(safe)) return "copy the thread id above and run /codex resume <thread-id>";
+	return `/codex resume ${safe}`;
+}
+/** Escapes Codex-originated text so it is safe to render in chat command output. */
+function formatCodexDisplayText(value) {
+	return escapeCodexChatText(formatCodexTextForDisplay(value));
+}
+function formatCodexAccountSummary(value) {
+	const safe = formatCodexTextForDisplay(summarizeAccount(value));
+	return isLikelyEmailAddress(safe) ? escapeCodexChatTextPreservingAt(safe) : escapeCodexChatText(safe);
+}
+function formatCodexTextForDisplay(value) {
+	return sanitizeCodexTextForDisplay(value).trim() || "<unknown>";
+}
+function sanitizeCodexTextForDisplay(value) {
+	let safe = "";
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		safe += codePoint != null && isUnsafeDisplayCodePoint(codePoint) ? "?" : character;
+	}
+	return safe;
+}
+function escapeCodexChatText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("@", "＠").replaceAll("`", "｀").replaceAll("[", "［").replaceAll("]", "］").replaceAll("(", "（").replaceAll(")", "）").replaceAll("*", "∗").replaceAll("_", "＿").replaceAll("~", "～").replaceAll("|", "｜");
+}
+function escapeCodexChatTextPreservingAt(value) {
+	return escapeCodexChatText(value).replaceAll("＠", "@");
+}
+function formatCodexAccountLine(value) {
+	if (value === "") return "";
+	const safe = sanitizeCodexTextForDisplay(value).trimEnd();
+	if (!safe.trim()) return "";
+	const emailPattern = /[^\s@<>()[\]`]+@[^\s@<>()[\]`]+\.[^\s@<>()[\]`]+/gu;
+	let formatted = "";
+	let lastIndex = 0;
+	for (const match of safe.matchAll(emailPattern)) {
+		const index = match.index ?? 0;
+		formatted += escapeCodexChatText(safe.slice(lastIndex, index));
+		formatted += escapeCodexChatTextPreservingAt(match[0]);
+		lastIndex = index + match[0].length;
+	}
+	formatted += escapeCodexChatText(safe.slice(lastIndex));
+	return formatted;
+}
+function isLikelyEmailAddress(value) {
+	return /^[^\s@<>()[\]`]+@[^\s@<>()[\]`]+\.[^\s@<>()[\]`]+$/.test(value);
+}
+function isUnsafeDisplayCodePoint(codePoint) {
+	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 173 || codePoint === 1564 || codePoint === 6158 || codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303 || codePoint === 65279 || codePoint >= 65529 && codePoint <= 65531 || codePoint >= 917504 && codePoint <= 917631;
+}
+/** Builds the portable `/codex` command help text. */
+function buildHelp() {
+	return [
+		"Codex commands:",
+		"- /codex status",
+		"- /codex models",
+		"- /codex threads [filter]",
+		"- /codex sessions --host <node> [filter]",
+		"- /codex resume <thread-id>",
+		"- /codex resume <session-id> --host <node> --bind here",
+		"- /codex bind [thread-id] [--cwd <path>] [--model <model>] [--provider <provider>]",
+		"- /codex binding",
+		"- /codex stop",
+		"- /codex steer <message>",
+		"- /codex model [model]",
+		"- /codex fast [on|off|status]",
+		"- /codex permissions [default|yolo|status]",
+		"- /codex detach",
+		"- /codex compact",
+		"- /codex review",
+		"- /codex diagnostics [note]",
+		"- /codex computer-use [status|install]",
+		"- /codex account",
+		"- /codex mcp",
+		"- /codex skills",
+		"- /codex plugins [list|enable|disable]"
+	].join("\n");
+}
+function summarizeAccount(value) {
+	if (!isJsonObject(value)) return "unavailable";
+	const account = isJsonObject(value.account) ? value.account : value;
+	if (readString$1(account, "type") === "amazonBedrock") return "Amazon Bedrock";
+	return readString$1(account, "email") ?? readString$1(account, "accountEmail") ?? readString$1(account, "planType") ?? readString$1(account, "id") ?? "available";
+}
+function summarizeArrayLike(value) {
+	const entries = extractArray(value);
+	if (entries.length === 0) return "none returned";
+	return `${entries.length}`;
+}
+function summarizeCodexSkills(value) {
+	const groups = isJsonObject(value) && Array.isArray(value.data) ? value.data : [];
+	if (groups.length === 0) return "none returned";
+	let enabledSkills = 0;
+	let loadErrors = 0;
+	for (const group of groups) {
+		if (!isJsonObject(group)) continue;
+		if (Array.isArray(group.errors)) loadErrors += group.errors.length;
+		if (!Array.isArray(group.skills)) continue;
+		enabledSkills += group.skills.filter((skill) => !isJsonObject(skill) || skill.enabled !== false).length;
+	}
+	if (enabledSkills > 0) return `${enabledSkills}`;
+	if (loadErrors > 0) return `none returned (${loadErrors} load ${loadErrors === 1 ? "error" : "errors"})`;
+	return "none returned";
+}
+function formatCodexRateLimitSummary(value) {
+	const summary = summarizeCodexRateLimits(value);
+	if (summary) return formatCodexDisplayText(summary);
+	return formatCodexDisplayText(hasCodexRateLimitSnapshots(value) ? "none returned" : summarizeRateLimits(value));
+}
+function formatCodexRateLimitDetails(value) {
+	const lines = summarizeCodexAccountRateLimits(value);
+	if (!lines) return formatCodexDisplayText(hasCodexRateLimitSnapshots(value) ? "none returned" : summarizeRateLimits(value));
+	return lines.map(formatCodexDisplayText).join("\n");
+}
+function summarizeRateLimits(value) {
+	const entries = extractArray(value);
+	if (entries.length > 0) {
+		const count = entries.filter(isMeaningfulRateLimitSnapshot).length;
+		return count > 0 ? `${count}` : "none returned";
+	}
+	if (!isJsonObject(value)) return "none returned";
+	const keyed = value.rateLimitsByLimitId;
+	if (isJsonObject(keyed)) {
+		const count = Object.values(keyed).filter(isMeaningfulRateLimitSnapshot).length;
+		if (count > 0) return `${count}`;
+	}
+	return isMeaningfulRateLimitSnapshot(value.rateLimits) ? "1" : "none returned";
+}
+function isMeaningfulRateLimitSnapshot(value) {
+	if (!isJsonObject(value)) return false;
+	if (readString$1(value, "rateLimitReachedType") ?? readString$1(value, "rate_limit_reached_type")) return true;
+	return ["primary", "secondary"].some((key) => {
+		const window = value[key];
+		return isJsonObject(window) && Object.values(window).some((entry) => entry != null);
+	});
+}
+function extractArray(value) {
+	if (Array.isArray(value)) return value;
+	if (!isJsonObject(value)) return [];
+	for (const key of [
+		"data",
+		"items",
+		"threads",
+		"models",
+		"skills",
+		"servers",
+		"rateLimits"
+	]) {
+		const child = value[key];
+		if (Array.isArray(child)) return child;
+	}
+	return [];
+}
+/** Reads and trims a non-empty string field from a JSON object. */
+function readString$1(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/app-server-policy.ts
+/**
+* Policy promotion for Codex app-server runs that can safely use OpenClaw tool
+* approvals.
+*/
+/**
+* Promotes implicit `never` approval policy to `untrusted` only when runtime
+* requirements allow OpenClaw to handle tool approvals.
+*/
+function resolveCodexAppServerForOpenClawToolPolicy(params) {
+	if (!params.shouldPromote || !params.canUseUntrustedApprovalPolicy || params.appServer.approvalPolicy !== "never") return params.appServer;
+	const explicitMode = params.execPolicy?.mode === "full" || params.pluginConfig.appServer?.mode !== void 0 || isCodexAppServerPolicyMode(params.env.OPENCLAW_CODEX_APP_SERVER_MODE);
+	const explicitApprovalPolicy = params.pluginConfig.appServer?.approvalPolicy !== void 0 || isCodexAppServerApprovalPolicy(params.env.OPENCLAW_CODEX_APP_SERVER_APPROVAL_POLICY) || params.appServer.approvalPolicySource === "requirements";
+	if (explicitMode || explicitApprovalPolicy) return params.appServer;
+	return {
+		...params.appServer,
+		approvalPolicy: "untrusted"
+	};
+}
+function resolveCodexAppServerForModelProvider(params) {
+	const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);
+	if (!isCodexModelBackedApprovalsReviewer(params.appServer.approvalsReviewer) || canUseCodexModelBackedApprovalsReviewerForModel({
+		modelProvider: explicitProvider,
+		model: params.model,
+		config: params.config,
+		env: params.env,
+		agentDir: params.agentDir,
+		codexConfigToml: params.codexConfigToml
+	})) return params.appServer;
+	return {
+		...params.appServer,
+		approvalsReviewer: "user"
+	};
+}
+function isCodexAppServerPolicyMode(value) {
+	return value === "guardian" || value === "yolo";
+}
+function isCodexAppServerApprovalPolicy(value) {
+	return value === "never" || value === "on-request" || value === "on-failure" || value === "untrusted";
+}
+function isCodexModelBackedApprovalsReviewer(value) {
+	return value === "auto_review" || value === "guardian_subagent";
+}
+function normalizeModelBackedReviewerProvider(provider) {
+	return provider?.trim().toLowerCase() || void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/notification-correlation.ts
+/**
+* Correlates Codex app-server notifications with the active thread/turn so
+* projectors can ignore global or stale events without losing diagnostics.
+*/
+/** Returns true when a notification payload belongs to the exact active thread and turn. */
+function isCodexNotificationForTurn(value, threadId, turnId) {
+	if (!isJsonObject(value)) return false;
+	return readCodexNotificationThreadId(value) === threadId && readCodexNotificationTurnId(value) === turnId;
+}
+/** Reads a thread id from either top-level notification params or nested turn payloads. */
+function readCodexNotificationThreadId(record) {
+	return readNestedTurnThreadId(record) ?? readString(record, "threadId");
+}
+/** Reads a turn id from either top-level notification params or nested turn payloads. */
+function readCodexNotificationTurnId(record) {
+	return readNestedTurnId(record) ?? readString(record, "turnId");
+}
+/** Builds structured correlation details for logs when notification routing is ambiguous. */
+function describeCodexNotificationCorrelation(notification, active) {
+	const params = isJsonObject(notification.params) ? notification.params : void 0;
+	const turn = params && isJsonObject(params.turn) ? params.turn : void 0;
+	const threadId = params ? readString(params, "threadId") : void 0;
+	const turnId = params ? readString(params, "turnId") : void 0;
+	const nestedTurnThreadId = turn ? readString(turn, "threadId") : void 0;
+	const nestedTurnId = turn ? readString(turn, "id") : void 0;
+	const resolvedThreadId = params ? readCodexNotificationThreadId(params) : void 0;
+	const resolvedTurnId = params ? readCodexNotificationTurnId(params) : void 0;
+	const matchesActiveThread = resolvedThreadId === active.threadId;
+	const matchesActiveTurn = active.turnId ? matchesActiveThread && resolvedTurnId === active.turnId : void 0;
+	const items = turn?.items;
+	return {
+		method: notification.method,
+		...params ? { paramsKeys: Object.keys(params).toSorted() } : {},
+		activeThreadId: active.threadId,
+		...active.turnId ? { activeTurnId: active.turnId } : {},
+		...threadId ? { threadId } : {},
+		...turnId ? { turnId } : {},
+		...nestedTurnThreadId ? { nestedTurnThreadId } : {},
+		...nestedTurnId ? { nestedTurnId } : {},
+		...turn ? { turnStatus: readString(turn, "status") } : {},
+		...Array.isArray(items) ? { turnItemCount: items.length } : {},
+		matchesActiveThread,
+		...matchesActiveTurn === void 0 ? {} : { matchesActiveTurn }
+	};
+}
+function readNestedTurnId(record) {
+	const turn = record.turn;
+	return isJsonObject(turn) ? readString(turn, "id") : void 0;
+}
+function readNestedTurnThreadId(record) {
+	const turn = record.turn;
+	return isJsonObject(turn) ? readString(turn, "threadId") : void 0;
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+//#endregion
+export { resolveCodexAppServerForModelProvider as a, formatAccount as c, formatComputerUseStatus as d, formatList as f, readString$1 as g, formatThreads as h, readCodexNotificationTurnId as i, formatCodexDisplayText as l, formatSkills as m, isCodexNotificationForTurn as n, resolveCodexAppServerForOpenClawToolPolicy as o, formatModels as p, readCodexNotificationThreadId as r, buildHelp as s, describeCodexNotificationCorrelation as t, formatCodexStatus as u };

package/dist/{request-D64BfplD.js → plugin-app-cache-key-NpzxEcSR.js}

@@ -1,7 +1,6 @@
-import { n as CodexAppServerRpcError } from "./client-kMCtlApt.js";
-import { b as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-BJsazZ8j.js";
-import { a as getLeasedSharedCodexAppServerClient, h as resolveCodexAppServerHomeDir, i as createIsolatedCodexAppServerClient, l as withTimeout, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-xytpSKD0.js";
-import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-C-Yv9uwY.js";
+import { n as CodexAppServerRpcError } from "./client-DovmVtbr.js";
+import { S as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-Cq1-IfZB.js";
+import { h as resolveCodexAppServerHomeDir } from "./shared-client-CflavQ_i.js";
 import { createHash } from "node:crypto";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
@@ -77,35 +76,4 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-//#region extensions/codex/src/app-server/request.ts
-async function requestCodexAppServerJson(params) {
-	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-		method: params.method,
-		requestParams: params.requestParams,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId
-	});
-	if (sandboxBlock) throw new Error(sandboxBlock);
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	return await withTimeout((async () => {
-		const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
-			startOptions: params.startOptions,
-			timeoutMs,
-			authProfileId: params.authProfileId,
-			agentDir: params.agentDir,
-			config: params.config
-		});
-		try {
-			return await client.request(params.method, params.requestParams, { timeoutMs });
-		} finally {
-			if (params.isolated) await client.closeAndWait({
-				exitTimeoutMs: 2e3,
-				forceKillDelayMs: 250
-			});
-			else releaseLeasedSharedCodexAppServerClient(client);
-		}
-	})(), timeoutMs, `codex app-server ${params.method} timed out`);
-}
-//#endregion
-export { describeControlFailure as i, buildCodexPluginAppCacheKey as n, CODEX_CONTROL_METHODS as r, requestCodexAppServerJson as t };
+export { CODEX_CONTROL_METHODS as n, describeControlFailure as r, buildCodexPluginAppCacheKey as t };

package/dist/protocol-oeJQu4rs.js

@@ -0,0 +1,9 @@
+//#region extensions/codex/src/app-server/protocol.ts
+function isJsonObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isRpcResponse(message) {
+	return "id" in message && !("method" in message);
+}
+//#endregion
+export { isRpcResponse as n, isJsonObject as t };