theclawbay 0.3.63 → 0.3.64

package/dist/commands/setup.js

@@ -2986,7 +2986,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             let restoredClaudeDesktop3pConfig = false;
             let claudeDesktop3pConfigPathManaged = null;
             let sessionMigration = null;
-            let authSeedCleanup = null;
+            let authSeedResult = null;
             let stateDbMigration = null;
             let modelCacheMigration = null;
             let continueConfigPath = null;
@@ -3088,8 +3088,10 @@ class SetupCommand extends base_command_1.BaseCommand {
                             neutralizeSources: HISTORY_PROVIDER_NEUTRALIZE_SOURCES,
                         });
                     }
-                    authSeedCleanup = await (0, codex_auth_seeding_1.cleanupSeededCodexAuth)({
+                    authSeedResult = await (0, codex_auth_seeding_1.ensureCodexApiKeyAuth)({
                         codexHome: paths_1.codexDir,
+                        apiKey: authCredential,
+                        replaceExistingAuth: true,
                     });
                     if (migrateCodexConversations) {
                         stateDbMigration = await (0, codex_history_migration_1.migrateStateDbProviders)({
@@ -3229,13 +3231,11 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             if (modelCacheMigration?.warning)
                 summaryNotes.add(modelCacheMigration.warning);
-            if (authSeedCleanup?.warning)
-                summaryNotes.add(authSeedCleanup.warning);
-            if (authSeedCleanup?.action === "removed") {
-                summaryNotes.add("Removed an older The Claw Bay Codex auth override that newer Codex releases now treat as invalid ChatGPT OAuth.");
-            }
-            else if (authSeedCleanup?.action === "restored_backup") {
-                summaryNotes.add("Restored the Codex auth that existed before an older The Claw Bay auth override.");
+            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.");
             }
             if (selectedSetupClients.has("codex") && !migrateCodexConversations) {
                 summaryNotes.add("Left existing Codex conversations untouched.");
@@ -3338,17 +3338,22 @@ class SetupCommand extends base_command_1.BaseCommand {
                 else if (modelCacheMigration) {
                     this.log("- Codex model cache: no change.");
                 }
-                if (authSeedCleanup?.action === "restored_backup") {
-                    this.log("- Codex login state: restored the auth that existed before an older The Claw Bay override.");
+                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.");
+                }
+                else if (authSeedResult?.action === "updated") {
+                    this.log("- Codex login state: refreshed the local The Claw Bay API-key auth seed.");
                 }
-                else if (authSeedCleanup?.action === "removed") {
-                    this.log("- Codex login state: removed the older The Claw Bay ChatGPT-token override for compatibility with current Codex releases.");
+                else if (authSeedResult?.action === "already_seeded") {
+                    this.log("- Codex login state: local desktop auth was already pinned to The Claw Bay API-key mode.");
                 }
-                else if (authSeedCleanup?.warning) {
-                    this.log(`- Codex login state: ${authSeedCleanup.warning}`);
+                else if (authSeedResult?.warning) {
+                    this.log(`- Codex login state: ${authSeedResult.warning}`);
                 }
                 else {
-                    this.log("- Codex login state: using provider-scoped bearer auth only; no fake ChatGPT auth tokens were seeded.");
+                    this.log("- Codex login state: no change.");
                 }
             }
             else if (codexDetected) {

package/dist/lib/codex-auth-seeding.d.ts

@@ -12,10 +12,12 @@ export type CleanupCodexAuthResult = {
 export declare function ensureCodexApiKeyAuth(params: {
     codexHome: string;
     apiKey: string;
+    replaceExistingAuth?: boolean;
 }): Promise<EnsureCodexAuthResult>;
 export declare function ensureCodexUsageLimitAuth(params: {
     codexHome: string;
     apiKey: string;
+    replaceExistingAuth?: boolean;
 }): Promise<EnsureCodexAuthResult>;
 export declare function cleanupSeededCodexAuth(params: {
     codexHome: string;

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

@@ -236,7 +236,7 @@ async function ensureCodexApiKeyAuth(params) {
         codexHome: params.codexHome,
         apiKey: params.apiKey,
         mode: "api-key",
-        replaceExistingAuth: false,
+        replaceExistingAuth: params.replaceExistingAuth ?? false,
     });
 }
 async function ensureCodexUsageLimitAuth(params) {

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

@@ -265,6 +265,159 @@ function runVersionCommand(command, args) {
         return null;
     return parseCodexVersion(`${run.stdout ?? ""}\n${run.stderr ?? ""}`);
 }
+function compareCodexVersions(left, right) {
+    const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
+    const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
+    const maxLen = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < maxLen; index += 1) {
+        const leftPart = leftParts[index] ?? 0;
+        const rightPart = rightParts[index] ?? 0;
+        if (leftPart !== rightPart)
+            return leftPart - rightPart;
+    }
+    return 0;
+}
+function highestCodexVersion(candidates) {
+    const versions = candidates
+        .map((candidate) => (candidate ? parseCodexVersion(candidate) : null))
+        .filter((candidate) => Boolean(candidate));
+    if (versions.length === 0)
+        return null;
+    versions.sort((left, right) => compareCodexVersions(right, left));
+    return versions[0] ?? null;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+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 next = result.stdout.replace(/\r/g, "").trim();
+    return next ? next : 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;
+    const drive = match[1].toLowerCase();
+    const rest = match[2].replace(/\\/g, "/");
+    return node_path_1.default.posix.join("/mnt", drive, rest);
+}
+function resolveWindowsHomeDirForHost() {
+    const reported = readWindowsCommandStdout("$env:USERPROFILE");
+    if (reported)
+        return resolveWindowsPathForHost(reported);
+    if (node_os_1.default.platform() === "win32")
+        return node_os_1.default.homedir();
+    return null;
+}
+function editorExtensionDirCandidates() {
+    const home = node_os_1.default.homedir();
+    const dirs = [];
+    if (node_os_1.default.platform() === "darwin") {
+        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, ".cursor", "extensions"), node_path_1.default.join(home, ".windsurf", "extensions"), node_path_1.default.join(home, ".vscode-oss", "extensions"));
+        return uniqueStrings(dirs);
+    }
+    if (node_os_1.default.platform() === "win32") {
+        const homeDir = process.env.USERPROFILE?.trim() || home;
+        dirs.push(node_path_1.default.join(homeDir, ".vscode", "extensions"), node_path_1.default.join(homeDir, ".vscode-insiders", "extensions"), node_path_1.default.join(homeDir, ".cursor", "extensions"), node_path_1.default.join(homeDir, ".windsurf", "extensions"), node_path_1.default.join(homeDir, ".vscode-oss", "extensions"));
+        return uniqueStrings(dirs);
+    }
+    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, ".cursor", "extensions"), node_path_1.default.join(home, ".windsurf", "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, ".cursor", "extensions"), node_path_1.default.join(windowsHome, ".windsurf", "extensions"), node_path_1.default.join(windowsHome, ".vscode-oss", "extensions"));
+        }
+    }
+    return uniqueStrings(dirs);
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function codexBinaryCandidatesForBinRoot(binRoot) {
+    const runtimePreferred = node_os_1.default.platform() === "win32"
+        ? [
+            node_path_1.default.join(binRoot, "windows-x86_64", "codex.exe"),
+            node_path_1.default.join(binRoot, "windows-arm64", "codex.exe"),
+        ]
+        : node_os_1.default.platform() === "darwin"
+            ? [
+                node_path_1.default.join(binRoot, "darwin-aarch64", "codex"),
+                node_path_1.default.join(binRoot, "darwin-arm64", "codex"),
+                node_path_1.default.join(binRoot, "darwin-x86_64", "codex"),
+            ]
+            : [
+                node_path_1.default.join(binRoot, "linux-x86_64", "codex"),
+                node_path_1.default.join(binRoot, "linux-arm64", "codex"),
+            ];
+    return uniqueStrings([
+        ...runtimePreferred,
+        node_path_1.default.join(binRoot, "codex"),
+        node_path_1.default.join(binRoot, "codex.exe"),
+    ]);
+}
+async function inferCodexClientVersionsFromInstalledExtensions() {
+    const versions = new Set();
+    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 binRoot = node_path_1.default.join(extensionDir, entry.name, "bin");
+            for (const candidate of codexBinaryCandidatesForBinRoot(binRoot)) {
+                if (!(await pathExists(candidate)))
+                    continue;
+                const parsed = runVersionCommand(candidate, ["--version"]);
+                if (parsed)
+                    versions.add(parsed);
+            }
+        }
+    }
+    return [...versions];
+}
+async function inferCodexClientVersionFromVersionJson(codexHome) {
+    const parsed = await readJsonIfExists(node_path_1.default.join(codexHome, "version.json"));
+    const obj = objectRecordOr(parsed);
+    if (!obj)
+        return null;
+    const latestVersion = typeof obj.latest_version === "string" ? obj.latest_version : "";
+    return latestVersion ? parseCodexVersion(latestVersion) : null;
+}
 function resolvePythonCommand() {
     const candidates = [
         { command: "python3", args: ["-c", "import sqlite3"] },
@@ -355,20 +508,29 @@ async function inferCodexClientVersionFromStateDb(codexHome) {
     return null;
 }
 async function inferCodexClientVersion(codexHome) {
+    const versions = [];
     if (node_os_1.default.platform() === "win32") {
         for (const commandLine of ["codex --version", "codex-cli --version", "codex.cmd --version", "codex-cli.cmd --version"]) {
             const parsed = runVersionCommand("cmd.exe", ["/d", "/s", "/c", commandLine]);
             if (parsed)
-                return parsed;
+                versions.push(parsed);
         }
-        return await inferCodexClientVersionFromStateDb(codexHome);
     }
-    for (const command of ["codex", "codex-cli"]) {
-        const parsed = runVersionCommand(command, ["--version"]);
-        if (parsed)
-            return parsed;
+    else {
+        for (const command of ["codex", "codex-cli"]) {
+            const parsed = runVersionCommand(command, ["--version"]);
+            if (parsed)
+                versions.push(parsed);
+        }
     }
-    return await inferCodexClientVersionFromStateDb(codexHome);
+    versions.push(...await inferCodexClientVersionsFromInstalledExtensions());
+    const versionJsonVersion = await inferCodexClientVersionFromVersionJson(codexHome);
+    if (versionJsonVersion)
+        versions.push(versionJsonVersion);
+    const stateDbVersion = await inferCodexClientVersionFromStateDb(codexHome);
+    if (stateDbVersion)
+        versions.push(stateDbVersion);
+    return highestCodexVersion(versions);
 }
 function normalizeCacheDocument(value) {
     const doc = objectRecordOr(value);

package/package.json

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