@openclaw/codex 2026.9.4 → 2026.9.6

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/{thread-archive-guard-DfpBr-Sz.js → .setup/thread-archive-guard-C9frICzX.mjs}

@@ -1,4 +1,4 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+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;

package/dist/.setup/thread-history-page-DoVpnHim.mjs

@@ -0,0 +1,83 @@
+import { M as parseTranscriptPage, P as readControlCursor, v as CatalogParamsError } from "./session-catalog-native-projection-DowriLid.mjs";
+//#region extensions/codex/src/app-server/thread-history-page.ts
+const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
+function encodeTurnItemCursor(turnCursor, itemId) {
+	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
+}
+function decodeTurnItemCursor(cursor) {
+	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
+	} catch {
+		throw new CatalogParamsError("invalid Codex transcript item cursor");
+	}
+	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
+	return {
+		turnCursor: value[0],
+		itemId: value[1]
+	};
+}
+/** Legacy stores expose only turn cursors; an item identity preserves paging across appends. */
+async function readLegacyCodexHistoryPage(readTurns, request, projection) {
+	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
+	const page = parseTranscriptPage(await readTurns({
+		threadId: request.threadId,
+		limit: 1,
+		sortDirection: "desc",
+		itemsView: "full",
+		...turnCursor ? { cursor: turnCursor } : {}
+	}));
+	const source = page.data.flatMap(({ items, ...turn }) => items.toReversed().map((item) => ({
+		turnId: turn.id,
+		item,
+		turn
+	})));
+	const anchorIndex = itemId ? source.findIndex(({ item }) => item.id === itemId) : -1;
+	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
+	const remaining = source.slice(anchorIndex + 1);
+	const items = projection.project(remaining.slice(0, request.limit), request.limit);
+	const result = () => {
+		const lastSource = remaining[items.length - 1];
+		const partial = lastSource !== void 0 && items.length < remaining.length;
+		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
+		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.item.id) : nativeCursor : void 0;
+		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
+		return {
+			items,
+			...cursor ? { nextCursor: cursor } : {}
+		};
+	};
+	let bounded = result();
+	while (!projection.fits(bounded)) {
+		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
+		items.pop();
+		bounded = result();
+	}
+	return bounded;
+}
+/** Callers authorize the thread; this reader owns native cursor and response-size semantics. */
+async function readCodexThreadHistoryPage(control, thread, request, projection) {
+	if (thread.historyMode !== "paginated") return readLegacyCodexHistoryPage((params) => control.listTurnPage(params), request, projection);
+	let limit = request.limit;
+	for (;;) {
+		const page = await control.listItemPage({
+			threadId: request.threadId,
+			limit,
+			sortDirection: "desc",
+			...request.cursor ? { cursor: request.cursor } : {}
+		});
+		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
+		const items = projection.project(page.data, limit);
+		const result = {
+			items,
+			...nextCursor ? { nextCursor } : {}
+		};
+		const fittingCount = items.length - (projection.fits(result) ? 0 : 1);
+		if (fittingCount === page.data.length) return result;
+		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
+		limit = fittingCount;
+	}
+}
+//#endregion
+export { readLegacyCodexHistoryPage as n, readCodexThreadHistoryPage as t };