theclawbay 0.2.13 → 0.3.2

package/dist/lib/codex-history-migration.d.ts

@@ -0,0 +1,23 @@
+export type SessionProviderMigrationResult = {
+    scanned: number;
+    rewritten: number;
+    skipped: number;
+    retimed: number;
+    fastSkipped: boolean;
+};
+export type StateDbProviderMigrationResult = {
+    found: number;
+    updated: number;
+    failed: string[];
+    warning?: string;
+};
+export declare function migrateSessionProviders(params: {
+    codexHome: string;
+    migrationStateFile: string;
+    neutralizeSources: Set<string>;
+}): Promise<SessionProviderMigrationResult>;
+export declare function migrateStateDbProviders(params: {
+    codexHome: string;
+    targetProvider: string;
+    sourceProviders: string[];
+}): Promise<StateDbProviderMigrationResult>;

package/dist/lib/codex-history-migration.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateSessionProviders = migrateSessionProviders;
+exports.migrateStateDbProviders = migrateStateDbProviders;
+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 STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
+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;
+}
+function renderProgressBar(current, total) {
+    if (total <= 0)
+        return "";
+    const width = 24;
+    const ratio = Math.max(0, Math.min(1, current / total));
+    const filled = Math.round(width * ratio);
+    return `[${"#".repeat(filled)}${"-".repeat(width - filled)}] ${Math.round(ratio * 100)
+        .toString()
+        .padStart(3, " ")}%`;
+}
+function inferRolloutUpdatedAt(source) {
+    const lines = source.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const trimmed = (lines[i] ?? "").trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.timestamp !== "string")
+                continue;
+            const ms = Date.parse(parsed.timestamp);
+            if (!Number.isFinite(ms))
+                continue;
+            return new Date(ms);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function listSessionRollouts(root) {
+    const results = [];
+    const walk = async (dir) => {
+        let entries = [];
+        try {
+            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT")
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const nextPath = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(nextPath);
+                continue;
+            }
+            if (entry.isFile() && nextPath.endsWith(".jsonl")) {
+                results.push(nextPath);
+            }
+        }
+    };
+    await walk(root);
+    return results;
+}
+async function readMigrationState(migrationStateFile) {
+    try {
+        const raw = await promises_1.default.readFile(migrationStateFile, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version === 1 &&
+            typeof parsed.fileCount === "number" &&
+            Number.isFinite(parsed.fileCount) &&
+            typeof parsed.maxMtimeMs === "number" &&
+            Number.isFinite(parsed.maxMtimeMs)) {
+            return {
+                version: 1,
+                fileCount: Math.max(0, Math.floor(parsed.fileCount)),
+                maxMtimeMs: Math.max(0, Math.floor(parsed.maxMtimeMs)),
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeMigrationState(migrationStateFile, state) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(migrationStateFile), { recursive: true });
+    await promises_1.default.writeFile(migrationStateFile, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+async function computeSessionSnapshot(files) {
+    let maxMtimeMs = 0;
+    for (const file of files) {
+        try {
+            const stats = await promises_1.default.stat(file);
+            const mtimeMs = Math.floor(stats.mtimeMs);
+            if (mtimeMs > maxMtimeMs)
+                maxMtimeMs = mtimeMs;
+        }
+        catch {
+            // ignore transient missing file/race
+        }
+    }
+    return { fileCount: files.length, maxMtimeMs };
+}
+async function migrateSessionProviders(params) {
+    const sessionsRoot = node_path_1.default.join(params.codexHome, "sessions");
+    const files = await listSessionRollouts(sessionsRoot);
+    const snapshot = await computeSessionSnapshot(files);
+    const previousState = await readMigrationState(params.migrationStateFile);
+    if (previousState &&
+        previousState.fileCount === snapshot.fileCount &&
+        previousState.maxMtimeMs === snapshot.maxMtimeMs) {
+        return { scanned: 0, rewritten: 0, skipped: 0, retimed: 0, fastSkipped: true };
+    }
+    let rewritten = 0;
+    let skipped = 0;
+    let retimed = 0;
+    const useProgress = process.stdout.isTTY && files.length > 0;
+    const drawProgress = (current) => {
+        if (!useProgress)
+            return;
+        const bar = renderProgressBar(current, files.length);
+        process.stdout.write(`\rMigrating conversations ${current}/${files.length} ${bar}`);
+        if (current >= files.length)
+            process.stdout.write("\n");
+    };
+    drawProgress(0);
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        let source = "";
+        let originalStats = null;
+        try {
+            source = await promises_1.default.readFile(file, "utf8");
+            originalStats = await promises_1.default.stat(file);
+        }
+        catch {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        const desiredMtime = inferRolloutUpdatedAt(source) ?? originalStats.mtime;
+        const desiredAtime = originalStats.atime;
+        const maybeRetainMtime = async () => {
+            const diffMs = Math.abs(desiredMtime.getTime() - originalStats.mtime.getTime());
+            if (diffMs <= 1500)
+                return;
+            try {
+                await promises_1.default.utimes(file, desiredAtime, desiredMtime);
+                retimed++;
+            }
+            catch {
+                // best-effort only
+            }
+        };
+        if (!source.trim()) {
+            skipped++;
+            await maybeRetainMtime();
+            drawProgress(i + 1);
+            continue;
+        }
+        const lines = source.split(/\r?\n/);
+        const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
+        if (firstNonEmptyIndex < 0) {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(lines[firstNonEmptyIndex] ?? "");
+        }
+        catch {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        if ((parsed.type ?? "") !== "session_meta") {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        const payload = parsed.payload;
+        if (!payload || typeof payload !== "object") {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        const currentProvider = payload.model_provider;
+        if (typeof currentProvider !== "string") {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        if (!params.neutralizeSources.has(currentProvider)) {
+            skipped++;
+            drawProgress(i + 1);
+            continue;
+        }
+        // Remove explicit provider tag so the same thread stays visible across provider contexts.
+        delete payload.model_provider;
+        lines[firstNonEmptyIndex] = JSON.stringify(parsed);
+        const next = lines.join("\n");
+        if (next === source) {
+            skipped++;
+            await maybeRetainMtime();
+            drawProgress(i + 1);
+            continue;
+        }
+        await promises_1.default.writeFile(file, next, "utf8");
+        await maybeRetainMtime();
+        rewritten++;
+        drawProgress(i + 1);
+    }
+    await writeMigrationState(params.migrationStateFile, {
+        version: 1,
+        fileCount: snapshot.fileCount,
+        maxMtimeMs: snapshot.maxMtimeMs,
+    });
+    return { scanned: files.length, rewritten, skipped, retimed, fastSkipped: false };
+}
+async function listStateDbFiles(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))
+        .sort();
+}
+async function migrateStateDbProviders(params) {
+    const dbPaths = await listStateDbFiles(params.codexHome);
+    if (dbPaths.length === 0) {
+        return { found: 0, updated: 0, failed: [] };
+    }
+    const python = resolvePythonCommand();
+    if (!python) {
+        return {
+            found: dbPaths.length,
+            updated: 0,
+            failed: dbPaths,
+            warning: "Python with sqlite3 support was not found.",
+        };
+    }
+    const script = `
+import json
+import sqlite3
+import sys
+
+db_paths = json.loads(sys.argv[1])
+target_provider = sys.argv[2]
+source_providers = json.loads(sys.argv[3])
+
+result = {"updated": 0, "failed": []}
+
+for db_path in db_paths:
+    try:
+        conn = sqlite3.connect(db_path, timeout=2.0)
+        conn.execute("PRAGMA busy_timeout = 2000")
+        table_exists = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='threads' LIMIT 1"
+        ).fetchone()
+        if not table_exists:
+            conn.close()
+            continue
+
+        placeholders = ",".join("?" for _ in source_providers)
+        sql = f"UPDATE threads SET model_provider = ? WHERE model_provider IN ({placeholders})"
+        cursor = conn.execute(sql, [target_provider, *source_providers])
+        conn.commit()
+        result["updated"] += max(cursor.rowcount, 0)
+        conn.close()
+    except Exception:
+        result["failed"].append(db_path)
+
+print(json.dumps(result))
+`.trim();
+    const result = (0, node_child_process_1.spawnSync)(python.command, [...python.args, "-c", script, JSON.stringify(dbPaths), params.targetProvider, JSON.stringify(params.sourceProviders)], { encoding: "utf8" });
+    if (result.status !== 0) {
+        return {
+            found: dbPaths.length,
+            updated: 0,
+            failed: dbPaths,
+            warning: (result.stderr || result.stdout || "SQLite migration failed.").trim(),
+        };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout || "{}");
+        const failed = Array.isArray(parsed.failed)
+            ? parsed.failed.filter((value) => typeof value === "string" && value.length > 0)
+            : [];
+        return {
+            found: dbPaths.length,
+            updated: typeof parsed.updated === "number" && Number.isFinite(parsed.updated) ? Math.max(0, Math.floor(parsed.updated)) : 0,
+            failed,
+        };
+    }
+    catch {
+        return {
+            found: dbPaths.length,
+            updated: 0,
+            failed: dbPaths,
+            warning: "SQLite migration returned unreadable output.",
+        };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "theclawbay",
-  "version": "0.2.13",
-  "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access, with optional relay fallback.",
+  "version": "0.3.2",
+  "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access.",
   "license": "MIT",
   "bin": {
     "theclawbay": "dist/index.js"
@@ -14,6 +14,7 @@
     "release:patch": "./scripts/release-npm.sh patch",
     "release:minor": "./scripts/release-npm.sh minor",
     "release:major": "./scripts/release-npm.sh major",
+    "release:publish": "./scripts/release-npm.sh none",
     "release:dry-run": "./scripts/release-npm.sh patch --dry-run"
   },
   "engines": {
@@ -30,9 +31,7 @@
     "cli",
     "setup",
     "wan",
-    "proxy",
-    "api-key",
-    "relay"
+    "api-key"
   ],
   "preferGlobal": true,
   "dependencies": {

package/dist/commands/proxy.d.ts

@@ -1,13 +0,0 @@
-import { BaseCommand } from "../lib/base-command";
-export default class ProxyCommand extends BaseCommand {
-    static description: string;
-    static flags: {
-        host: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        port: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
-        backend: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        "api-key": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        "base-path": import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        client: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-}