theclawbay 0.2.13 → 0.3.2

package/README.md

@@ -60,20 +60,29 @@ After setup, restart terminal/VS Code once only if your own shell workflows depe
 - Full ChatGPT account model-picker behavior is tied to ChatGPT auth mode.
 - `theclawbay setup` keeps your existing Codex login state unchanged on purpose (so local history context is preserved and setup stays non-destructive).
 
-## Run Relay (Optional)
+## Link Only (Optional)
 
-Only needed as a fallback compatibility mode:
+If you only want to save backend/API-key state without applying local client config yet:
 
 ```sh
 theclawbay link --api-key <apiKey>
-theclawbay proxy
 ```
 
-By default this starts a local relay on `http://127.0.0.1:2455` and forwards to:
+## Logout
 
-- `https://theclawbay.com/api/codex-auth/v1/proxy/...`
+To remove local The Claw Bay API-key auth state from this machine:
 
-The command auto-detects whether `openclaw` and/or `opencode` are installed and configures them automatically.
+```sh
+theclawbay logout
+```
+
+## Release Notes (Maintainers)
+
+If a previous publish failed after version bump, publish the current local version without bumping again:
+
+```sh
+npm run release:publish
+```
 
 ## Notes
 

package/dist/commands/link.js

@@ -20,7 +20,7 @@ class LinkCommand extends base_command_1.BaseCommand {
             });
             this.log(`Linked. Managed config written to ${paths_1.managedConfigPath}`);
             this.log(`Backend: ${backendUrl}`);
-            this.log(`Run "theclawbay proxy" to start the local relay.`);
+            this.log(`Run "theclawbay setup" to configure Codex/OpenClaw/OpenCode on this machine.`);
         });
     }
 }

