@yansigit/opencodex 2.31.0

package/src/codex/paths.ts

@@ -0,0 +1,144 @@
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { expandUserPath } from "../config";
+import { defaultCodexHome } from "./home";
+
+function resolveCodexHome(): string {
+  const raw = process.env.CODEX_HOME?.trim();
+  if (raw) {
+    const path = resolve(expandUserPath(raw));
+    let stat;
+    try {
+      stat = statSync(path);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`CODEX_HOME points to ${raw}, but that path could not be read: ${message}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`CODEX_HOME points to ${raw}, but that path is not a directory`);
+    }
+    return realpathSync.native(path);
+  }
+
+  return defaultCodexHome();
+}
+
+export const CODEX_HOME = resolveCodexHome();
+export const CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
+export const CODEX_PROFILE_PATH = join(CODEX_HOME, "opencodex.config.toml");
+export const DEFAULT_CATALOG_PATH = join(CODEX_HOME, "opencodex-catalog.json");
+export const CODEX_MODELS_CACHE_PATH = join(CODEX_HOME, "models_cache.json");
+
+/** Runtime CODEX_HOME lookup (honors CODEX_HOME env changes after import). */
+export function getCodexHome(): string {
+  return resolveCodexHome();
+}
+
+export interface CodexSqliteHomeDeps {
+  env?: NodeJS.ProcessEnv;
+  cwd?: () => string;
+  codexHome?: string;
+  readConfig?: (path: string) => string;
+}
+
+type RootTomlStringState =
+  | { kind: "absent" }
+  | { kind: "value"; value: string }
+  | { kind: "invalid" };
+
+/**
+ * Parse the authoritative SQLite setting without changing the tolerant helper
+ * used by injection/catalog readers. History ownership must distinguish a
+ * missing key from a present value that Codex cannot interpret as a path.
+ */
+function readAuthoritativeRootTomlString(content: string, key: string): RootTomlStringState {
+  let parsed: unknown;
+  try {
+    parsed = Bun.TOML.parse(content);
+  } catch {
+    return { kind: "invalid" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { kind: "invalid" };
+  const root = parsed as Record<string, unknown>;
+  if (!Object.prototype.hasOwnProperty.call(root, key)) return { kind: "absent" };
+  const value = root[key];
+  if (typeof value !== "string" || value.trim() === "") return { kind: "invalid" };
+  return { kind: "value", value: value.trim() };
+}
+
+/**
+ * Resolve Codex's SQLite state root at call time.
+ *
+ * Codex permits SQLite-backed state to live outside CODEX_HOME, especially for
+ * Windows Desktop sessions whose app-server runs in WSL. Keep the precedence
+ * identical to Codex: root config, then environment, then the effective home.
+ */
+export function resolveCodexSqliteHome(deps: CodexSqliteHomeDeps = {}): string {
+  const codexHome = deps.codexHome ?? getCodexHome();
+  const readConfig = deps.readConfig ?? (path => readFileSync(path, "utf8"));
+  const configPath = join(codexHome, "config.toml");
+  let configured: RootTomlStringState = { kind: "absent" };
+  try {
+    configured = readAuthoritativeRootTomlString(readConfig(configPath), "sqlite_home");
+  } catch (cause) {
+    if ((cause as NodeJS.ErrnoException | undefined)?.code !== "ENOENT") {
+      throw new Error(
+        `Codex config could not be read while resolving sqlite_home: ${configPath}`,
+        { cause },
+      );
+    }
+    // A genuinely absent config cannot contain the authoritative root override,
+    // so only ENOENT may continue to the documented environment/home fallback.
+  }
+  if (configured.kind === "invalid") {
+    throw new Error(`Codex config has an invalid sqlite_home setting: ${configPath}`);
+  }
+  const raw = configured.kind === "value"
+    ? configured.value
+    : (deps.env ?? process.env).CODEX_SQLITE_HOME?.trim() || "";
+  if (!raw) return codexHome;
+  const expanded = expandUserPath(raw);
+  return isAbsolute(expanded)
+    ? resolve(expanded)
+    : resolve((deps.cwd ?? process.cwd)(), expanded);
+}
+
+/** Active Codex thread-state database, derived from the call-time SQLite root. */
+export function resolveCodexStateDbPath(deps: CodexSqliteHomeDeps = {}): string {
+  return join(resolveCodexSqliteHome(deps), "state_5.sqlite");
+}
+
+/** Active Codex diagnostic-log database, derived from the call-time SQLite root. */
+export function resolveCodexLogsDbPath(deps: CodexSqliteHomeDeps = {}): string {
+  return join(resolveCodexSqliteHome(deps), "logs_2.sqlite");
+}
+
+export function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+export function parseTomlString(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try {
+      return JSON.parse(raw) as string;
+    } catch {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw.slice(1, -1);
+}
+
+export function readRootTomlString(content: string, key: string): string | null {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  const rootLines = firstTable === -1 ? lines : lines.slice(0, firstTable);
+  for (const line of rootLines) {
+    const m = line.match(new RegExp(`^\\s*${key}\\s*=\\s*(\"(?:\\\\.|[^\"])*\"|'[^']*')`));
+    if (m) return parseTomlString(m[1]);
+  }
+  return null;
+}
+
+export function resolveCodexConfigPath(path: string): string {
+  return isAbsolute(path) ? path : join(CODEX_HOME, path);
+}

package/src/codex/plan-from-token.ts

@@ -0,0 +1,140 @@
+import {
+  ConfigMutationLockError,
+  loadConfig,
+  mutatePersistedConfig,
+} from "../config";
+import type { CodexAccount, OcxConfig } from "../types";
+import { isSelectableCodexPoolAccount, isValidCodexAccountId } from "./account-id";
+import {
+  getCodexAccountCredential,
+  isCodexAccountGenerationLive,
+  readCodexAccountRecord,
+} from "./account-store";
+import { extractChatgptPlanType, codexPlanValue } from "./plan";
+
+interface FreshPoolPlanUpdate {
+  accountId: string;
+  plan: string;
+  credentialGeneration: number;
+}
+
+function configuredPoolAccount(config: OcxConfig, accountId: string): CodexAccount | null {
+  if (!isValidCodexAccountId(accountId)) return null;
+  return (config.codexAccounts ?? [])
+    .find(account => account.id === accountId && isSelectableCodexPoolAccount(account)) ?? null;
+}
+
+function jwtPlanFromPoolCredential(accountId: string): string | undefined {
+  const cred = getCodexAccountCredential(accountId);
+  return cred ? extractChatgptPlanType(undefined, cred.accessToken) : undefined;
+}
+
+/**
+ * WHAM-wins gate (release-audit fix). A JWT-derived plan may be persisted only when no
+ * WHAM-sourced plan exists for the CURRENT credential generation. A token refresh bumps the
+ * generation, and the refreshed JWT is then genuinely newer information than the previous
+ * generation's WHAM read, so it may write again until WHAM re-observes. Records without
+ * provenance (legacy) stay writable so the original #1989 recovery still works.
+ */
+function jwtMayWritePlan(account: CodexAccount, generation: number): boolean {
+  if (account.planSource !== "wham") return true;
+  const whamGeneration = account.planCredentialGeneration;
+  return whamGeneration !== undefined && generation > whamGeneration;
+}
+
+function collectJwtPoolPlanUpdates(runtimeConfig: OcxConfig): FreshPoolPlanUpdate[] {
+  const updates: FreshPoolPlanUpdate[] = [];
+  for (const account of (runtimeConfig.codexAccounts ?? []).filter(isSelectableCodexPoolAccount)) {
+    const jwtPlan = jwtPlanFromPoolCredential(account.id);
+    if (!jwtPlan || codexPlanValue(account.plan) === jwtPlan) continue;
+    const generation = readCodexAccountRecord(account.id)?.generation;
+    if (generation === undefined) continue;
+    if (!jwtMayWritePlan(account, generation)) continue;
+    updates.push({ accountId: account.id, plan: jwtPlan, credentialGeneration: generation });
+  }
+  return updates;
+}
+
+const appliedJwtPlans = new Map<string, string>();
+
+function persistJwtPlanUpdates(runtimeConfig: OcxConfig, updates: FreshPoolPlanUpdate[]): void {
+  if (updates.length === 0) return;
+  let outcome: ReturnType<typeof mutatePersistedConfig<FreshPoolPlanUpdate[]>>;
+  try {
+    outcome = mutatePersistedConfig(persistedConfig => {
+      const accepted: FreshPoolPlanUpdate[] = [];
+      let changed = false;
+      for (const update of updates) {
+        if (!isCodexAccountGenerationLive(update.accountId, update.credentialGeneration)) continue;
+        const liveAccount = configuredPoolAccount(runtimeConfig, update.accountId);
+        const persistedAccount = configuredPoolAccount(persistedConfig, update.accountId);
+        if (!liveAccount || !persistedAccount) continue;
+        // Re-check against the PERSISTED row: another process may have landed a WHAM
+        // observation between collect and this mutation.
+        if (!jwtMayWritePlan(persistedAccount, update.credentialGeneration)) continue;
+        accepted.push(update);
+        if (persistedAccount.plan !== update.plan) {
+          persistedAccount.plan = update.plan;
+          changed = true;
+        }
+        if (persistedAccount.planSource !== "jwt" || persistedAccount.planCredentialGeneration !== update.credentialGeneration) {
+          persistedAccount.planSource = "jwt";
+          persistedAccount.planCredentialGeneration = update.credentialGeneration;
+          changed = true;
+        }
+      }
+      return { changed, value: accepted };
+    });
+  } catch (error) {
+    if (error instanceof ConfigMutationLockError) return;
+    throw error;
+  }
+  if (outcome.status === "unavailable") return;
+  for (const update of outcome.value) {
+    if (!isCodexAccountGenerationLive(update.accountId, update.credentialGeneration)) continue;
+    const liveAccount = configuredPoolAccount(runtimeConfig, update.accountId);
+    if (liveAccount) {
+      liveAccount.plan = update.plan;
+      liveAccount.planSource = "jwt";
+      liveAccount.planCredentialGeneration = update.credentialGeneration;
+      appliedJwtPlans.set(update.accountId, update.plan);
+    }
+  }
+}
+
+/**
+ * Persist JWT `chatgpt_plan_type` onto `codexAccounts[].plan` when it contradicts the stored
+ * label. Generation-gated, same fail-closed lock policy as the WHAM plan patch. Does not
+ * overwrite a plan that already matches the token.
+ */
+export function reconcileCodexPlansFromTokens(runtimeConfig: OcxConfig = loadConfig()): void {
+  persistJwtPlanUpdates(runtimeConfig, collectJwtPoolPlanUpdates(runtimeConfig));
+}
+
+export function resetJwtPlanNotesForTests(): void {
+  appliedJwtPlans.clear();
+}
+
+/** Apply one account's live token claim without blocking the credential read path. */
+export function noteCodexAccountAccessToken(
+  accountId: string,
+  accessToken: string,
+  credentialGeneration: number,
+): void {
+  const jwtPlan = extractChatgptPlanType(undefined, accessToken);
+  if (!jwtPlan) return;
+  if (appliedJwtPlans.get(accountId) === jwtPlan) return;
+  try {
+    const runtimeConfig = loadConfig();
+    const live = configuredPoolAccount(runtimeConfig, accountId);
+    if (!live || codexPlanValue(live.plan) === jwtPlan) {
+      appliedJwtPlans.set(accountId, jwtPlan);
+      return;
+    }
+    if (!jwtMayWritePlan(live, credentialGeneration)) return;
+    persistJwtPlanUpdates(runtimeConfig, [{ accountId, plan: jwtPlan, credentialGeneration }]);
+    if (codexPlanValue(live.plan) === jwtPlan) appliedJwtPlans.set(accountId, jwtPlan);
+  } catch {
+    appliedJwtPlans.delete(accountId);
+  }
+}

package/src/codex/plan.ts

@@ -0,0 +1,40 @@
+import { decodeJwtPayload } from "../oauth/chatgpt";
+
+/** Preserve user/provider plan labels only when they are usable strings. */
+export function codexPlanValue(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  return value.trim() ? value : undefined;
+}
+
+/** Case-insensitive key used by quota, capacity, and collision policy. */
+export function codexPlanKey(value: unknown): string | undefined {
+  return codexPlanValue(value)?.trim().toLowerCase();
+}
+
+export function isThirtyDayOnlyCodexPlan(value: unknown): boolean {
+  const key = codexPlanKey(value);
+  return key === "go" || key === "free";
+}
+
+/**
+ * ChatGPT plan label from a live access/id token (`chatgpt_plan_type`).
+ * Used when WHAM has not run yet so a stale stored `free` cannot outrank the token (#1989).
+ */
+export function extractChatgptPlanType(idToken?: string, accessToken?: string): string | undefined {
+  for (const token of [idToken, accessToken]) {
+    if (!token) continue;
+    const payload = decodeJwtPayload(token);
+    if (!payload) continue;
+    if (typeof payload.chatgpt_plan_type === "string") {
+      const plan = codexPlanValue(payload.chatgpt_plan_type);
+      if (plan) return plan;
+    }
+    const ns = payload["https://api.openai.com/auth"];
+    if (ns && typeof ns === "object") {
+      const nested = (ns as Record<string, unknown>).chatgpt_plan_type;
+      const plan = codexPlanValue(nested);
+      if (plan) return plan;
+    }
+  }
+  return undefined;
+}

package/src/codex/plugins-doctor.ts

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { CODEX_CONFIG_PATH } from "./paths";
+import { redactUserPath } from "../lib/redact";
+
+// Mirrors codex-rs core-plugins/src/marketplace.rs MARKETPLACE_MANIFEST_RELATIVE_PATHS.
+// A marketplace root "resolves" only when one of these files exists under it.
+const MARKETPLACE_MANIFEST_RELATIVE_PATHS = [
+  ".agents/plugins/marketplace.json",
+  ".claude-plugin/marketplace.json",
+] as const;
+
+const OPENAI_BUNDLED_MARKETPLACE_NAME = "openai-bundled";
+
+// Where the Codex desktop app's bundled plugins live, relative to an install
+// root. Windows app-package paths embed the app version, so the actual install
+// root is discovered by scanning candidate bases (LOCALAPPDATA, etc.) rather
+// than hardcoded. The bundled marketplace dir is named after the marketplace.
+const BUNDLED_MARKETPLACE_LEAF = join("plugins", "bundled-marketplaces", OPENAI_BUNDLED_MARKETPLACE_NAME);
+const CODEX_APP_DIR_SEGMENTS = [join("Programs", "@openai", "codex"), join("Programs", "codex"), join("@openai", "codex"), "codex"] as const;
+
+// Plugins the issue (#43) calls out. Treated as data, not as an authoritative
+// allowlist: codex-rs only allowlists chrome/computer-use, but the diagnostic
+// just reports presence, so listing browser here is informational only.
+const COMMON_BUNDLED_PLUGINS = ["computer-use", "browser", "chrome"] as const;
+
+export type CodexPluginsDiagnostic =
+  | { applicable: false; reason: string; summary: string }
+  | {
+      applicable: true;
+      stale: boolean;
+      marketplace: {
+        name: string;
+        present: boolean;
+        sourceType: string | null;
+        source: string | null;
+        resolvesToManifest: boolean;
+        currentBundledPath: string | null;
+        pathMismatch: boolean;
+      };
+      bundledPlugins: Array<{ id: string; configured: boolean }>;
+      suggestedRepair: string | null;
+      summary: string;
+    };
+
+/** True when the table at `[marketplaces.<name>]` exists in the config text. */
+function readMarketplaceTable(configText: string, name: string): Record<string, string> | null {
+  // Split on CRLF or LF: config.toml on Windows (the platform this diagnostic
+  // targets) uses CRLF, and a leftover \r would defeat the `$`-anchored regexes.
+  const lines = configText.split(/\r?\n/);
+  const header = new RegExp(`^\\s*\\[marketplaces\\.(?:"${escapeRegExp(name)}"|${escapeRegExp(name)})\\]\\s*(?:#.*)?$`);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (header.test(lines[i] ?? "")) { start = i + 1; break; }
+  }
+  if (start === -1) return null;
+
+  const table: Record<string, string> = {};
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (/^\s*\[/.test(line)) break; // next table starts; stop
+    const m = line.match(/^\s*([A-Za-z0-9_-]+)\s*=\s*("(?:\\.|[^"\\])*"|'[^']*'|(?!["'])[^\s#]+)\s*(?:#.*)?$/);
+    if (!m) continue;
+    table[m[1]] = unquoteTomlValue(m[2].trim());
+  }
+  return table;
+}
+
+function unquoteTomlValue(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try { return JSON.parse(raw) as string; } catch { return raw.slice(1, -1); }
+  }
+  if (raw.startsWith("'")) return raw.slice(1, -1);
+  return raw;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** A directory is a bundled-marketplace root when it holds a supported manifest. */
+function dirHasManifest(dir: string): boolean {
+  return MARKETPLACE_MANIFEST_RELATIVE_PATHS.some(rel => existsSync(join(dir, rel)));
+}
+
+/**
+ * Locate the bundled `openai-bundled` marketplace dir under the installed Codex
+ * desktop app on Windows. Windows app paths embed the app version, so we scan
+ * candidate install bases for a versioned app dir whose
+ * `plugins/bundled-marketplaces/openai-bundled` holds a manifest. Returns the
+ * newest matching dir (by mtime) or null. Filesystem access is injectable for
+ * tests so a Windows layout can be exercised on any OS.
+ */
+export function locateCurrentBundledMarketplace(
+  options: {
+    env?: NodeJS.ProcessEnv;
+    listDir?: (dir: string) => string[];
+    isManifestRoot?: (dir: string) => boolean;
+    mtimeOf?: (dir: string) => number;
+  } = {},
+): string | null {
+  const env = options.env ?? process.env;
+  const listDir = options.listDir ?? ((dir: string) => {
+    try { return readdirSync(dir); } catch { return []; }
+  });
+  const isManifestRoot = options.isManifestRoot ?? dirHasManifest;
+  const mtimeOf = options.mtimeOf ?? ((dir: string) => {
+    try { return statSync(dir).mtimeMs; } catch { return 0; }
+  });
+
+  const bases = [env.LOCALAPPDATA, env.PROGRAMFILES, env["ProgramFiles(x86)"], env.APPDATA]
+    .filter((b): b is string => typeof b === "string" && b.length > 0);
+
+  const candidates: string[] = [];
+  for (const base of bases) {
+    for (const seg of CODEX_APP_DIR_SEGMENTS) {
+      const appRoot = join(base, seg);
+      // Direct (unversioned) layout.
+      const direct = join(appRoot, BUNDLED_MARKETPLACE_LEAF);
+      if (isManifestRoot(direct)) candidates.push(direct);
+      // Versioned layout: appRoot/<version>/plugins/bundled-marketplaces/openai-bundled
+      for (const child of listDir(appRoot)) {
+        const versioned = join(appRoot, child, BUNDLED_MARKETPLACE_LEAF);
+        if (isManifestRoot(versioned)) candidates.push(versioned);
+      }
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => mtimeOf(b) - mtimeOf(a));
+  return candidates[0] ?? null;
+}
+
+/** Normalize a path for comparison: lowercase + unify separators (Windows is case-insensitive). */
+function normalizePathForCompare(path: string): string {
+  return path.replace(/[\\/]+/g, "\\").replace(/\\+$/, "").toLowerCase();
+}
+
+/** A local marketplace `source` resolves when it holds a supported manifest. */
+function sourceResolvesToManifest(source: string): boolean {
+  if (!isAbsolute(source)) return false;
+  if (!existsSync(source)) return false;
+  return MARKETPLACE_MANIFEST_RELATIVE_PATHS.some(rel => existsSync(join(source, rel)));
+}
+
+/**
+ * Read-only diagnostic for the Codex `openai-bundled` plugin marketplace.
+ *
+ * Only meaningful on Windows, where app-package paths embed the app version and
+ * go stale after an update. On other platforms it reports "not applicable".
+ * NEVER mutates config.toml, never invokes `codex plugin marketplace add`.
+ */
+export function diagnoseCodexBundledPlugins(
+  options: {
+    platform?: NodeJS.Platform;
+    configPath?: string;
+    locateCurrent?: () => string | null;
+  } = {},
+): CodexPluginsDiagnostic {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    return {
+      applicable: false,
+      reason: "not_windows",
+      summary: "not applicable (bundled-marketplace staleness is Windows-specific)",
+    };
+  }
+
+  const configPath = options.configPath ?? CODEX_CONFIG_PATH;
+  let configText: string;
+  try {
+    configText = readFileSync(configPath, "utf8");
+  } catch {
+    return {
+      applicable: false,
+      reason: "config_unreadable",
+      summary: "not applicable (Codex config.toml not found or unreadable)",
+    };
+  }
+
+  const table = readMarketplaceTable(configText, OPENAI_BUNDLED_MARKETPLACE_NAME);
+  const present = table !== null;
+  const sourceType = table?.source_type ?? null;
+  const source = table?.source ?? null;
+  const isLocal = sourceType === "local" && !!source;
+  const resolvesToManifest = isLocal ? sourceResolvesToManifest(source as string) : false;
+
+  // Locate the bundled marketplace under the currently installed Codex app, so
+  // we can tell "registered path differs from the live app path" (the Windows
+  // app-update staleness signal) apart from a merely missing manifest.
+  const locateCurrent = options.locateCurrent ?? (() => locateCurrentBundledMarketplace());
+  const currentBundledPath = locateCurrent();
+  const pathMismatch = !!(
+    currentBundledPath && source && isLocal &&
+    normalizePathForCompare(currentBundledPath) !== normalizePathForCompare(source)
+  );
+
+  // Stale = a registered local bundled marketplace whose source no longer
+  // resolves to a manifest, OR whose registered path differs from the live
+  // app's bundled path (the Windows app-update signal). A missing marketplace
+  // is "not stale" but flagged separately by `present: false`.
+  const stale = present && isLocal && (!resolvesToManifest || pathMismatch);
+  // Present but not a usable local entry (wrong source_type or empty source):
+  // not "stale" in the app-update sense, but it must NOT be reported as healthy.
+  const malformed = present && !isLocal;
+
+  const bundledPlugins = COMMON_BUNDLED_PLUGINS.map(id => ({
+    id,
+    configured: new RegExp(`\\[plugins\\.(?:"${escapeRegExp(`${id}@${OPENAI_BUNDLED_MARKETPLACE_NAME}`)}")\\]`).test(configText),
+  }));
+
+  const repairTarget = currentBundledPath ?? `<current ${OPENAI_BUNDLED_MARKETPLACE_NAME} path under the installed Codex app>`;
+  const suggestedRepair = (stale || pathMismatch)
+    ? `codex plugin marketplace add ${currentBundledPath ? redactUserPath(currentBundledPath) : repairTarget}`
+    : null;
+
+  const summary = !present
+    ? `no [marketplaces.${OPENAI_BUNDLED_MARKETPLACE_NAME}] entry in Codex config`
+    : malformed
+      ? `[marketplaces.${OPENAI_BUNDLED_MARKETPLACE_NAME}] is present but not a usable local source (source_type/source missing)`
+      : !resolvesToManifest
+        ? `stale: registered ${OPENAI_BUNDLED_MARKETPLACE_NAME} source no longer resolves to a marketplace manifest`
+        : pathMismatch
+          ? `stale: registered ${OPENAI_BUNDLED_MARKETPLACE_NAME} path differs from the installed Codex app's bundled path`
+          : `ok: ${OPENAI_BUNDLED_MARKETPLACE_NAME} marketplace resolves`;
+
+  return {
+    applicable: true,
+    stale,
+    marketplace: {
+      name: OPENAI_BUNDLED_MARKETPLACE_NAME,
+      present,
+      sourceType,
+      source: source ? redactUserPath(source) : null,
+      resolvesToManifest,
+      currentBundledPath: currentBundledPath ? redactUserPath(currentBundledPath) : null,
+      pathMismatch,
+    },
+    bundledPlugins,
+    suggestedRepair,
+    summary,
+  };
+}