theclawbay 0.3.5 → 0.3.7

package/dist/commands/setup.js

@@ -208,7 +208,7 @@ async function writeCodexConfig(params) {
         'name = "OpenAI"',
         `base_url = "${proxyRoot}/backend-api/codex"`,
         'wire_api = "responses"',
-        "requires_openai_auth = true",
+        "requires_openai_auth = false",
         `experimental_bearer_token = "${params.apiKey}"`,
         MANAGED_END,
     ]);

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

@@ -12,6 +12,7 @@ const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
 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_ID = "gpt-5.4";
 const SEED_MARKER_KEY = "_theclawbay_seeded";
 const SEED_MARKER_VALUE = "gpt-5.4";
@@ -208,21 +209,110 @@ function runVersionCommand(command, args) {
         return null;
     return parseCodexVersion(`${run.stdout ?? ""}\n${run.stderr ?? ""}`);
 }
-function inferCodexClientVersion() {
+function resolvePythonCommand() {
+    const candidates = [
+        { command: "python3", args: ["-c", "import sqlite3"] },
+        { command: "python", args: ["-c", "import sqlite3"] },
+        { command: "py", args: ["-3", "-c", "import sqlite3"] },
+    ];
+    for (const candidate of candidates) {
+        const result = (0, node_child_process_1.spawnSync)(candidate.command, candidate.args, { stdio: "ignore" });
+        if (result.status === 0) {
+            return {
+                command: candidate.command,
+                args: candidate.args.slice(0, -2),
+            };
+        }
+    }
+    return null;
+}
+async function listStateDbs(codexHome) {
+    let entries = [];
+    try {
+        entries = await promises_1.default.readdir(codexHome, { withFileTypes: true });
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    return entries
+        .filter((entry) => entry.isFile() && STATE_DB_FILE_PATTERN.test(entry.name))
+        .map((entry) => node_path_1.default.join(codexHome, entry.name));
+}
+async function inferCodexClientVersionFromStateDb(codexHome) {
+    const python = resolvePythonCommand();
+    if (!python)
+        return null;
+    const dbs = await listStateDbs(codexHome);
+    if (dbs.length === 0)
+        return null;
+    const dated = await Promise.all(dbs.map(async (dbPath) => {
+        try {
+            const stats = await promises_1.default.stat(dbPath);
+            return { dbPath, mtimeMs: stats.mtimeMs };
+        }
+        catch {
+            return { dbPath, mtimeMs: 0 };
+        }
+    }));
+    dated.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    const script = [
+        "import sqlite3, sys",
+        "db_path = sys.argv[1]",
+        "query = \"\"\"",
+        "SELECT cli_version",
+        "FROM threads",
+        "WHERE cli_version IS NOT NULL AND TRIM(cli_version) != ''",
+        "ORDER BY updated_at DESC",
+        "LIMIT 50",
+        "\"\"\"",
+        "conn = sqlite3.connect(db_path)",
+        "cur = conn.cursor()",
+        "try:",
+        "    rows = cur.execute(query).fetchall()",
+        "except Exception:",
+        "    rows = []",
+        "finally:",
+        "    conn.close()",
+        "for row in rows:",
+        "    value = row[0] if row else ''",
+        "    if isinstance(value, str) and value.strip():",
+        "        print(value.strip())",
+    ].join("\n");
+    for (const entry of dated) {
+        const run = (0, node_child_process_1.spawnSync)(python.command, [...python.args, "-c", script, entry.dbPath], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (run.status !== 0)
+            continue;
+        const versions = (run.stdout ?? "")
+            .split(/\r?\n/)
+            .map((line) => parseCodexVersion(line))
+            .filter((line) => Boolean(line));
+        if (versions.length > 0) {
+            return versions[0] ?? null;
+        }
+    }
+    return null;
+}
+async function inferCodexClientVersion(codexHome) {
     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;
         }
-        return null;
+        return await inferCodexClientVersionFromStateDb(codexHome);
     }
     for (const command of ["codex", "codex-cli"]) {
         const parsed = runVersionCommand(command, ["--version"]);
         if (parsed)
             return parsed;
     }
-    return null;
+    return await inferCodexClientVersionFromStateDb(codexHome);
 }
 function normalizeCacheDocument(value) {
     const doc = objectRecordOr(value);
@@ -240,7 +330,7 @@ async function ensureCodexModelCacheHasGpt54(params) {
         const existingState = await readPatchState(statePath);
         const parsed = await readJsonIfExists(cachePath);
         if (parsed === null) {
-            const clientVersion = inferCodexClientVersion();
+            const clientVersion = await inferCodexClientVersion(params.codexHome);
             if (!clientVersion) {
                 await removeFileIfExists(statePath);
                 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access.",
   "license": "MIT",
   "bin": {