@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/README.md

@@ -28,6 +28,8 @@ Disabling or uninstalling the plugin leaves supervised Chats locked and unavaila
 
 These shell commands differ from the in-chat `/codex` runtime commands. In particular, `/codex sessions --host <node>` lists Codex CLI session files on one node, `/codex threads` uses the current conversation's App Server connection, and `/codex resume` or `/codex bind` changes that conversation's binding. There is no `/codex archive` runtime command.
 
+Native Codex plugin catalogs are discoverable with `/codex plugins available`, including repository marketplaces declared in `.agents/plugins/marketplace.json` in the bound workspace. An owner or `operator.admin` can install and authorize an exact plugin with `/codex plugins install <plugin>@<marketplace>`. The owner-scoped `codex_plugins` agent tool only reads marketplace metadata; installation and policy changes stay on authenticated `/codex` management commands. Explicitly installing a plugin trusts its skills, apps, MCP servers, and hooks.
+
 For a supervised branch, Codex App Server selects the snapshot fork's model and provider from its current native configuration. OpenClaw starts the canonical harness thread with exactly that returned pair. Codex persists the canonical thread's native selection, and later resumes preserve it because OpenClaw omits model and provider overrides. OpenClaw cannot substitute its outer runtime, model, or fallback. The returned initial pair can differ from the source's last recorded model.
 
 The visible-history mirror keeps at most 200 user or assistant messages, 512 KiB total, and 64 KiB per message. Image inputs become `[Image attachment]`; image data and local paths are not copied.

package/dist/api.js