package/dist/commands/logout.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from "../lib/base-command";
+export default class LogoutCommand extends BaseCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 base_command_1 = require("../lib/base-command");
+const codex_history_migration_1 = require("../lib/codex-history-migration");
+const paths_1 = require("../lib/config/paths");
+const OPENAI_PROVIDER_ID = "openai";
+const DEFAULT_PROVIDER_ID = "theclawbay";
+const LEGACY_PROVIDER_ID = "codex-lb";
+const WAN_PROVIDER_ID = "theclawbay-wan";
+const MANAGED_START = "# theclawbay-managed:start";
+const MANAGED_END = "# theclawbay-managed:end";
+const SHELL_START = "# theclawbay-shell-managed:start";
+const SHELL_END = "# theclawbay-shell-managed:end";
+const ENV_FILE = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay", "env");
+const ENV_KEY_NAME = "CODEX_LB_API_KEY";
+const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
+const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
+    OPENAI_PROVIDER_ID,
+    WAN_PROVIDER_ID,
+    DEFAULT_PROVIDER_ID,
+    LEGACY_PROVIDER_ID,
+]);
+const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = [DEFAULT_PROVIDER_ID, WAN_PROVIDER_ID, LEGACY_PROVIDER_ID];
+function removeManagedBlock(source, start, end) {
+    const markerStart = source.indexOf(start);
+    if (markerStart < 0)
+        return source;
+    const markerEnd = source.indexOf(end, markerStart);
+    if (markerEnd < 0)
+        return `${source.slice(0, markerStart).trimEnd()}\n`;
+    return `${(source.slice(0, markerStart) + source.slice(markerEnd + end.length)).trimEnd()}\n`;
+}
+function removeProviderTable(source, providerId) {
+    const header = `[model_providers.${providerId}]`;
+    const lines = source.split(/\r?\n/);
+    const output = [];
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() !== header) {
+            output.push(lines[i] ?? "");
+            continue;
+        }
+        i++;
+        while (i < lines.length && !/^\s*\[[^\]]+\]\s*$/.test(lines[i] ?? ""))
+            i++;
+        i--;
+    }
+    return `${output.join("\n").trimEnd()}\n`;
+}
+function removeTopLevelProviderSelection(source) {
+    const lines = source.split(/\r?\n/);
+    const filtered = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*\[/.test(line)) {
+            filtered.push(...lines.slice(i));
+            break;
+        }
+        if (/^\s*#/.test(line) || !line.trim()) {
+            filtered.push(line);
+            continue;
+        }
+        const match = line.match(/^\s*model_provider\s*=\s*"([^"]+)"\s*$/);
+        if (!match) {
+            filtered.push(line);
+            continue;
+        }
+        if (match[1] === DEFAULT_PROVIDER_ID || match[1] === LEGACY_PROVIDER_ID)
+            continue;
+        filtered.push(line);
+    }
+    return `${filtered.join("\n").trimEnd()}\n`;
+}
+async function readFileIfExists(filePath) {
+    try {
+        return await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function removeFileIfExists(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function writeIfChanged(filePath, next, previous) {
+    if (next === previous)
+        return false;
+    await promises_1.default.writeFile(filePath, next, "utf8");
+    return true;
+}
+function objectRecordOr(value, fallback) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value))
+        return { ...value };
+    return fallback;
+}
+async function cleanupCodexConfig() {
+    const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
+    const existing = await readFileIfExists(configPath);
+    if (existing === null)
+        return false;
+    let next = existing;
+    next = removeManagedBlock(next, MANAGED_START, MANAGED_END);
+    next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
+    next = removeProviderTable(next, LEGACY_PROVIDER_ID);
+    next = removeTopLevelProviderSelection(next);
+    return writeIfChanged(configPath, next, existing);
+}
+async function cleanupShellFiles() {
+    const updated = [];
+    const shellRcPaths = [".bashrc", ".zshrc", ".profile"].map((name) => node_path_1.default.join(node_os_1.default.homedir(), name));
+    for (const rcPath of shellRcPaths) {
+        const existing = await readFileIfExists(rcPath);
+        if (existing === null)
+            continue;
+        const next = removeManagedBlock(existing, SHELL_START, SHELL_END);
+        if (await writeIfChanged(rcPath, next, existing))
+            updated.push(rcPath);
+    }
+    return updated;
+}
+async function cleanupVsCodeHooks() {
+    const updated = [];
+    const homes = [".vscode-server", ".vscode-server-insiders"];
+    for (const home of homes) {
+        const setupPath = node_path_1.default.join(node_os_1.default.homedir(), home, "server-env-setup");
+        const existing = await readFileIfExists(setupPath);
+        if (existing === null)
+            continue;
+        const next = removeManagedBlock(existing, SHELL_START, SHELL_END);
+        if (await writeIfChanged(setupPath, next, existing))
+            updated.push(setupPath);
+    }
+    return updated;
+}
+async function cleanupOpenClawConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
+    const existingRaw = await readFileIfExists(configPath);
+    if (existingRaw === null || !existingRaw.trim())
+        return false;
+    let doc;
+    try {
+        doc = objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    const modelsRoot = objectRecordOr(doc.models, {});
+    const providersRoot = objectRecordOr(modelsRoot.providers, {});
+    for (const id of [DEFAULT_PROVIDER_ID, LEGACY_PROVIDER_ID]) {
+        if (id in providersRoot) {
+            delete providersRoot[id];
+            changed = true;
+        }
+    }
+    modelsRoot.providers = providersRoot;
+    doc.models = modelsRoot;
+    const agentsRoot = objectRecordOr(doc.agents, {});
+    const defaultsRoot = objectRecordOr(agentsRoot.defaults, {});
+    const modelRoot = objectRecordOr(defaultsRoot.model, {});
+    const primary = modelRoot.primary;
+    if (typeof primary === "string" &&
+        (primary.startsWith(`${DEFAULT_PROVIDER_ID}/`) || primary.startsWith(`${LEGACY_PROVIDER_ID}/`))) {
+        delete modelRoot.primary;
+        changed = true;
+    }
+    defaultsRoot.model = modelRoot;
+    agentsRoot.defaults = defaultsRoot;
+    doc.agents = agentsRoot;
+    if (!changed)
+        return false;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return true;
+}
+async function cleanupOpenCodeConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
+    const existingRaw = await readFileIfExists(configPath);
+    if (existingRaw === null || !existingRaw.trim())
+        return false;
+    let doc;
+    try {
+        doc = objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    const providerRoot = objectRecordOr(doc.provider, {});
+    for (const id of [DEFAULT_PROVIDER_ID, LEGACY_PROVIDER_ID]) {
+        if (id in providerRoot) {
+            delete providerRoot[id];
+            changed = true;
+        }
+    }
+    doc.provider = providerRoot;
+    const model = doc.model;
+    if (typeof model === "string" &&
+        (model.startsWith(`${DEFAULT_PROVIDER_ID}/`) || model.startsWith(`${LEGACY_PROVIDER_ID}/`))) {
+        delete doc.model;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return true;
+}
+class LogoutCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const deletedManagedPaths = (await Promise.all([
+                removeFileIfExists(paths_1.managedConfigPath),
+                removeFileIfExists(paths_1.legacyManagedConfigPathClayBay),
+                removeFileIfExists(paths_1.legacyManagedConfigPathCodexAuth),
+            ])).filter(Boolean).length;
+            const removedEnvFile = await removeFileIfExists(ENV_FILE);
+            const updatedShellFiles = await cleanupShellFiles();
+            const updatedVsCodeHooks = await cleanupVsCodeHooks();
+            const updatedCodexConfig = await cleanupCodexConfig();
+            const updatedOpenClawConfig = await cleanupOpenClawConfig();
+            const updatedOpenCodeConfig = await cleanupOpenCodeConfig();
+            const sessionMigration = await (0, codex_history_migration_1.migrateSessionProviders)({
+                codexHome: paths_1.codexDir,
+                migrationStateFile: MIGRATION_STATE_FILE,
+                neutralizeSources: HISTORY_PROVIDER_NEUTRALIZE_SOURCES,
+            });
+            const stateDbMigration = await (0, codex_history_migration_1.migrateStateDbProviders)({
+                codexHome: paths_1.codexDir,
+                targetProvider: OPENAI_PROVIDER_ID,
+                sourceProviders: HISTORY_PROVIDER_DB_MIGRATE_SOURCES,
+            });
+            delete process.env[ENV_KEY_NAME];
+            this.log("Logout complete");
+            this.log(`- Managed configs removed: ${deletedManagedPaths}`);
+            this.log(`- API key env file removed: ${removedEnvFile ? "yes" : "no"}`);
+            this.log(`- Shell profiles updated: ${updatedShellFiles.length ? updatedShellFiles.join(", ") : "none"}`);
+            this.log(`- VS Code env hooks updated: ${updatedVsCodeHooks.length ? updatedVsCodeHooks.join(", ") : "none"}`);
+            this.log(`- Codex config cleaned: ${updatedCodexConfig ? "yes" : "no"}`);
+            if (sessionMigration.rewritten > 0) {
+                this.log(`- Conversations: updated ${sessionMigration.rewritten}/${sessionMigration.scanned} local sessions for cross-provider visibility.`);
+            }
+            else if (sessionMigration.fastSkipped) {
+                this.log("- Conversations: already migrated (fast check).");
+            }
+            else {
+                this.log("- Conversations: no local sessions required migration.");
+            }
+            if (sessionMigration.retimed > 0) {
+                this.log(`- Conversation ordering: repaired timestamps on ${sessionMigration.retimed} local sessions.`);
+            }
+            if (stateDbMigration.updated > 0) {
+                this.log(`- Conversation cache: relabeled ${stateDbMigration.updated} local Codex history rows back to OpenAI.`);
+            }
+            else if (stateDbMigration.failed.length > 0) {
+                const detail = stateDbMigration.warning ? ` ${stateDbMigration.warning}` : "";
+                this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
+            }
+            this.log(`- OpenClaw config cleaned: ${updatedOpenClawConfig ? "yes" : "no"}`);
+            this.log(`- OpenCode config cleaned: ${updatedOpenCodeConfig ? "yes" : "no"}`);
+            this.log("Note: restart terminals/VS Code windows to clear already-loaded shell environment.");
+        });
+    }
+}
+LogoutCommand.description = "Log out from local The Claw Bay API-key auth on this machine";
+exports.default = LogoutCommand;

