theclawbay 0.3.65 → 0.3.66

package/dist/commands/setup.js

@@ -14,6 +14,7 @@ const core_1 = require("@oclif/core");
 const yaml_1 = require("yaml");
 const base_command_1 = require("../lib/base-command");
 const codex_auth_seeding_1 = require("../lib/codex-auth-seeding");
+const codex_desktop_model_picker_1 = require("../lib/codex-desktop-model-picker");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
 const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
 const paths_1 = require("../lib/config/paths");
@@ -2989,6 +2990,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             let authSeedResult = null;
             let stateDbMigration = null;
             let modelCacheMigration = null;
+            let desktopModelPickerMigration = null;
             let continueConfigPath = null;
             let clineConfigPaths = [];
             let gsdConfigPaths = [];
@@ -3088,7 +3090,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                             neutralizeSources: HISTORY_PROVIDER_NEUTRALIZE_SOURCES,
                         });
                     }
-                    authSeedResult = await (0, codex_auth_seeding_1.ensureCodexApiKeyAuth)({
+                    authSeedResult = await (0, codex_auth_seeding_1.ensureCodexUsageLimitAuth)({
                         codexHome: paths_1.codexDir,
                         apiKey: authCredential,
                         replaceExistingAuth: true,
@@ -3103,6 +3105,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                     modelCacheMigration = await (0, codex_model_cache_migration_1.ensureCodexModelCacheHasGpt54)({
                         codexHome: paths_1.codexDir,
                     });
+                    desktopModelPickerMigration = await (0, codex_desktop_model_picker_1.ensureCodexDesktopModelPickerSupport)();
                 }
                 if (selectedSetupClients.has("continue")) {
                     progress.update("Configuring Continue");
@@ -3231,11 +3234,16 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             if (modelCacheMigration?.warning)
                 summaryNotes.add(modelCacheMigration.warning);
+            if (desktopModelPickerMigration?.warning)
+                summaryNotes.add(desktopModelPickerMigration.warning);
             if (authSeedResult?.warning)
                 summaryNotes.add(authSeedResult.warning);
             if (authSeedResult &&
                 ["seeded", "updated", "already_seeded"].includes(authSeedResult.action)) {
-                summaryNotes.add("Codex desktop clients were pinned to local API-key auth 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 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.");
+            }
+            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") && !migrateCodexConversations) {
                 summaryNotes.add("Left existing Codex conversations untouched.");
@@ -3338,16 +3346,25 @@ class SetupCommand extends base_command_1.BaseCommand {
                 else if (modelCacheMigration) {
                     this.log("- Codex model cache: no change.");
                 }
+                if (desktopModelPickerMigration?.action === "patched") {
+                    this.log("- Codex desktop picker: refreshed VS Code / Codex app picker compatibility so supported The Claw Bay models keep their real labels.");
+                }
+                else if (desktopModelPickerMigration?.warning) {
+                    this.log(`- Codex desktop picker: ${desktopModelPickerMigration.warning}`);
+                }
+                else if (desktopModelPickerMigration) {
+                    this.log("- Codex desktop picker: no change.");
+                }
                 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 API-key mode."
-                        : "- Codex login state: seeded local desktop auth in The Claw Bay API-key mode.");
+                        ? "- 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.");
                 }
                 else if (authSeedResult?.action === "updated") {
-                    this.log("- Codex login state: refreshed the local The Claw Bay API-key auth seed.");
+                    this.log("- Codex login state: refreshed the local The Claw Bay desktop compatibility auth seed.");
                 }
                 else if (authSeedResult?.action === "already_seeded") {
-                    this.log("- Codex login state: local desktop auth was already pinned to The Claw Bay API-key mode.");
+                    this.log("- Codex login state: local desktop auth was already pinned to the Claw Bay desktop compatibility mode.");
                 }
                 else if (authSeedResult?.warning) {
                     this.log(`- Codex login state: ${authSeedResult.warning}`);

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

@@ -74,15 +74,19 @@ function buildFakeJwt(params) {
 }
 function buildSeededAuthDocument(params) {
     if (params.mode === "chatgpt-auth-tokens") {
+        const fakeJwt = buildFakeJwt({
+            email: THECLAWBAY_CHATGPT_EMAIL,
+            accountId: THECLAWBAY_CHATGPT_ACCOUNT_ID,
+            planType: THECLAWBAY_CHATGPT_PLAN_TYPE,
+        });
         return {
             auth_mode: "chatgptAuthTokens",
             tokens: {
-                id_token: buildFakeJwt({
-                    email: THECLAWBAY_CHATGPT_EMAIL,
-                    accountId: THECLAWBAY_CHATGPT_ACCOUNT_ID,
-                    planType: THECLAWBAY_CHATGPT_PLAN_TYPE,
-                }),
-                access_token: params.apiKey,
+                // Current desktop Codex builds derive the local ChatGPT-style account
+                // identity from these token fields. Keep them obviously fake so the real
+                // The Claw Bay bearer stays scoped to experimental_bearer_token only.
+                id_token: fakeJwt,
+                access_token: fakeJwt,
                 refresh_token: "",
                 account_id: THECLAWBAY_CHATGPT_ACCOUNT_ID,
             },
@@ -240,11 +244,12 @@ async function ensureCodexApiKeyAuth(params) {
     });
 }
 async function ensureCodexUsageLimitAuth(params) {
-    // Current Codex releases treat chatgptAuthTokens.access_token as a real
-    // ChatGPT JWT and use it against chatgpt.com. The Claw Bay credentials are
-    // provider-scoped bearer tokens, so the legacy fake-ChatGPT seed path is no
-    // longer safe to apply here.
-    return ensureCodexApiKeyAuth(params);
+    return ensureCodexAuth({
+        codexHome: params.codexHome,
+        apiKey: params.apiKey,
+        mode: "chatgpt-auth-tokens",
+        replaceExistingAuth: params.replaceExistingAuth ?? false,
+    });
 }
 async function cleanupSeededCodexAuth(params) {
     const authPath = node_path_1.default.join(params.codexHome, AUTH_FILE);

package/dist/lib/codex-desktop-model-picker.d.ts

@@ -0,0 +1,7 @@
+export type EnsureCodexDesktopModelPickerResult = {
+    action: "patched" | "already_patched" | "skipped";
+    warning?: string;
+    patchedBundles: number;
+    patchedCaches: number;
+};
+export declare function ensureCodexDesktopModelPickerSupport(): Promise<EnsureCodexDesktopModelPickerResult>;

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

@@ -0,0 +1,417 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCodexDesktopModelPickerSupport = ensureCodexDesktopModelPickerSupport;
+const node_child_process_1 = require("node:child_process");
+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 STATSIG_MODEL_PICKER_CONFIG_ID = "107580212";
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => Boolean(value))));
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWslInteropRuntime() {
+    return node_os_1.default.platform() === "linux" && Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
+function readWindowsCommandStdout(command) {
+    const shell = node_os_1.default.platform() === "win32" ? "powershell.exe" : isWslInteropRuntime() ? "powershell.exe" : null;
+    if (!shell)
+        return null;
+    const result = (0, node_child_process_1.spawnSync)(shell, ["-NoProfile", "-Command", command], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0)
+        return null;
+    const output = result.stdout.replace(/\r/g, "").trim();
+    return output || null;
+}
+function resolveWindowsPathForHost(input) {
+    if (!input)
+        return null;
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    if (node_os_1.default.platform() === "win32")
+        return trimmed;
+    const match = /^([A-Za-z]):\\(.*)$/.exec(trimmed);
+    if (!match)
+        return null;
+    return node_path_1.default.posix.join("/mnt", match[1].toLowerCase(), match[2].replace(/\\/g, "/"));
+}
+function resolveWindowsHomeDirForHost() {
+    const reported = readWindowsCommandStdout("$env:USERPROFILE");
+    if (reported)
+        return resolveWindowsPathForHost(reported);
+    return node_os_1.default.platform() === "win32" ? node_os_1.default.homedir() : null;
+}
+function editorExtensionDirCandidates() {
+    const home = node_os_1.default.homedir();
+    const dirs = [];
+    if (node_os_1.default.platform() === "darwin") {
+        return uniqueStrings([
+            node_path_1.default.join(home, ".vscode", "extensions"),
+            node_path_1.default.join(home, ".vscode-insiders", "extensions"),
+            node_path_1.default.join(home, ".vscode-oss", "extensions"),
+        ]);
+    }
+    if (node_os_1.default.platform() === "win32") {
+        const homeDir = process.env.USERPROFILE?.trim() || home;
+        return uniqueStrings([
+            node_path_1.default.join(homeDir, ".vscode", "extensions"),
+            node_path_1.default.join(homeDir, ".vscode-insiders", "extensions"),
+            node_path_1.default.join(homeDir, ".vscode-oss", "extensions"),
+        ]);
+    }
+    dirs.push(node_path_1.default.join(home, ".vscode", "extensions"), node_path_1.default.join(home, ".vscode-insiders", "extensions"), node_path_1.default.join(home, ".vscode-oss", "extensions"));
+    if (isWslInteropRuntime()) {
+        const windowsHome = resolveWindowsHomeDirForHost();
+        if (windowsHome) {
+            dirs.push(node_path_1.default.join(windowsHome, ".vscode", "extensions"), node_path_1.default.join(windowsHome, ".vscode-insiders", "extensions"), node_path_1.default.join(windowsHome, ".vscode-oss", "extensions"));
+        }
+    }
+    return uniqueStrings(dirs);
+}
+async function findWritableCodexWebviewBundleFiles() {
+    const results = [];
+    for (const extensionDir of editorExtensionDirCandidates()) {
+        let entries = [];
+        try {
+            entries = await promises_1.default.readdir(extensionDir, { withFileTypes: true });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (!entry.name.toLowerCase().startsWith("openai.chatgpt-"))
+                continue;
+            const assetsDir = node_path_1.default.join(extensionDir, entry.name, "webview", "assets");
+            let assetEntries = [];
+            try {
+                assetEntries = await promises_1.default.readdir(assetsDir, { withFileTypes: true });
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            for (const assetEntry of assetEntries) {
+                if (!assetEntry.isFile())
+                    continue;
+                if (!assetEntry.name.endsWith(".js"))
+                    continue;
+                if (!assetEntry.name.startsWith("font-settings-") && !assetEntry.name.startsWith("index-"))
+                    continue;
+                const filePath = node_path_1.default.join(assetsDir, assetEntry.name);
+                try {
+                    await promises_1.default.access(filePath, 2);
+                    results.push(filePath);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    return uniqueStrings(results);
+}
+function patchDesktopIndexBundle(source) {
+    return source.replace(/let (\w+)=([\w$.]+)\.email\?\?void 0,(\w+)=\2\.userId\?\?void 0,(\w+)=(\w+)\?\?void 0,(\w+)=(\w+)\?\?void 0,(\w+);/g, "let $1=$2.email??void 0,$3=$2.userId??$7??$5??void 0,$4=$5??void 0,$6=$7??void 0,$8;");
+}
+function patchDesktopFontSettingsBundle(source) {
+    return source.replace(/if\((\w+)\.useHiddenModels\?\1\.availableModels\.has\((\w+)\.model\):!\2\.hidden\)\{/g, "if(!$2.hidden||$1.availableModels.has($2.model)){");
+}
+async function patchCodexWebviewBundles() {
+    const bundleFiles = await findWritableCodexWebviewBundleFiles();
+    let patched = 0;
+    for (const filePath of bundleFiles) {
+        const original = await promises_1.default.readFile(filePath, "utf8");
+        const next = filePath.includes(`${node_path_1.default.sep}font-settings-`)
+            ? patchDesktopFontSettingsBundle(original)
+            : patchDesktopIndexBundle(original);
+        if (next === original)
+            continue;
+        await promises_1.default.writeFile(filePath, next, "utf8");
+        patched += 1;
+    }
+    return { patched, scanned: bundleFiles.length };
+}
+function resolvePythonCommand() {
+    const candidates = [
+        { command: "python3", args: [] },
+        { command: "python", args: [] },
+        { command: "py", args: ["-3"] },
+    ];
+    for (const candidate of candidates) {
+        const result = (0, node_child_process_1.spawnSync)(candidate.command, [...candidate.args, "-c", "import sys; print(sys.version)"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (result.status === 0)
+            return candidate;
+    }
+    return null;
+}
+function venvPythonPath(venvDir) {
+    if (node_os_1.default.platform() === "win32") {
+        return node_path_1.default.join(venvDir, "Scripts", "python.exe");
+    }
+    return node_path_1.default.join(venvDir, "bin", "python");
+}
+function runPython(command, script, extraArgs = []) {
+    return (0, node_child_process_1.spawnSync)(command.command, [...command.args, "-c", script, ...extraArgs], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function pythonImportsLevelDb(command) {
+    const result = runPython(command, "import plyvel");
+    return result.status === 0;
+}
+async function ensureLocalPythonWithLevelDbSupport() {
+    const systemPython = resolvePythonCommand();
+    if (!systemPython)
+        return null;
+    if (pythonImportsLevelDb(systemPython))
+        return systemPython;
+    const venvDir = node_path_1.default.join(paths_1.theclawbayStateDir, "python", "leveldb");
+    const venvPython = venvPythonPath(venvDir);
+    const venvCommand = { command: venvPython, args: [] };
+    const existingVenv = (0, node_child_process_1.spawnSync)(venvPython, ["-c", "import sys; print(sys.executable)"], {
+        stdio: "ignore",
+    });
+    if (existingVenv.status !== 0) {
+        await promises_1.default.mkdir(node_path_1.default.dirname(venvDir), { recursive: true });
+        const createVenv = (0, node_child_process_1.spawnSync)(systemPython.command, [...systemPython.args, "-m", "venv", venvDir], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (createVenv.status !== 0)
+            return null;
+    }
+    if (!pythonImportsLevelDb(venvCommand)) {
+        const pipArgs = ["-m", "pip", "install", "--disable-pip-version-check", "plyvel-ci"];
+        let install = (0, node_child_process_1.spawnSync)(venvPython, pipArgs, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (install.status !== 0) {
+            install = (0, node_child_process_1.spawnSync)(venvPython, ["-m", "pip", "install", "--disable-pip-version-check", "plyvel"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            if (install.status !== 0)
+                return null;
+        }
+    }
+    return pythonImportsLevelDb(venvCommand) ? venvCommand : null;
+}
+async function findWindowsCodexPackageLevelDbDirs(windowsHome) {
+    const packagesRoot = node_path_1.default.join(windowsHome, "AppData", "Local", "Packages");
+    let entries = [];
+    try {
+        entries = await promises_1.default.readdir(packagesRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    return uniqueStrings(entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("OpenAI.Codex_"))
+        .map((entry) => node_path_1.default.join(packagesRoot, entry.name, "LocalCache", "Roaming", "Codex", "Local Storage", "leveldb")));
+}
+async function desktopStatsigLevelDbCandidates() {
+    const home = node_os_1.default.homedir();
+    const candidates = [];
+    if (node_os_1.default.platform() === "darwin") {
+        candidates.push(node_path_1.default.join(home, "Library", "Application Support", "Code", "Local Storage", "leveldb"), node_path_1.default.join(home, "Library", "Application Support", "Code - Insiders", "Local Storage", "leveldb"), node_path_1.default.join(home, "Library", "Application Support", "Codex", "Local Storage", "leveldb"), node_path_1.default.join(home, "Library", "Containers", "OpenAI.Codex", "Data", "Library", "Application Support", "Codex", "Local Storage", "leveldb"));
+    }
+    else if (node_os_1.default.platform() === "win32") {
+        const homeDir = process.env.USERPROFILE?.trim() || home;
+        candidates.push(node_path_1.default.join(homeDir, "AppData", "Roaming", "Code", "Local Storage", "leveldb"), node_path_1.default.join(homeDir, "AppData", "Roaming", "Code - Insiders", "Local Storage", "leveldb"));
+        candidates.push(...(await findWindowsCodexPackageLevelDbDirs(homeDir)));
+    }
+    else {
+        candidates.push(node_path_1.default.join(home, ".config", "Code", "Local Storage", "leveldb"), node_path_1.default.join(home, ".config", "Code - Insiders", "Local Storage", "leveldb"), node_path_1.default.join(home, ".config", "Codex", "Local Storage", "leveldb"));
+        if (isWslInteropRuntime()) {
+            const windowsHome = resolveWindowsHomeDirForHost();
+            if (windowsHome) {
+                candidates.push(node_path_1.default.join(windowsHome, "AppData", "Roaming", "Code", "Local Storage", "leveldb"), node_path_1.default.join(windowsHome, "AppData", "Roaming", "Code - Insiders", "Local Storage", "leveldb"));
+                candidates.push(...(await findWindowsCodexPackageLevelDbDirs(windowsHome)));
+            }
+        }
+    }
+    const existing = [];
+    for (const candidate of uniqueStrings(candidates)) {
+        if (await pathExists(candidate))
+            existing.push(candidate);
+    }
+    return existing;
+}
+function buildStatsigPatchScript() {
+    return [
+        "import json, sys",
+        "import plyvel",
+        "target_models = json.loads(sys.argv[1])",
+        `config_id = ${JSON.stringify(STATSIG_MODEL_PICKER_CONFIG_ID)}`,
+        "for db_path in sys.argv[2:]:",
+        "    result = {'db': db_path, 'patched': 0, 'error': None}",
+        "    try:",
+        "        db = plyvel.DB(db_path, create_if_missing=False)",
+        "    except Exception as exc:",
+        "        result['error'] = str(exc)",
+        "        print(json.dumps(result))",
+        "        continue",
+        "    try:",
+        "        for key, raw in db:",
+        "            if b'statsig.cached.evaluations.' not in key:",
+        "                continue",
+        "            try:",
+        "                text = raw.decode('utf-8')",
+        "                prefix = '\\x01' if text.startswith('\\x01') else ''",
+        "                if prefix:",
+        "                    text = text[1:]",
+        "                outer = json.loads(text)",
+        "                inner = json.loads(outer.get('data', '{}'))",
+        "                dynamic_configs = inner.get('dynamic_configs')",
+        "                if not isinstance(dynamic_configs, dict):",
+        "                    continue",
+        "                config = dynamic_configs.get(config_id)",
+        "                if not isinstance(config, dict):",
+        "                    continue",
+        "                value = config.get('value')",
+        "                if not isinstance(value, dict):",
+        "                    continue",
+        "                current_models = value.get('available_models')",
+        "                merged = []",
+        "                seen = set()",
+        "                for model_id in list(target_models) + (current_models if isinstance(current_models, list) else []):",
+        "                    if not isinstance(model_id, str):",
+        "                        continue",
+        "                    normalized = model_id.strip()",
+        "                    if not normalized or normalized in seen:",
+        "                        continue",
+        "                    seen.add(normalized)",
+        "                    merged.append(normalized)",
+        "                changed = False",
+        "                if value.get('use_hidden_models') is not False:",
+        "                    value['use_hidden_models'] = False",
+        "                    changed = True",
+        "                if value.get('available_models') != merged:",
+        "                    value['available_models'] = merged",
+        "                    changed = True",
+        "                if not changed:",
+        "                    continue",
+        "                outer['data'] = json.dumps(inner, separators=(',', ':'))",
+        "                encoded = (prefix + json.dumps(outer, separators=(',', ':'))).encode('utf-8')",
+        "                db.put(key, encoded)",
+        "                result['patched'] += 1",
+        "            except Exception:",
+        "                continue",
+        "    finally:",
+        "        db.close()",
+        "    print(json.dumps(result))",
+    ].join("\\n");
+}
+async function patchDesktopStatsigCaches() {
+    const dbDirs = await desktopStatsigLevelDbCandidates();
+    if (dbDirs.length === 0)
+        return { patched: 0, warnings: [] };
+    const python = await ensureLocalPythonWithLevelDbSupport();
+    if (!python) {
+        return {
+            patched: 0,
+            warnings: [
+                "Could not install the local desktop model-picker helper, so Codex app model labels may stay stale until the next supported cache refresh.",
+            ],
+        };
+    }
+    const run = (0, node_child_process_1.spawnSync)(python.command, [...python.args, "-c", buildStatsigPatchScript(), JSON.stringify(DESKTOP_MODEL_IDS), ...dbDirs], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (run.status !== 0) {
+        return {
+            patched: 0,
+            warnings: [
+                "Could not refresh the desktop model-picker cache. Close Codex app / VS Code and rerun setup if the picker still shows Custom.",
+            ],
+        };
+    }
+    let patched = 0;
+    const warnings = [];
+    const lines = (run.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            patched += typeof parsed.patched === "number" ? parsed.patched : 0;
+            if (typeof parsed.error === "string" && parsed.error.trim()) {
+                const dbLabel = typeof parsed.db === "string" ? parsed.db : "desktop cache";
+                warnings.push(`${dbLabel}: ${parsed.error.trim()}`);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return { patched, warnings };
+}
+async function ensureCodexDesktopModelPickerSupport() {
+    try {
+        const bundleResult = await patchCodexWebviewBundles();
+        const cacheResult = await patchDesktopStatsigCaches();
+        const warning = cacheResult.warnings.length > 0 ? cacheResult.warnings.join(" ") : undefined;
+        if (bundleResult.patched > 0 || cacheResult.patched > 0) {
+            return {
+                action: "patched",
+                warning,
+                patchedBundles: bundleResult.patched,
+                patchedCaches: cacheResult.patched,
+            };
+        }
+        if (warning) {
+            return {
+                action: "skipped",
+                warning,
+                patchedBundles: 0,
+                patchedCaches: 0,
+            };
+        }
+        return {
+            action: "already_patched",
+            patchedBundles: 0,
+            patchedCaches: 0,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            action: "skipped",
+            warning: `Could not refresh the desktop model picker: ${message}`,
+            patchedBundles: 0,
+            patchedCaches: 0,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.65",
+  "version": "0.3.66",
   "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": {