@@ -0,0 +1,147 @@
+import { a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions } from "./config-CpNeo5AE.js";
+import { a as CODEX_APP_SERVER_VERSION, n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-By4FZC6i.js";
+import path from "node:path";
+import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { listAgentIds as listAgentIds$1, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolveEffectiveAgentRuntime } from "openclaw/plugin-sdk/command-auth-native";
+import { getHealthCheck } from "openclaw/plugin-sdk/health";
+//#region extensions/codex/src/doctor.ts
+const CODEX_MANAGED_APP_SERVER_CHECK_ID = "codex/managed-app-server";
+const CODEX_VERSION_TIMEOUT_MS = 5e3;
+const CODEX_VERSION_MAX_BUFFER_BYTES = 64 * 1024;
+function managedCodexFinding(params) {
+	return {
+		checkId: CODEX_MANAGED_APP_SERVER_CHECK_ID,
+		severity: "error",
+		source: "codex",
+		message: params.message,
+		...params.path ? { path: params.path } : {},
+		...params.requirement ? { requirement: params.requirement } : {},
+		...params.fixHint ? { fixHint: params.fixHint } : {}
+	};
+}
+function readErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function parseCodexVersion(output) {
+	return /(?:^|\s)(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output)?.[1];
+}
+function runVersionCommand(command) {
+	return new Promise((resolve, reject) => {
+		execFile(command, ["--version"], {
+			encoding: "utf8",
+			maxBuffer: CODEX_VERSION_MAX_BUFFER_BYTES,
+			timeout: CODEX_VERSION_TIMEOUT_MS,
+			windowsHide: true
+		}, (error, stdout, stderr) => {
+			if (error) {
+				reject(new Error(readErrorMessage(error), { cause: error }));
+				return;
+			}
+			resolve({
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+function createCodexManagedAppServerHealthCheck(params) {
+	const resolveStartOptions = params.deps?.resolveStartOptions ?? resolveManagedCodexAppServerStartOptions;
+	const resolveAgentStartOptions = params.deps?.resolveAgentStartOptions ?? resolveCodexAppServerStartOptionsForAgent;
+	const isDesktopCommand = params.deps?.isDesktopCommand ?? isManagedCodexDesktopCommand;
+	const resolveNativeCommand = params.deps?.resolveNativeCommand ?? resolveManagedCodexNativeCommand;
+	const executeVersion = params.deps?.runVersionCommand ?? runVersionCommand;
+	return {
+		id: CODEX_MANAGED_APP_SERVER_CHECK_ID,
+		kind: "plugin",
+		description: "Verify the selected managed Codex app-server binary and pinned version.",
+		source: "codex",
+		defaultEnabled: false,
+		async detect(ctx) {
+			const pluginConfig = ctx.cfg.plugins?.entries?.codex?.config;
+			const start = resolveCodexAppServerRuntimeOptions({
+				pluginConfig,
+				env: ctx.env ?? process.env
+			}).start;
+			if (start.transport !== "stdio" || start.commandSource !== "managed") return [];
+			const env = ctx.env ?? process.env;
+			let resolved;
+			for (const agentId of listAgentIds$1(ctx.cfg)) {
+				const model = resolveDefaultModelForAgent({
+					cfg: ctx.cfg,
+					agentId
+				});
+				if (resolveEffectiveAgentRuntime({
+					cfg: ctx.cfg,
+					provider: model.provider,
+					modelId: model.model,
+					agentId
+				}) !== "codex") continue;
+				const agentStart = resolveAgentStartOptions({
+					startOptions: start,
+					agentDir: resolveAgentDir$1(ctx.cfg, agentId, env),
+					env
+				});
+				try {
+					resolved = await resolveStartOptions(agentStart, { pluginRoot: params.pluginRoot });
+				} catch (error) {
+					return [managedCodexFinding({
+						message: `Managed Codex app-server could not be resolved: ${readErrorMessage(error)}`,
+						path: params.pluginRoot,
+						requirement: `an executable Codex ${CODEX_APP_SERVER_VERSION} managed artifact`,
+						fixHint: "Reinstall the staged OpenClaw package with its @openai/codex platform dependency, then rerun the candidate check."
+					})];
+				}
+				if (!isDesktopCommand(resolved.command)) break;
+				resolved = void 0;
+			}
+			if (!resolved) return [];
+			const nativeCommand = resolveNativeCommand(resolved.command);
+			if (!nativeCommand) return [managedCodexFinding({
+				message: "Managed Codex app-server resolved a launcher without a native artifact.",
+				path: resolved.command,
+				requirement: `the platform-native Codex ${CODEX_APP_SERVER_VERSION} executable`,
+				fixHint: "Reinstall the staged OpenClaw package with the matching @openai/codex platform package, then rerun the candidate check."
+			})];
+			let output;
+			try {
+				output = await executeVersion(nativeCommand);
+			} catch (error) {
+				return [managedCodexFinding({
+					message: `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
+					path: nativeCommand,
+					requirement: `Codex ${CODEX_APP_SERVER_VERSION} must report its version within ${CODEX_VERSION_TIMEOUT_MS} ms`,
+					fixHint: "Repair or reinstall the staged OpenClaw package, then rerun the candidate check before cutover."
+				})];
+			}
+			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
+			if (detectedVersion !== "0.149.1") return [managedCodexFinding({
+				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
+				path: nativeCommand,
+				requirement: `the exact OpenClaw-pinned Codex version ${CODEX_APP_SERVER_VERSION}`,
+				fixHint: "Reinstall the staged OpenClaw package so its managed @openai/codex dependency matches the pinned version, then rerun the candidate check."
+			})];
+			return [];
+		}
+	};
+}
+function registerCodexManagedAppServerDoctorChecks$1(host, deps) {
+	if (getHealthCheck("codex/managed-app-server")) return;
+	host.registerHealthCheck(createCodexManagedAppServerHealthCheck({
+		pluginRoot: host.pluginRoot,
+		deps
+	}));
+}
+//#endregion
+//#region extensions/codex/api.ts
+const CODEX_PLUGIN_ROOT = path.dirname(fileURLToPath(import.meta.url));
+function registerCodexManagedAppServerDoctorChecks(host) {
+	registerCodexManagedAppServerDoctorChecks$1({
+		...host,
+		pluginRoot: CODEX_PLUGIN_ROOT
+	});
+}
+//#endregion
+export { CODEX_MANAGED_APP_SERVER_CHECK_ID, registerCodexManagedAppServerDoctorChecks };

package/dist/app-server-policy-bg5QPSVP.js

@@ -0,0 +1,25 @@
+import { b as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CpNeo5AE.js";
+//#region extensions/codex/src/app-server/app-server-policy.ts
+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 isCodexModelBackedApprovalsReviewer(value) {
+	return value === "auto_review" || value === "guardian_subagent";
+}
+function normalizeModelBackedReviewerProvider(provider) {
+	return provider?.trim().toLowerCase() || void 0;
+}
+//#endregion
+export { resolveCodexAppServerForModelProvider as t };