package/dist/commands/setup.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../lib/base-command");
+const codex_history_migration_1 = require("../lib/codex-history-migration");
 const paths_1 = require("../lib/config/paths");
 const api_key_1 = require("../lib/managed/api-key");
 const config_1 = require("../lib/managed/config");
@@ -16,10 +17,12 @@ const errors_1 = require("../lib/managed/errors");
 const DEFAULT_BACKEND_URL = "https://theclawbay.com";
 const DEFAULT_PROVIDER_ID = "theclawbay";
 const LEGACY_PROVIDER_ID = "codex-lb";
-const DEFAULT_CODEX_MODEL = "gpt-5.2-codex";
-const DEFAULT_OPENCLAW_MODEL = "gpt-5.3-codex";
-const DEFAULT_MODELS = ["gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.2-codex", "gpt-5.1-codex"];
+const DEFAULT_CODEX_MODEL = "gpt-5.4";
+const DEFAULT_OPENCLAW_MODEL = "gpt-5.4";
+const DEFAULT_MODELS = ["gpt-5.4", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.2-codex", "gpt-5.1-codex"];
 const PREFERRED_MODELS = [
+    "gpt-5.4",
+    "gpt-5.4-codex",
     "gpt-5.3-codex",
     "gpt-5.3-codex-spark",
     "gpt-5.2-codex",
@@ -28,6 +31,8 @@ const PREFERRED_MODELS = [
     "gpt-5.1-codex",
 ];
 const MODEL_DISPLAY_NAMES = {
+    "gpt-5.4": "GPT-5.4",
+    "gpt-5.4-codex": "GPT-5.4",
     "gpt-5.3-codex": "GPT-5.3 Codex",
     "gpt-5.3-codex-spark": "GPT-5.3 Codex Spark",
     "gpt-5.2-codex": "GPT-5.2 Codex",
@@ -44,6 +49,7 @@ const SHELL_START = "# theclawbay-shell-managed:start";
 const SHELL_END = "# theclawbay-shell-managed:end";
 const OPENCLAW_PROVIDER_ID = DEFAULT_PROVIDER_ID;
 const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set(["openai", "theclawbay-wan", DEFAULT_PROVIDER_ID, LEGACY_PROVIDER_ID]);
+const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = ["openai", "theclawbay-wan", LEGACY_PROVIDER_ID];
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/g, "");
 }
@@ -113,220 +119,6 @@ function shellQuote(value) {
 function modelDisplayName(modelId) {
     return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
 }
-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() {
-    try {
-        const raw = await promises_1.default.readFile(MIGRATION_STATE_FILE, "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(state) {
-    await promises_1.default.mkdir(node_path_1.default.dirname(MIGRATION_STATE_FILE), { recursive: true });
-    await promises_1.default.writeFile(MIGRATION_STATE_FILE, `${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();
-    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 (!HISTORY_PROVIDER_NEUTRALIZE_SOURCES.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({
-        version: 1,
-        fileCount: snapshot.fileCount,
-        maxMtimeMs: snapshot.maxMtimeMs,
-    });
-    return { scanned: files.length, rewritten, skipped, retimed, fastSkipped: false };
-}
 async function fetchBackendModelIds(backendUrl, apiKey) {
     const url = `${trimTrailingSlash(backendUrl)}/api/codex-auth/v1/proxy/v1/models`;
     try {
@@ -658,7 +450,16 @@ class SetupCommand extends base_command_1.BaseCommand {
             const codexConfigPath = await writeCodexConfig({ backendUrl, model: resolved.model, apiKey });
             const updatedShellFiles = await persistApiKeyEnv(apiKey);
             const updatedVsCodeEnvFiles = await persistVsCodeServerEnvSource();
-            const sessionMigration = await migrateSessionProviders({ codexHome: paths_1.codexDir });
+            const sessionMigration = await (0, codex_history_migration_1.migrateSessionProviders)({
+                codexHome: paths_1.codexDir,
+                migrationStateFile: MIGRATION_STATE_FILE,
+                neutralizeSources: HISTORY_PROVIDER_NEUTRALIZE_SOURCES,
+            });
+            const stateDbMigration = await (0, codex_history_migration_1.migrateStateDbProviders)({
+                codexHome: paths_1.codexDir,
+                targetProvider: DEFAULT_PROVIDER_ID,
+                sourceProviders: HISTORY_PROVIDER_DB_MIGRATE_SOURCES,
+            });
             const hasOpenClaw = hasCommand("openclaw");
             const hasOpenCode = hasCommand("opencode");
             let openClawConfigPath = null;
@@ -701,6 +502,13 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (sessionMigration.retimed > 0) {
                 this.log(`- Conversation ordering: repaired timestamps on ${sessionMigration.retimed} local sessions.`);
             }
+            if (stateDbMigration.updated > 0) {
+                this.log(`- Conversation cache: relabeled ${stateDbMigration.updated} local Codex history rows for The Claw Bay.`);
+            }
+            else if (stateDbMigration.failed.length > 0) {
+                const detail = stateDbMigration.warning ? ` ${stateDbMigration.warning}` : "";
+                this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
+            }
             this.log(`- API key env: ${ENV_FILE}`);
             this.log(`- Shell profiles updated: ${updatedShellFiles.join(", ")}`);
             this.log(`- VS Code env hooks updated: ${updatedVsCodeEnvFiles.join(", ")}`);

package/dist/index.js

@@ -1,7 +1,40 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@oclif/core");
-void (0, core_1.run)()
-    .then(() => (0, core_1.flush)())
-    .catch(core_1.Errors.handle);
+const update_check_1 = require("./lib/update-check");
+function detectPackageVersion() {
+    try {
+        const packageJsonPath = node_path_1.default.join(__dirname, "..", "package.json");
+        const raw = (0, node_fs_1.readFileSync)(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function maybePrintBareInvocationHint() {
+    if (process.argv.slice(2).length > 0)
+        return;
+    const packageName = "theclawbay";
+    const currentVersion = detectPackageVersion();
+    await (0, update_check_1.maybeNotifyUpdate)({
+        packageName,
+        currentVersion,
+        log: (message) => console.log(message),
+    }).catch(() => { });
+    console.log("Get your API key at: https://theclawbay.com/keys");
+    console.log("Then run: theclawbay setup --api-key <apiKey>");
+    console.log("");
+}
+async function main() {
+    await maybePrintBareInvocationHint();
+    await (0, core_1.run)().then(() => (0, core_1.flush)());
+}
+void main().catch(core_1.Errors.handle);