@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{source-Bjp4UQij.mjs → source-CS_7GFJZ.mjs}

@@ -1,19 +1,17 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { c as CODEX_PLUGINS_MARKETPLACE_NAME, i as pluginReadParams, n as isOpenAiCuratedMarketplace } from "./plugin-inventory-DUle8DLz.mjs";
-import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { o as withCodexAppServerJsonClient } from "./request-BioXJLYa.mjs";
-import "./config-CedDWjM-.mjs";
+import { a as marketplaceRef, n as isOpenAiCuratedMarketplace, o as pluginReadParams, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-Cky2XJUw.mjs";
+import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BL9B5H0L.mjs";
+import { o as withCodexAppServerJsonClient } from "./request-BHZ1nz8d.mjs";
+import "./config-DKhXquav.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { asNonArrayRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import os from "node:os";
 import fs from "node:fs/promises";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { pathExists } from "openclaw/plugin-sdk/security-runtime";
-import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
+import { tryReadJson } from "@openclaw/fs-safe/json";
 //#region extensions/codex/src/migration/helpers.ts
-async function exists(filePath) {
-	return await pathExists(filePath);
-}
 async function isDirectory(filePath) {
 	if (!filePath) return false;
 	try {
@@ -34,60 +32,48 @@ function sanitizeName(value) {
 	return value.trim().toLowerCase().replaceAll(/[^a-z0-9._-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, 64);
 }
 async function readJsonObject(filePath) {
-	if (!filePath) return {};
-	const { value: parsed } = await readJsonFileWithFallback(filePath, {});
-	return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	return asNonArrayRecord(filePath ? await tryReadJson(filePath) : null);
 }
 //#endregion
 //#region extensions/codex/src/migration/source-files.ts
 const SKILL_FILENAME = "SKILL.md";
 const MAX_SCAN_DEPTH = 6;
 const MAX_DISCOVERED_DIRS = 2e3;
-async function safeReadDir(dir) {
-	return await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-}
-async function discoverSkillDirs(params) {
+async function discoverSourceDirs(params, readSource) {
 	if (!params.root || !await isDirectory(params.root)) return [];
 	const discovered = [];
 	async function visit(dir, depth) {
 		if (discovered.length >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) return;
-		const name = path.basename(dir);
-		if (params.excludeSystem && depth === 1 && name === ".system") return;
-		if (await exists(path.join(dir, SKILL_FILENAME))) {
-			discovered.push({
-				name,
-				source: dir,
-				sourceLabel: params.sourceLabel
-			});
+		if (params.excludeSystem && depth === 1 && path.basename(dir) === ".system") return;
+		const source = await readSource(dir);
+		if (source !== void 0) {
+			discovered.push(source);
 			return;
 		}
-		for (const entry of await safeReadDir(dir)) if (entry.isDirectory()) await visit(path.join(dir, entry.name), depth + 1);
+		for (const entry of await fs.readdir(dir, { withFileTypes: true }).catch(() => [])) if (entry.isDirectory()) await visit(path.join(dir, entry.name), depth + 1);
 	}
 	await visit(params.root, 0);
 	return discovered;
 }
+async function discoverSkillDirs(params) {
+	return discoverSourceDirs(params, async (dir) => await pathExists(path.join(dir, SKILL_FILENAME)) ? {
+		name: path.basename(dir),
+		source: dir,
+		sourceLabel: params.sourceLabel
+	} : void 0);
+}
 async function discoverPluginDirs(codexHome) {
-	const root = path.join(codexHome, "plugins", "cache");
-	if (!await isDirectory(root)) return [];
-	const discovered = /* @__PURE__ */ new Map();
-	async function visit(dir, depth) {
-		if (discovered.size >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) return;
+	return (await discoverSourceDirs({ root: path.join(codexHome, "plugins", "cache") }, async (dir) => {
 		const manifestPath = path.join(dir, ".codex-plugin", "plugin.json");
-		if (await exists(manifestPath)) {
-			const manifest = await readJsonObject(manifestPath);
-			const manifestName = typeof manifest.name === "string" ? manifest.name.trim() : "";
-			discovered.set(dir, {
-				name: manifestName || path.basename(dir),
-				source: dir,
-				migratable: false,
-				message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory"
-			});
-			return;
-		}
-		for (const entry of await safeReadDir(dir)) if (entry.isDirectory()) await visit(path.join(dir, entry.name), depth + 1);
-	}
-	await visit(root, 0);
-	return [...discovered.values()].toSorted((a, b) => a.source.localeCompare(b.source));
+		if (!await pathExists(manifestPath)) return;
+		const manifest = await readJsonObject(manifestPath);
+		return {
+			name: (typeof manifest.name === "string" ? manifest.name.trim() : "") || path.basename(dir),
+			source: dir,
+			migratable: false,
+			message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory"
+		};
+	})).toSorted((a, b) => a.source.localeCompare(b.source));
 }
 async function discoverCodexMemoryFile(candidate) {
 	try {
@@ -186,19 +172,6 @@ function sourceCodexAppServerStartOptions(codexHome) {
 		}
 	};
 }
-function buildInstalledPluginSource(plugin) {
-	const pluginName = pluginNameFromSummary(plugin);
-	if (!pluginName) return;
-	return {
-		name: plugin.name,
-		pluginName,
-		marketplaceName: CODEX_PLUGINS_MARKETPLACE_NAME,
-		source: `${CODEX_PLUGINS_MARKETPLACE_NAME}/${pluginName}`,
-		migratable: true,
-		installed: plugin.installed,
-		enabled: plugin.enabled
-	};
-}
 function discoverInstalledCuratedPluginSources(response) {
 	const installedByName = /* @__PURE__ */ new Map();
 	for (const marketplace of response.marketplaces) {
@@ -206,27 +179,28 @@ function discoverInstalledCuratedPluginSources(response) {
 		const remote = !marketplace.path;
 		for (const summary of marketplace.plugins) {
 			if (!summary.installed) continue;
-			const plugin = buildInstalledPluginSource(summary);
-			if (!plugin?.pluginName) continue;
-			const existing = installedByName.get(plugin.pluginName);
+			const pluginName = pluginNameFromSummary(summary);
+			if (!pluginName) continue;
+			const existing = installedByName.get(pluginName);
 			if (existing && (!remote || existing.remote)) continue;
-			installedByName.set(plugin.pluginName, {
-				plugin,
-				marketplace: marketplaceRef(marketplace),
-				...remote ? { readPluginName: summary.remotePluginId?.trim() || void 0 } : { readPluginName: plugin.pluginName },
+			installedByName.set(pluginName, {
+				plugin: {
+					name: summary.name,
+					pluginName,
+					marketplaceName: CODEX_PLUGINS_MARKETPLACE_NAME,
+					source: `${CODEX_PLUGINS_MARKETPLACE_NAME}/${pluginName}`,
+					migratable: true,
+					installed: summary.installed,
+					enabled: summary.enabled
+				},
+				marketplace: marketplaceRef(marketplace, CODEX_PLUGINS_MARKETPLACE_NAME),
+				...remote ? { readPluginName: summary.remotePluginId?.trim() || void 0 } : { readPluginName: pluginName },
 				remote
 			});
 		}
 	}
 	return Array.from(installedByName.values());
 }
-function marketplaceRef(marketplace) {
-	return {
-		name: CODEX_PLUGINS_MARKETPLACE_NAME,
-		...marketplace.path ? { path: marketplace.path } : {},
-		...!marketplace.path ? { remoteMarketplaceName: marketplace.name } : {}
-	};
-}
 async function withPluginMigrationEligibility(params) {
 	const pending = [];
 	const evaluated = [];
@@ -260,7 +234,10 @@ async function withPluginMigrationEligibility(params) {
 			});
 			continue;
 		}
-		const apps = detail.detail.apps.map(sourcePluginAppFact).toSorted((left, right) => left.id.localeCompare(right.id));
+		const apps = detail.detail.apps.map(({ id, name }) => ({
+			id,
+			name
+		})).toSorted((left, right) => left.id.localeCompare(right.id));
 		pending.push({
 			plugin,
 			apps
@@ -275,53 +252,30 @@ async function withPluginMigrationEligibility(params) {
 	} catch (error) {
 		sourceAccountError = coerceErrorMessage(error);
 	}
-	if (sourceAccountError && !params.verifyPluginApps) {
-		for (const { plugin, apps } of pending) evaluated.push({
-			...plugin,
-			migratable: false,
-			migrationBlock: {
-				code: "codex_account_unavailable",
-				apps,
-				error: sourceAccountError
-			},
-			message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but the source Codex app-server account could not be read: ${sourceAccountError}`
-		});
-		return evaluated;
-	}
-	if (sourceAccount === "non_chatgpt") {
-		for (const { plugin, apps } of pending) evaluated.push({
-			...plugin,
-			migratable: false,
-			migrationBlock: {
-				code: "codex_subscription_required",
-				apps
-			},
-			message: codexSubscriptionRequiredMessage(plugin)
-		});
-		return evaluated;
-	}
-	if (!params.verifyPluginApps) {
-		for (const { plugin, apps } of pending) evaluated.push({
-			...plugin,
+	const unavailable = (code, reason, error) => evaluated.concat(pending.map(({ plugin, apps }) => ({
+		...plugin,
+		migratable: false,
+		migrationBlock: {
+			code,
 			apps,
-			migratable: true
-		});
-		return evaluated;
-	}
-	const snapshot = await refreshSourceAppInventory(params.requestOptions).catch((error) => {
+			...error !== void 0 ? { error } : {}
+		},
+		message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but ${reason}`
+	})));
+	if (sourceAccountError && !params.verifyPluginApps) return unavailable("codex_account_unavailable", `the source Codex app-server account could not be read: ${sourceAccountError}`, sourceAccountError);
+	if (sourceAccount === "non_chatgpt") return unavailable("codex_subscription_required", codexPluginMigrationSubscriptionWarning());
+	if (!params.verifyPluginApps) return evaluated.concat(pending.map(({ plugin, apps }) => ({
+		...plugin,
+		apps,
+		migratable: true
+	})));
+	let snapshot;
+	try {
+		snapshot = await refreshSourceAppInventory(params.requestOptions);
+	} catch (error) {
 		const message = coerceErrorMessage(error);
-		for (const { plugin, apps } of pending) evaluated.push({
-			...plugin,
-			migratable: false,
-			migrationBlock: {
-				code: "app_inventory_unavailable",
-				apps,
-				error: message
-			},
-			message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but source app inventory could not be read: ${message}`
-		});
-	});
-	if (!snapshot) return evaluated;
+		return unavailable("app_inventory_unavailable", `source app inventory could not be read: ${message}`, message);
+	}
 	const appInfoById = new Map(snapshot.apps.map((app) => [app.id, app]));
 	const installedAppsById = new Map(snapshot.installedApps.map((app) => [app.id, app]));
 	for (const { plugin, apps: declaredApps } of pending) {
@@ -348,12 +302,10 @@ async function withPluginMigrationEligibility(params) {
 	return evaluated;
 }
 async function readSourceCodexAccount(options) {
-	const response = await options.request({
+	switch ((await options.request({
 		method: "account/read",
 		requestParams: { refreshToken: false }
-	});
-	if (!response.account || typeof response.account !== "object" || Array.isArray(response.account)) return "missing";
-	switch (response.account.type) {
+	})).account?.type) {
 		case "chatgpt": return "chatgpt";
 		case "apiKey":
 		case "amazonBedrock": return "non_chatgpt";
@@ -392,12 +344,6 @@ async function refreshSourceAppInventory(options) {
 		forceRefetch: true
 	});
 }
-function sourcePluginAppFact(app) {
-	return {
-		id: app.id,
-		name: app.name
-	};
-}
 function sourcePluginAppFactWithInventory(app, info, installedApp) {
 	if (!installedApp) return app;
 	if (!info) return installedApp.enabled ? {
@@ -410,13 +356,13 @@ function sourcePluginAppFactWithInventory(app, info, installedApp) {
 	};
 	if (!installedApp.enabled) return {
 		...app,
-		isAccessible: info.isAccessible,
+		isAccessible: true,
 		isEnabled: false
 	};
 	return {
 		...app,
-		isAccessible: info.isAccessible && installedApp.callable,
-		isEnabled: info.isEnabled,
+		isAccessible: installedApp.callable,
+		isEnabled: installedApp.enabled,
 		...!installedApp.callable ? { isCallable: false } : {}
 	};
 }
@@ -434,9 +380,6 @@ function appInventoryBlockMessage(plugin, apps, code) {
 function codexPluginMigrationSubscriptionWarning() {
 	return "Codex app-backed plugin migration requires the Codex app-server source account to be logged in with a ChatGPT subscription account. Log in to the Codex app with subscription auth; OpenClaw auth or API-key auth does not satisfy Codex app connector access.";
 }
-function codexSubscriptionRequiredMessage(plugin) {
-	return `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but ${codexPluginMigrationSubscriptionWarning()}`;
-}
 function pluginNameFromSummary(summary) {
 	const candidates = [summary.name, summary.id];
 	for (const candidate of candidates) {
@@ -478,20 +421,20 @@ async function discoverCodexSource(options = {}) {
 	});
 	const plugins = [...sourcePluginDiscovery.plugins, ...cachedPlugins].toSorted((a, b) => a.source.localeCompare(b.source));
 	const archivePaths = [];
-	if (!skipAssets && await exists(configPath)) archivePaths.push({
+	if (!skipAssets && await pathExists(configPath)) archivePaths.push({
 		id: "archive:config.toml",
 		path: configPath,
 		relativePath: "config.toml",
 		message: "Codex config is archived for manual review; it is not activated automatically"
 	});
-	if (!skipAssets && await exists(hooksPath)) archivePaths.push({
+	if (!skipAssets && await pathExists(hooksPath)) archivePaths.push({
 		id: "archive:hooks/hooks.json",
 		path: hooksPath,
 		relativePath: "hooks/hooks.json",
 		message: "Codex native hooks are archived for manual review because they can execute commands"
 	});
 	const skills = [...codexSkills, ...personalAgentSkills].toSorted((a, b) => a.source.localeCompare(b.source));
-	const hasAuth = !options.memoryOnly && await exists(authPath);
+	const hasAuth = !options.memoryOnly && await pathExists(authPath);
 	const high = Boolean(memoryFiles.length || codexSkills.length || plugins.length || archivePaths.length || hasAuth);
 	const medium = personalAgentSkills.length > 0;
 	return {
@@ -501,7 +444,7 @@ async function discoverCodexSource(options = {}) {
 		...await isDirectory(codexSkillsDir) ? { codexSkillsDir } : {},
 		...await isDirectory(agentsSkillsDir) ? { personalAgentsSkillsDir: agentsSkillsDir } : {},
 		...hasAuth ? { authPath } : {},
-		...await exists(modelsCachePath) ? { modelsCachePath } : {},
+		...await pathExists(modelsCachePath) ? { modelsCachePath } : {},
 		memoryFiles,
 		skills,
 		plugins,
@@ -516,4 +459,4 @@ function sanitizePluginName(value) {
 	return value.trim().toLowerCase().replaceAll(/\s+/gu, "-");
 }
 //#endregion
-export { source_exports as a, resolveHomePath as c, hasCodexSource as i, sanitizeName as l, defaultCodexHome as n, exists as o, discoverCodexSource as r, readJsonObject as s, codexPluginMigrationSubscriptionWarning as t };
+export { source_exports as a, hasCodexSource as i, defaultCodexHome as n, readJsonObject as o, discoverCodexSource as r, sanitizeName as s, codexPluginMigrationSubscriptionWarning as t };

package/dist/.setup/spawn-error-CL3n6MAa.mjs

@@ -0,0 +1,57 @@
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+//#region extensions/codex/src/app-server/spawn-error.ts
+const failures = resolveGlobalSingleton(Symbol.for("openclaw.codexSpawnFailures"), () => ({
+	commands: /* @__PURE__ */ new Map(),
+	errors: /* @__PURE__ */ new WeakMap(),
+	reported: /* @__PURE__ */ new Set()
+}));
+/** Also accepts the command runner's sanitized launch code (without syscall/errno). */
+function codexSpawnFailureReason(error) {
+	if (!(error instanceof Error)) return;
+	const failure = error;
+	if (failure.syscall === void 0 || failure.syscall.startsWith("spawn")) {
+		if (failure.code === "EBADARCH" || failure.errno === -86 || failure.code === "Unknown system error -86") return "is not runnable on this CPU";
+		if (failure.code === "ENOENT") return "or its working directory was not found";
+		if (failure.code === "EACCES") return "is not executable or its working directory is inaccessible";
+	}
+}
+var CodexAppServerSpawnError = class extends Error {
+	constructor(command, reason, cause) {
+		super(`Codex catalog updater cannot run: ${command} ${reason}. Repair the executable or working directory and restart the Gateway.`, { cause });
+		this.command = command;
+		this.name = "CodexAppServerSpawnError";
+		failures.errors.set(this, this);
+	}
+};
+function findCodexAppServerSpawnError(error) {
+	let current = error;
+	const seen = /* @__PURE__ */ new Set();
+	while (current instanceof Error && !seen.has(current)) {
+		const failure = failures.errors.get(current);
+		if (failure) return failure;
+		seen.add(current);
+		current = current.cause;
+	}
+}
+function describeCodexSpawnError(error, command) {
+	const reason = codexSpawnFailureReason(error);
+	return reason ? new CodexAppServerSpawnError(command, reason, error) : error;
+}
+function getCodexAppServerSpawnFailure(command) {
+	return failures.commands.get(command);
+}
+function recordCodexAppServerSpawnFailure(error, command, launchKey) {
+	const described = describeCodexSpawnError(error, command);
+	const failure = findCodexAppServerSpawnError(described);
+	if (failure) failures.commands.set(launchKey, failure);
+	return described;
+}
+function reportCodexCatalogSpawnFailure(failure) {
+	if (!failures.reported.has(failure.command)) {
+		failures.reported.add(failure.command);
+		embeddedAgentLog.warn(failure.message);
+	}
+}
+//#endregion
+export { reportCodexCatalogSpawnFailure as a, recordCodexAppServerSpawnFailure as i, findCodexAppServerSpawnError as n, getCodexAppServerSpawnFailure as r, describeCodexSpawnError as t };

package/dist/.setup/{thread-archive-guard-jmecf6OJ.mjs → thread-archive-guard-C9frICzX.mjs}

@@ -1,4 +1,4 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/thread-archive-guard.ts
 const DESCENDANT_PAGE_LIMIT = 100;
@@ -19,11 +19,12 @@ async function assertCodexArchiveDescendantsUnowned(params) {
 	if (!ancestorThreadId) throw new Error("cannot verify Codex archive descendants for an invalid thread id");
 	const seenCursors = /* @__PURE__ */ new Set();
 	const seenThreadIds = /* @__PURE__ */ new Set([ancestorThreadId]);
+	let archived = false;
 	let cursor;
 	for (let pageIndex = 0; pageIndex < MAX_DESCENDANT_PAGES; pageIndex += 1) {
 		const response = await params.listPage({
 			ancestorThreadId,
-			archived: false,
+			archived,
 			limit: DESCENDANT_PAGE_LIMIT,
 			sortKey: "created_at",
 			sortDirection: "desc",
@@ -42,7 +43,13 @@ async function assertCodexArchiveDescendantsUnowned(params) {
 			if (await params.bindingStore.hasOtherThreadOwner(descendantThreadId)) throw new Error("cannot archive a Codex thread while a spawned descendant is owned by an OpenClaw session");
 		}
 		const nextCursor = readNextCursor(response.nextCursor);
-		if (!nextCursor) return;
+		if (!nextCursor) {
+			if (archived) return;
+			archived = true;
+			cursor = void 0;
+			seenCursors.clear();
+			continue;
+		}
 		if (seenCursors.has(nextCursor)) throw new Error("Codex app-server returned a repeated descendant-list cursor");
 		seenCursors.add(nextCursor);
 		cursor = nextCursor;