theclawbay 0.3.66 → 0.3.68

package/dist/commands/logout.js

@@ -1548,10 +1548,10 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 this.log("- Codex login state: no cleanup needed.");
             }
             if (modelCacheCleanup.action === "removed") {
-                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 / GPT-5.4 Mini seed.");
+                this.log("- Codex model cache: removed the Claw Bay managed model catalog.");
             }
             else if (modelCacheCleanup.action === "preserved") {
-                this.log("- Codex model cache: preserved an existing GPT-5.4 / GPT-5.4 Mini entry.");
+                this.log("- Codex model cache: preserved an existing model catalog entry.");
             }
             else if (modelCacheCleanup.warning) {
                 this.log(`- Codex model cache: ${modelCacheCleanup.warning}`);

package/dist/commands/setup.js

@@ -3240,11 +3240,14 @@ class SetupCommand extends base_command_1.BaseCommand {
                 summaryNotes.add(authSeedResult.warning);
             if (authSeedResult &&
                 ["seeded", "updated", "already_seeded"].includes(authSeedResult.action)) {
-                summaryNotes.add("Codex desktop clients were pinned to a local ChatGPT-compatible auth shim so current VS Code and Codex app builds keep the The Claw Bay model picker instead of falling back to OpenAI's default model catalog.");
+                summaryNotes.add("Codex desktop clients were pinned to the local The Claw Bay API-key auth path while the desktop picker compatibility patches keep current VS Code and Codex app builds on the The Claw Bay model catalog.");
             }
             if (desktopModelPickerMigration?.action === "patched") {
                 summaryNotes.add("Desktop model pickers were refreshed so current VS Code and Codex app builds stop labeling supported The Claw Bay models like GPT-5.5 as Custom.");
             }
+            if (selectedSetupClients.has("codex")) {
+                summaryNotes.add("If Codex updates later, rerun `theclawbay setup` once to refresh its local model catalog.");
+            }
             if (selectedSetupClients.has("codex") && !migrateCodexConversations) {
                 summaryNotes.add("Left existing Codex conversations untouched.");
             }
@@ -3357,14 +3360,14 @@ class SetupCommand extends base_command_1.BaseCommand {
                 }
                 if (authSeedResult?.action === "seeded") {
                     this.log(authSeedResult.replacedExistingAuth
-                        ? "- Codex login state: backed up the existing Codex auth and switched local desktop auth to the Claw Bay desktop compatibility mode."
-                        : "- Codex login state: seeded local desktop auth in the Claw Bay desktop compatibility mode.");
+                        ? "- Codex login state: backed up the existing Codex auth and switched local desktop auth back to the Claw Bay API-key mode."
+                        : "- Codex login state: seeded local desktop auth in the Claw Bay API-key mode.");
                 }
                 else if (authSeedResult?.action === "updated") {
-                    this.log("- Codex login state: refreshed the local The Claw Bay desktop compatibility auth seed.");
+                    this.log("- Codex login state: refreshed the local The Claw Bay API-key auth seed.");
                 }
                 else if (authSeedResult?.action === "already_seeded") {
-                    this.log("- Codex login state: local desktop auth was already pinned to the Claw Bay desktop compatibility mode.");
+                    this.log("- Codex login state: local desktop auth was already pinned to the Claw Bay API-key mode.");
                 }
                 else if (authSeedResult?.warning) {
                     this.log(`- Codex login state: ${authSeedResult.warning}`);

package/dist/lib/codex-auth-seeding.js

@@ -244,12 +244,13 @@ async function ensureCodexApiKeyAuth(params) {
     });
 }
 async function ensureCodexUsageLimitAuth(params) {
-    return ensureCodexAuth({
-        codexHome: params.codexHome,
-        apiKey: params.apiKey,
-        mode: "chatgpt-auth-tokens",
-        replaceExistingAuth: params.replaceExistingAuth ?? false,
-    });
+    // Current desktop Codex builds treat chatgptAuthTokens as real ChatGPT web
+    // auth and can trigger upstream plugin sync calls against chatgpt.com. With
+    // The Claw Bay, that can wedge the desktop startup path behind Cloudflare
+    // challenges and leave Codex / VS Code stuck on splash. Keep desktop auth on
+    // the local API-key path and rely on the managed config + picker patches for
+    // model catalog compatibility instead.
+    return ensureCodexApiKeyAuth(params);
 }
 async function cleanupSeededCodexAuth(params) {
     const authPath = node_path_1.default.join(params.codexHome, AUTH_FILE);

package/dist/lib/codex-desktop-model-picker.js

@@ -9,8 +9,8 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("./config/paths");
-const supported_models_1 = require("./supported-models");
-const DESKTOP_MODEL_IDS = Array.from(new Set((0, supported_models_1.getSupportedModelIds)()));
+const codex_model_catalog_1 = require("./codex-model-catalog");
+const DESKTOP_MODEL_IDS = Array.from(new Set((0, codex_model_catalog_1.getVisibleHardcodedCodexModelIds)()));
 const STATSIG_MODEL_PICKER_CONFIG_ID = "107580212";
 function uniqueStrings(values) {
     return Array.from(new Set(values.filter((value) => Boolean(value))));

package/dist/lib/codex-model-cache-migration.js

@@ -10,36 +10,22 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
+const codex_model_catalog_1 = require("./codex-model-catalog");
 const supported_models_1 = require("./supported-models");
 const MODELS_CACHE_FILE = "models_cache.json";
 const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
-const TARGET_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
+const CATALOG_MODELS = (0, codex_model_catalog_1.getHardcodedCodexModelCatalog)();
+const CATALOG_MODEL_IDS = (0, codex_model_catalog_1.getHardcodedCodexModelIds)();
 const LEGACY_REMOVED_MODEL_IDS = (0, supported_models_1.getLegacyRemovedModelIds)();
-const TARGET_MODEL_ID_SET = new Set(TARGET_MODEL_IDS);
-const TRACKED_MODEL_ID_SET = new Set([...TARGET_MODEL_IDS, ...LEGACY_REMOVED_MODEL_IDS]);
+const CATALOG_MODEL_ID_SET = new Set(CATALOG_MODEL_IDS);
+const TRACKED_MODEL_ID_SET = new Set([...CATALOG_MODEL_IDS, ...LEGACY_REMOVED_MODEL_IDS]);
 const LEGACY_REMOVED_MODEL_ID_SET = new Set(LEGACY_REMOVED_MODEL_IDS);
 const SEED_MARKER_KEY = "_theclawbay_seeded";
 // Older releases stored the model id as the marker value; accept those so cleanup still works.
 const SEED_MARKER_VALUE = "theclawbay";
 const LEGACY_SEED_MARKER_VALUES = new Set([...TRACKED_MODEL_ID_SET, SEED_MARKER_VALUE, true]);
-const SUPPORTED_MODELS = (0, supported_models_1.getSupportedModels)();
-const SUPPORTED_MODEL_CONFIG = new Map(SUPPORTED_MODELS.map((model) => [model.id, model]));
-const TEMPLATE_MODEL_IDS = TARGET_MODEL_IDS;
-const DEFAULT_REASONING_LEVELS = [
-    { effort: "low", description: "Fast responses with lighter reasoning" },
-    { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
-    { effort: "high", description: "Greater reasoning depth for complex problems" },
-    { effort: "xhigh", description: "Extra high reasoning depth for complex problems" },
-];
-const FALLBACK_BASE_INSTRUCTIONS = `You are Codex, a coding agent based on GPT-5. You and the user share the same workspace and collaborate to achieve the user's goals.
-
-## General
-
-- Prefer rg or rg --files for search when available.
-- Make safe, minimal code changes that preserve user work.
-- Explain what changed and any remaining risk clearly.`;
-const SEEDED_CACHE_FRESHNESS_YEARS = 10;
+const SEEDED_CACHE_FRESHNESS_ISO = "2099-12-31T23:59:59.000Z";
 function objectRecordOr(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         return value;
@@ -148,7 +134,7 @@ async function readPatchState(statePath) {
 }
 async function writePatchState(statePath, fingerprints) {
     await promises_1.default.mkdir(node_path_1.default.dirname(statePath), { recursive: true });
-    const models = TARGET_MODEL_IDS.flatMap((modelId) => {
+    const models = CATALOG_MODEL_IDS.flatMap((modelId) => {
         const fingerprint = fingerprints[modelId];
         if (!fingerprint)
             return [];
@@ -166,93 +152,43 @@ function findModel(models, slug) {
 function hasSeedMarker(model) {
     return LEGACY_SEED_MARKER_VALUES.has(model[SEED_MARKER_KEY]);
 }
-function applySeedMarker(model) {
+function stripSeedMarker(model) {
+    if (!(SEED_MARKER_KEY in model))
+        return cloneJson(model);
     const next = cloneJson(model);
-    next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
+    delete next[SEED_MARKER_KEY];
     return next;
 }
-function seedDescription(modelId) {
-    return SUPPORTED_MODEL_CONFIG.get(modelId)?.note ?? "The Claw Bay model.";
+function buildCatalogModels() {
+    return cloneJson(CATALOG_MODELS).map((model) => stripSeedMarker(model));
 }
-function normalizeSeedModel(template, modelId) {
-    const modelConfig = SUPPORTED_MODEL_CONFIG.get(modelId);
-    const seed = applySeedMarker(template ?? {});
-    seed.slug = modelId;
-    seed.display_name = modelConfig?.label ?? modelId;
-    seed.description = seedDescription(modelId);
-    if (typeof seed.default_reasoning_level !== "string") {
-        seed.default_reasoning_level = "medium";
-    }
-    if (!Array.isArray(seed.supported_reasoning_levels) || seed.supported_reasoning_levels.length === 0) {
-        seed.supported_reasoning_levels = cloneJson(DEFAULT_REASONING_LEVELS);
-    }
-    if (typeof seed.shell_type !== "string") {
-        seed.shell_type = "shell_command";
-    }
-    seed.visibility = "list";
-    seed.supported_in_api = true;
-    seed.priority = 0;
-    seed.upgrade = null;
-    if (typeof seed.base_instructions !== "string" || !seed.base_instructions.trim()) {
-        seed.base_instructions = FALLBACK_BASE_INSTRUCTIONS;
-    }
-    if (typeof seed.supports_reasoning_summaries !== "boolean") {
-        seed.supports_reasoning_summaries = true;
-    }
-    if (typeof seed.support_verbosity !== "boolean") {
-        seed.support_verbosity = true;
-    }
-    if (seed.default_verbosity === undefined) {
-        seed.default_verbosity = "low";
-    }
-    if (seed.apply_patch_tool_type === undefined) {
-        seed.apply_patch_tool_type = "freeform";
-    }
-    const truncationPolicy = objectRecordOr(seed.truncation_policy);
-    if (!truncationPolicy || typeof truncationPolicy.mode !== "string" || typeof truncationPolicy.limit !== "number") {
-        seed.truncation_policy = { mode: "tokens", limit: 10000 };
-    }
-    if (typeof seed.supports_parallel_tool_calls !== "boolean") {
-        seed.supports_parallel_tool_calls = true;
-    }
-    if (typeof seed.context_window !== "number") {
-        seed.context_window = 272000;
-    }
-    if (typeof seed.effective_context_window_percent !== "number") {
-        seed.effective_context_window_percent = 95;
-    }
-    if (!Array.isArray(seed.experimental_supported_tools)) {
-        seed.experimental_supported_tools = [];
-    }
-    if (!Array.isArray(seed.input_modalities) || seed.input_modalities.length === 0) {
-        seed.input_modalities = ["text", "image"];
-    }
-    if (typeof seed.prefer_websockets !== "boolean") {
-        seed.prefer_websockets = true;
-    }
-    return seed;
+function buildCatalogModelMap() {
+    return new Map(buildCatalogModels().flatMap((model) => {
+        const slug = typeof model.slug === "string" ? model.slug : "";
+        return slug ? [[slug, model]] : [];
+    }));
 }
-function buildSeedModel(models, modelId) {
-    for (const candidate of TEMPLATE_MODEL_IDS) {
-        const template = findModel(models, candidate);
-        if (template)
-            return normalizeSeedModel(template, modelId);
-    }
-    return normalizeSeedModel(null, modelId);
+function sameFingerprintMaps(left, right) {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key, index) => key === rightKeys[index] && left[key] === right[key]);
 }
-function hasSeededTheClawBayModel(models) {
-    return models.some((model) => hasSeedMarker(model));
+function hasCatalogModels(models) {
+    return models.some((model) => {
+        const slug = typeof model.slug === "string" ? model.slug : "";
+        return Boolean(slug) && CATALOG_MODEL_ID_SET.has(slug);
+    });
 }
 function nextFetchedAtIsoForDocument(doc) {
-    if (!hasSeededTheClawBayModel(doc.models)) {
+    if (!hasCatalogModels(doc.models)) {
         return new Date().toISOString();
     }
-    // Current desktop Codex builds only consult models_cache.json for custom-provider
-    // catalogs in API-key mode, then silently fall back to compiled OpenAI models once
-    // the five-minute TTL expires. Keep the seeded cache durable until setup refreshes it.
-    const next = new Date();
-    next.setUTCFullYear(next.getUTCFullYear() + SEEDED_CACHE_FRESHNESS_YEARS);
-    return next.toISOString();
+    // Current Codex builds only consult models_cache.json for custom-provider
+    // catalogs in API-key mode. Pin the cache freshness far into the future so
+    // setup can refresh the catalog on demand without the five-minute TTL.
+    return SEEDED_CACHE_FRESHNESS_ISO;
 }
 function setCacheFreshnessMetadata(doc, clientVersion) {
     let changed = false;
@@ -562,22 +498,22 @@ async function ensureCodexModelCacheHasGpt54(params) {
     try {
         const existingState = await readPatchState(statePath);
         const parsed = await readJsonIfExists(cachePath);
+        const catalogModels = buildCatalogModels();
+        const catalogModelMap = buildCatalogModelMap();
         if (parsed === null) {
             const clientVersion = await inferCodexClientVersion(params.codexHome);
             if (!clientVersion) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model seed.",
+                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model catalog refresh.",
                 };
             }
-            const docModels = [];
-            const nextState = {};
-            for (const modelId of TARGET_MODEL_IDS) {
-                const seed = buildSeedModel(docModels, modelId);
-                docModels.push(seed);
-                nextState[modelId] = fingerprintModel(seed);
-            }
+            const docModels = cloneJson(catalogModels);
+            const nextState = Object.fromEntries(docModels.flatMap((model) => {
+                const slug = typeof model.slug === "string" ? model.slug : "";
+                return slug ? [[slug, fingerprintModel(model)]] : [];
+            }));
             const doc = {
                 fetched_at: nextFetchedAtIsoForDocument({ models: docModels }),
                 client_version: clientVersion,
@@ -592,105 +528,92 @@ async function ensureCodexModelCacheHasGpt54(params) {
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model seed.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model catalog refresh.",
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
             (typeof doc.client_version === "string" && doc.client_version ? doc.client_version : null);
         let changed = false;
         let seeded = false;
-        let stateChanged = false;
-        const nextState = { ...existingState };
-        const legacyRemovedBefore = doc.models.length;
-        doc.models = doc.models.filter((entry) => {
+        const currentCatalogEntries = new Map();
+        const rest = [];
+        for (const entry of doc.models) {
             const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (!slug || !LEGACY_REMOVED_MODEL_ID_SET.has(slug))
-                return true;
-            if (!hasSeedMarker(entry))
-                return true;
-            delete nextState[slug];
-            stateChanged = true;
-            return false;
-        });
-        if (doc.models.length !== legacyRemovedBefore) {
-            changed = true;
-        }
-        for (const modelId of TARGET_MODEL_IDS) {
-            const existingModel = findModel(doc.models, modelId);
-            const trackedFingerprint = existingState[modelId];
-            if (existingModel) {
-                const currentFingerprint = fingerprintModel(existingModel);
-                if (hasSeedMarker(existingModel)) {
-                    if (!trackedFingerprint || trackedFingerprint !== currentFingerprint) {
-                        nextState[modelId] = currentFingerprint;
-                        stateChanged = true;
-                    }
-                    continue;
+            if (!slug) {
+                rest.push(entry);
+                continue;
+            }
+            if (LEGACY_REMOVED_MODEL_ID_SET.has(slug) && hasSeedMarker(entry)) {
+                changed = true;
+                continue;
+            }
+            if (CATALOG_MODEL_ID_SET.has(slug)) {
+                if (!currentCatalogEntries.has(slug)) {
+                    currentCatalogEntries.set(slug, entry);
                 }
-                if (trackedFingerprint && trackedFingerprint === currentFingerprint) {
-                    const seededModel = applySeedMarker(existingModel);
-                    doc.models = doc.models.map((entry) => (entry.slug === modelId ? seededModel : entry));
-                    nextState[modelId] = fingerprintModel(seededModel);
-                    seeded = true;
+                else {
                     changed = true;
-                    stateChanged = true;
-                    continue;
-                }
-                if (trackedFingerprint && trackedFingerprint !== currentFingerprint) {
-                    delete nextState[modelId];
-                    stateChanged = true;
                 }
                 continue;
             }
-            const seed = buildSeedModel(doc.models, modelId);
-            doc.models = [seed, ...doc.models];
-            nextState[modelId] = fingerprintModel(seed);
-            seeded = true;
-            changed = true;
-            stateChanged = true;
+            const normalized = stripSeedMarker(entry);
+            if (fingerprintModel(normalized) !== fingerprintModel(entry)) {
+                changed = true;
+            }
+            rest.push(normalized);
         }
-        // Keep The Claw Bay seeds grouped at the top for easy discovery in the picker.
-        const bySlug = new Map();
-        const rest = [];
-        for (const entry of doc.models) {
-            const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (slug && TARGET_MODEL_ID_SET.has(slug) && !bySlug.has(slug)) {
-                bySlug.set(slug, entry);
+        const orderedCatalog = [];
+        const nextState = {};
+        for (const modelId of CATALOG_MODEL_IDS) {
+            const desiredModel = catalogModelMap.get(modelId);
+            if (!desiredModel)
+                continue;
+            const desiredFingerprint = fingerprintModel(desiredModel);
+            const trackedFingerprint = existingState[modelId];
+            const existingModel = currentCatalogEntries.get(modelId);
+            if (!existingModel) {
+                orderedCatalog.push(cloneJson(desiredModel));
+                nextState[modelId] = desiredFingerprint;
+                changed = true;
+                seeded = true;
                 continue;
             }
-            rest.push(entry);
-        }
-        const orderedTargets = [];
-        for (const id of TARGET_MODEL_IDS) {
-            const entry = bySlug.get(id);
-            if (entry)
-                orderedTargets.push(entry);
+            const normalizedExisting = stripSeedMarker(existingModel);
+            const existingFingerprint = fingerprintModel(normalizedExisting);
+            if (existingFingerprint === desiredFingerprint && !hasSeedMarker(existingModel)) {
+                orderedCatalog.push(normalizedExisting);
+                if (trackedFingerprint === desiredFingerprint) {
+                    nextState[modelId] = trackedFingerprint;
+                }
+                continue;
+            }
+            orderedCatalog.push(cloneJson(desiredModel));
+            nextState[modelId] = desiredFingerprint;
+            changed = true;
+            seeded = true;
         }
-        doc.models = [...orderedTargets, ...rest];
+        doc.models = [...orderedCatalog, ...rest];
         if (setCacheFreshnessMetadata(doc, clientVersion)) {
             changed = true;
         }
+        const stateChanged = !sameFingerprintMaps(existingState, nextState);
         if (changed) {
             await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
         }
-        const hasAnyTracked = TARGET_MODEL_IDS.some((id) => Boolean(nextState[id]));
+        const hasAnyTracked = CATALOG_MODEL_IDS.some((id) => Boolean(nextState[id]));
         if (!hasAnyTracked) {
             if (Object.keys(existingState).length > 0) {
                 await removeFileIfExists(statePath);
             }
         }
-        else if (stateChanged || seeded) {
+        else if (stateChanged) {
             await writePatchState(statePath, nextState);
         }
         if (seeded)
             return { action: "seeded" };
         if (changed || stateChanged)
             return { action: "refreshed" };
-        const allSeeded = TARGET_MODEL_IDS.every((id) => {
-            const model = findModel(doc.models, id);
-            return Boolean(model && hasSeedMarker(model));
-        });
-        return { action: allSeeded ? "already_seeded" : "already_present" };
+        return { action: hasAnyTracked ? "already_seeded" : "already_present" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -724,9 +647,17 @@ async function cleanupSeededCodexModelCache(params) {
         let preserved = 0;
         doc.models = doc.models.filter((entry) => {
             const slug = typeof entry.slug === "string" ? entry.slug : "";
-            if (!slug || !TRACKED_MODEL_ID_SET.has(slug))
+            if (!slug)
+                return true;
+            if (LEGACY_REMOVED_MODEL_ID_SET.has(slug) && hasSeedMarker(entry)) {
+                removed += 1;
+                return false;
+            }
+            const trackedFingerprint = state[slug];
+            if (!trackedFingerprint)
                 return true;
-            if (!hasSeedMarker(entry)) {
+            const normalized = stripSeedMarker(entry);
+            if (fingerprintModel(normalized) !== trackedFingerprint) {
                 preserved += 1;
                 return true;
             }

package/dist/lib/codex-model-catalog.d.ts

@@ -0,0 +1,5 @@
+type JsonObject = Record<string, unknown>;
+export declare function getHardcodedCodexModelCatalog(): JsonObject[];
+export declare function getHardcodedCodexModelIds(): string[];
+export declare function getVisibleHardcodedCodexModelIds(): string[];
+export {};

package/dist/lib/codex-model-catalog.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHardcodedCodexModelCatalog = getHardcodedCodexModelCatalog;
+exports.getHardcodedCodexModelIds = getHardcodedCodexModelIds;
+exports.getVisibleHardcodedCodexModelIds = getVisibleHardcodedCodexModelIds;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+function configPath() {
+    return node_path_1.default.resolve(__dirname, "..", "..", "theclawbay-codex-model-catalog.json");
+}
+function parseCodexModelCatalog(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error("codex model catalog must be an array");
+    }
+    return parsed.map((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new Error("codex model catalog contains an invalid entry");
+        }
+        return entry;
+    });
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+let cachedCatalog = null;
+function getHardcodedCodexModelCatalog() {
+    if (!cachedCatalog) {
+        cachedCatalog = parseCodexModelCatalog((0, node_fs_1.readFileSync)(configPath(), "utf8"));
+    }
+    return cloneJson(cachedCatalog);
+}
+function getHardcodedCodexModelIds() {
+    return getHardcodedCodexModelCatalog()
+        .map((model) => (typeof model.slug === "string" ? model.slug.trim() : ""))
+        .filter(Boolean);
+}
+function getVisibleHardcodedCodexModelIds() {
+    return getHardcodedCodexModelCatalog()
+        .filter((model) => model.visibility === "list")
+        .map((model) => (typeof model.slug === "string" ? model.slug.trim() : ""))
+        .filter(Boolean);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.66",
+  "version": "0.3.68",
   "description": "CLI for connecting Codex, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,7 @@
   },
   "files": [
     "dist",
+    "theclawbay-codex-model-catalog.json",
     "theclawbay-supported-models.json",
     "README.md",
     "LICENSE"