theclawbay 0.2.4 → 0.2.8

package/README.md

@@ -32,27 +32,17 @@ theclawbay setup --api-key <apiKey>
 ```
 
 This auto-detects installed clients and writes direct WAN API-key config so users can run directly.
-By default, Codex setup preserves local conversation history (no ChatGPT history sync mode).
+It configures Codex with `model_provider = "codex-lb"` and a managed bearer token, auto-selects the highest backend-advertised model, and preserves conversation visibility by neutralizing legacy local session provider tags so chats remain visible across provider modes.
 
-Explicit client targeting:
+It also configures OpenClaw/OpenCode automatically when those CLIs are installed.
 
-```sh
-theclawbay setup --api-key <apiKey> --client codex
-theclawbay setup --api-key <apiKey> --client openclaw
-theclawbay setup --api-key <apiKey> --client both
-```
-
-If needed, skip the automatic Codex login step:
-
-```sh
-theclawbay setup --api-key <apiKey> --skip-login
-```
+`CODEX_LB_API_KEY` is persisted for restarts in:
 
-If you explicitly want the prior ChatGPT-linked history mode:
-
-```sh
-theclawbay setup --api-key <apiKey> --openai-sync
-```
+- `~/.config/theclawbay/env`
+- `~/.bashrc`
+- `~/.zshrc`
+- `~/.profile`
+- `~/.vscode-server/server-env-setup` (and `~/.vscode-server-insiders/server-env-setup` when present)
 
 If you operate a custom backend, pass it explicitly:
 
@@ -60,6 +50,14 @@ If you operate a custom backend, pass it explicitly:
 theclawbay setup --api-key <apiKey> --backend https://your-domain.com
 ```
 
+After setup, restart terminal/VS Code once so env-backed clients (OpenClaw/OpenCode) pick up `CODEX_LB_API_KEY`.
+
+## Codex Extension Behavior
+
+- In API-key provider mode, Codex may label the model source as `Custom`.
+- 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)
 
 Only needed as a fallback compatibility mode:
@@ -73,8 +71,7 @@ By default this starts a local relay on `http://127.0.0.1:2455` and forwards to:
 
 - `https://theclawbay.com/api/codex-auth/v1/proxy/...`
 
-The command now auto-detects whether `codex`, `openclaw`, or both are installed and prints setup steps for the detected client(s).
-If both are installed and you're in an interactive terminal, it asks which one you want to configure.
+The command auto-detects whether `openclaw` and/or `opencode` are installed and configures them automatically.
 
 ## Notes
 

package/dist/commands/proxy.js

@@ -82,36 +82,70 @@ async function askClientChoice() {
         output: process.stdout,
     });
     try {
-        const answer = (await rl.question("Which client do you want to configure? [1] Codex [2] OpenClaw [3] Both: "))
+        const answer = (await rl.question("Which clients do you want to configure? [1] All detected [2] Codex [3] OpenClaw [4] OpenCode [5] Codex+OpenClaw: "))
             .trim()
             .toLowerCase();
-        if (answer === "2" || answer === "openclaw")
+        if (answer === "2" || answer === "codex")
+            return "codex";
+        if (answer === "3" || answer === "openclaw")
             return "openclaw";
-        if (answer === "3" || answer === "both")
+        if (answer === "4" || answer === "opencode")
+            return "opencode";
+        if (answer === "5" || answer === "both")
             return "both";
-        return "codex";
+        return "all";
     }
     finally {
         rl.close();
     }
 }
+function clientTargetsForChoice(choice) {
+    if (choice === "codex")
+        return { codex: true, openclaw: false, opencode: false };
+    if (choice === "openclaw")
+        return { codex: false, openclaw: true, opencode: false };
+    if (choice === "opencode")
+        return { codex: false, openclaw: false, opencode: true };
+    if (choice === "both")
+        return { codex: true, openclaw: true, opencode: false };
+    return { codex: true, openclaw: true, opencode: true };
+}
+function detectedClientTargets() {
+    return {
+        codex: hasCommand("codex"),
+        openclaw: hasCommand("openclaw"),
+        opencode: hasCommand("opencode"),
+    };
+}
+function countEnabledTargets(targets) {
+    return Number(targets.codex) + Number(targets.openclaw) + Number(targets.opencode);
+}
 async function resolveClientChoice(mode) {
-    if (mode === "codex" || mode === "openclaw" || mode === "both") {
-        return mode;
+    if (mode === "all") {
+        const detected = detectedClientTargets();
+        return countEnabledTargets(detected) > 0 ? detected : { codex: true, openclaw: false, opencode: false };
     }
-    const codexInstalled = hasCommand("codex");
-    const openclawInstalled = hasCommand("openclaw");
-    if (codexInstalled && !openclawInstalled)
-        return "codex";
-    if (!codexInstalled && openclawInstalled)
-        return "openclaw";
-    if (codexInstalled && openclawInstalled) {
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            return askClientChoice();
-        }
-        return "both";
+    if (mode === "codex" || mode === "openclaw" || mode === "opencode" || mode === "both") {
+        return clientTargetsForChoice(mode);
     }
-    return "codex";
+    const detected = detectedClientTargets();
+    const enabledCount = countEnabledTargets(detected);
+    if (enabledCount === 0)
+        return { codex: true, openclaw: false, opencode: false };
+    if (enabledCount === 1)
+        return detected;
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+        const choice = await askClientChoice();
+        if (choice === "all")
+            return detected;
+        const requested = clientTargetsForChoice(choice);
+        return {
+            codex: requested.codex && detected.codex,
+            openclaw: requested.openclaw && detected.openclaw,
+            opencode: requested.opencode && detected.opencode,
+        };
+    }
+    return detected;
 }
 class ProxyCommand extends base_command_1.BaseCommand {
     async run() {
@@ -128,7 +162,7 @@ class ProxyCommand extends base_command_1.BaseCommand {
             }
             const basePath = ensureLeadingSlash(flags["base-path"].trim()).replace(/\/+$/g, "");
             const proxyBase = `${trimTrailingSlash(backendUrl)}${basePath}`;
-            const clientChoice = await resolveClientChoice(flags.client);
+            const targets = await resolveClientChoice(flags.client);
             const server = node_http_1.default.createServer(async (req, res) => {
                 const method = req.method?.toUpperCase() ?? "GET";
                 const incomingUrl = new URL(req.url || "/", "http://local-proxy.invalid");
@@ -177,7 +211,7 @@ class ProxyCommand extends base_command_1.BaseCommand {
             this.log(`theclawbay WAN relay listening at ${localBase}`);
             this.log(`Forwarding to ${proxyBase}`);
             this.log("");
-            if (clientChoice === "codex" || clientChoice === "both") {
+            if (targets.codex) {
                 this.log("Codex CLI config snippet:");
                 this.log('model_provider = "theclawbay-wan"');
                 this.log("");
@@ -189,11 +223,11 @@ class ProxyCommand extends base_command_1.BaseCommand {
                 this.log("requires_openai_auth = true");
                 this.log("");
             }
-            if (clientChoice === "openclaw" || clientChoice === "both") {
+            if (targets.openclaw) {
                 const openClawProviderJson = JSON.stringify({
                     baseUrl: `${localBase}/v1`,
                     apiKey: "theclawbay-local",
-                    api: "openai-responses",
+                    api: "openai-completions",
                     models: [
                         { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
                         { id: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
@@ -203,9 +237,30 @@ class ProxyCommand extends base_command_1.BaseCommand {
                 });
                 this.log("OpenClaw setup:");
                 this.log("Run these once:");
-                this.log('openclaw config set agents.defaults.model.primary "openai/gpt-5.3-codex"');
+                this.log('openclaw config set agents.defaults.model.primary "codex-lb/gpt-5.3-codex"');
                 this.log('openclaw config set models.mode "merge"');
-                this.log(`openclaw config set models.providers.openai '${openClawProviderJson}' --json`);
+                this.log(`openclaw config set models.providers.codex-lb '${openClawProviderJson}' --json`);
+                this.log("");
+            }
+            if (targets.opencode) {
+                this.log("OpenCode setup:");
+                this.log("Set in ~/.config/opencode/opencode.json:");
+                this.log(JSON.stringify({
+                    provider: {
+                        "codex-lb": {
+                            npm: "@ai-sdk/openai-compatible",
+                            name: "codex-lb",
+                            options: {
+                                baseURL: `${localBase}/v1`,
+                                apiKey: "theclawbay-local",
+                            },
+                            models: {
+                                "gpt-5.3-codex": { name: "GPT-5.3 Codex" },
+                            },
+                        },
+                    },
+                    model: "codex-lb/gpt-5.3-codex",
+                }, null, 2));
                 this.log("");
             }
             await new Promise((resolve) => {
@@ -244,7 +299,7 @@ ProxyCommand.flags = {
     client: core_1.Flags.string({
         required: false,
         default: "auto",
-        options: ["auto", "codex", "openclaw", "both"],
+        options: ["auto", "codex", "openclaw", "opencode", "both", "all"],
         description: "Client target to guide setup for",
     }),
 };

package/dist/commands/setup.d.ts

@@ -4,11 +4,6 @@ export default class SetupCommand extends BaseCommand {
     static flags: {
         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>;
-        provider: 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>;
-        "openclaw-model": import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        "skip-login": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        "openai-sync": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/setup.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (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 node_child_process_1 = require("node:child_process");
-const promises_2 = require("node:readline/promises");
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../lib/base-command");
 const paths_1 = require("../lib/config/paths");
@@ -14,10 +14,34 @@ const api_key_1 = require("../lib/managed/api-key");
 const config_1 = require("../lib/managed/config");
 const errors_1 = require("../lib/managed/errors");
 const DEFAULT_BACKEND_URL = "https://theclawbay.com";
-const DEFAULT_PROVIDER_ID = "theclawbay-wan";
+const DEFAULT_PROVIDER_ID = "codex-lb";
+const DEFAULT_CODEX_MODEL = "gpt-5.2-codex";
+const DEFAULT_MODELS = ["gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.2-codex", "gpt-5.1-codex"];
+const PREFERRED_MODELS = [
+    "gpt-5.3-codex",
+    "gpt-5.3-codex-spark",
+    "gpt-5.2-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini",
+    "gpt-5.1-codex",
+];
+const MODEL_DISPLAY_NAMES = {
+    "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",
+    "gpt-5.1-codex-max": "GPT-5.1 Codex Max",
+    "gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",
+    "gpt-5.1-codex": "GPT-5.1 Codex",
+};
+const ENV_KEY_NAME = "CODEX_LB_API_KEY";
+const ENV_FILE = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay", "env");
+const MIGRATION_STATE_FILE = node_path_1.default.join(paths_1.codexDir, "theclawbay.migration.json");
 const MANAGED_START = "# theclawbay-managed:start";
 const MANAGED_END = "# theclawbay-managed:end";
-const DEFAULT_OPENCLAW_MODEL = "gpt-5.3-codex";
+const SHELL_START = "# theclawbay-shell-managed:start";
+const SHELL_END = "# theclawbay-shell-managed:end";
+const OPENCLAW_PROVIDER_ID = "codex-lb";
+const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set(["openai", "theclawbay-wan", "codex-lb"]);
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/g, "");
 }
@@ -34,58 +58,27 @@ function hasCommand(name) {
     const result = (0, node_child_process_1.spawnSync)("which", [name], { stdio: "ignore" });
     return result.status === 0;
 }
-async function askClientChoice() {
-    const rl = (0, promises_2.createInterface)({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        const answer = (await rl.question("Which client do you want to configure? [1] Codex [2] OpenClaw [3] Both: "))
-            .trim()
-            .toLowerCase();
-        if (answer === "2" || answer === "openclaw")
-            return "openclaw";
-        if (answer === "3" || answer === "both")
-            return "both";
-        return "codex";
-    }
-    finally {
-        rl.close();
-    }
-}
-async function resolveClientChoice(mode) {
-    if (mode === "codex" || mode === "openclaw" || mode === "both") {
-        return mode;
-    }
-    const codexInstalled = hasCommand("codex");
-    const openclawInstalled = hasCommand("openclaw");
-    if (codexInstalled && !openclawInstalled)
-        return "codex";
-    if (!codexInstalled && openclawInstalled)
-        return "openclaw";
-    if (codexInstalled && openclawInstalled) {
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            return askClientChoice();
-        }
-        return "both";
-    }
-    return "codex";
-}
-function removeManagedBlock(source) {
-    const start = source.indexOf(MANAGED_START);
-    if (start < 0)
+function removeManagedBlock(source, start, end) {
+    const markerStart = source.indexOf(start);
+    if (markerStart < 0)
         return source;
-    const end = source.indexOf(MANAGED_END, start);
-    if (end < 0)
-        return source.slice(0, start).trimEnd() + "\n";
-    return (source.slice(0, start) + source.slice(end + MANAGED_END.length)).trimEnd() + "\n";
+    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 appendManagedBlock(source, lines) {
+    const body = lines.join("\n").trimEnd() + "\n";
+    if (!source.trim())
+        return body;
+    return `${source.trimEnd()}\n\n${body}`;
 }
 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) {
+        if ((lines[i] ?? "").trim() !== header) {
             output.push(lines[i] ?? "");
             continue;
         }
@@ -112,6 +105,283 @@ function upsertFirstKeyLine(source, key, tomlValue) {
     }
     return `${`${key} = ${tomlValue}\n${source}`.trimEnd()}\n`;
 }
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+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 {
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(4500),
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        const ids = (body.data ?? [])
+            .map((entry) => (typeof entry.id === "string" ? entry.id.trim() : ""))
+            .filter((id) => id.length > 0);
+        return ids.length ? ids : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveModels(backendUrl, apiKey) {
+    const ids = await fetchBackendModelIds(backendUrl, apiKey);
+    const available = new Set(ids ?? []);
+    let selected = DEFAULT_CODEX_MODEL;
+    let note;
+    for (const preferred of PREFERRED_MODELS) {
+        if (available.has(preferred)) {
+            selected = preferred;
+            break;
+        }
+    }
+    if (ids?.length && !available.has(selected)) {
+        selected = ids[0] ?? DEFAULT_CODEX_MODEL;
+        note = "No preferred Codex model advertised by backend; selected first available model.";
+    }
+    else if (!ids) {
+        note = `Unable to query backend model list; defaulted to ${DEFAULT_CODEX_MODEL}.`;
+    }
+    const unique = [];
+    const pushUnique = (modelId) => {
+        if (!modelId || unique.includes(modelId))
+            return;
+        unique.push(modelId);
+    };
+    pushUnique(selected);
+    for (const modelId of DEFAULT_MODELS)
+        pushUnique(modelId);
+    for (const modelId of ids ?? []) {
+        if (unique.length >= 8)
+            break;
+        pushUnique(modelId);
+    }
+    return {
+        model: selected,
+        models: unique.map((modelId) => ({ id: modelId, name: modelDisplayName(modelId) })),
+        note,
+    };
+}
 async function writeCodexConfig(params) {
     const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
     await promises_1.default.mkdir(paths_1.codexDir, { recursive: true });
@@ -126,40 +396,82 @@ async function writeCodexConfig(params) {
     }
     const proxyRoot = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy`;
     let next = existing;
-    next = removeManagedBlock(next);
-    next = removeProviderTable(next, params.providerId);
-    next = upsertFirstKeyLine(next, "model_provider", `"${params.providerId}"`);
-    const managedBlock = [
+    next = removeManagedBlock(next, MANAGED_START, MANAGED_END);
+    next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
+    next = upsertFirstKeyLine(next, "model_provider", `"${DEFAULT_PROVIDER_ID}"`);
+    next = upsertFirstKeyLine(next, "model", `"${params.model}"`);
+    const managedBlock = appendManagedBlock("", [
         MANAGED_START,
-        `[model_providers.${params.providerId}]`,
+        `[model_providers.${DEFAULT_PROVIDER_ID}]`,
         'name = "OpenAI"',
         `base_url = "${proxyRoot}/backend-api/codex"`,
         'wire_api = "responses"',
-        ...(params.openaiSync
-            ? [`chatgpt_base_url = "${proxyRoot}"`, "requires_openai_auth = true"]
-            : []),
+        "requires_openai_auth = true",
+        `experimental_bearer_token = "${params.apiKey}"`,
         MANAGED_END,
+    ]);
+    next = appendManagedBlock(next, managedBlock.trimEnd().split("\n"));
+    await promises_1.default.writeFile(configPath, next, "utf8");
+    return configPath;
+}
+async function persistApiKeyEnv(apiKey) {
+    const envDir = node_path_1.default.dirname(ENV_FILE);
+    await promises_1.default.mkdir(envDir, { recursive: true });
+    const envContents = [
+        "# Generated by theclawbay setup",
+        `export ${ENV_KEY_NAME}=${shellQuote(apiKey)}`,
         "",
     ].join("\n");
-    if (next.trim().length) {
-        next = `${next.trimEnd()}\n\n`;
+    await promises_1.default.writeFile(ENV_FILE, envContents, "utf8");
+    await promises_1.default.chmod(ENV_FILE, 0o600);
+    const sourceLine = `[ -f "$HOME/.config/theclawbay/env" ] && . "$HOME/.config/theclawbay/env"`;
+    const shellRcPaths = [".bashrc", ".zshrc", ".profile"].map((name) => node_path_1.default.join(node_os_1.default.homedir(), name));
+    const updated = [];
+    for (const rcPath of shellRcPaths) {
+        let existing = "";
+        try {
+            existing = await promises_1.default.readFile(rcPath, "utf8");
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT")
+                throw error;
+        }
+        const cleaned = removeManagedBlock(existing, SHELL_START, SHELL_END);
+        const withBlock = appendManagedBlock(cleaned, [SHELL_START, sourceLine, SHELL_END]);
+        await promises_1.default.writeFile(rcPath, withBlock, "utf8");
+        updated.push(rcPath);
     }
-    next += managedBlock;
-    await promises_1.default.writeFile(configPath, next, "utf8");
-    return configPath;
+    process.env[ENV_KEY_NAME] = apiKey;
+    return updated;
 }
-function codexLoginWithApiKey(apiKey) {
-    const run = (0, node_child_process_1.spawnSync)("codex", ["login", "--with-api-key"], {
-        input: `${apiKey}\n`,
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    if (run.status === 0)
-        return;
-    const stderr = (run.stderr ?? "").trim();
-    const stdout = (run.stdout ?? "").trim();
-    const details = stderr || stdout || "codex login returned a non-zero exit status";
-    throw new Error(`failed to store API key in Codex CLI: ${details}`);
+async function persistVsCodeServerEnvSource() {
+    const homes = [".vscode-server", ".vscode-server-insiders"];
+    const sourceLine = `[ -f "$HOME/.config/theclawbay/env" ] && . "$HOME/.config/theclawbay/env"`;
+    const updated = [];
+    for (const home of homes) {
+        const setupPath = node_path_1.default.join(node_os_1.default.homedir(), home, "server-env-setup");
+        await promises_1.default.mkdir(node_path_1.default.dirname(setupPath), { recursive: true });
+        let existing = "";
+        try {
+            existing = await promises_1.default.readFile(setupPath, "utf8");
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT")
+                throw error;
+        }
+        let next = existing.trimEnd();
+        if (!next.startsWith("#!")) {
+            next = `#!/usr/bin/env sh\n${next}`.trimEnd();
+        }
+        next = `${removeManagedBlock(next + "\n", SHELL_START, SHELL_END).trimEnd()}\n`;
+        next = appendManagedBlock(next, [SHELL_START, sourceLine, SHELL_END]);
+        await promises_1.default.writeFile(setupPath, next, "utf8");
+        await promises_1.default.chmod(setupPath, 0o700);
+        updated.push(setupPath);
+    }
+    return updated;
 }
 function runOpenClawConfigCommand(args) {
     const run = (0, node_child_process_1.spawnSync)("openclaw", args, {
@@ -174,29 +486,78 @@ function runOpenClawConfigCommand(args) {
     throw new Error(`failed to update OpenClaw config: ${details}`);
 }
 function setupOpenClaw(params) {
-    const base = trimTrailingSlash(params.backendUrl);
-    const model = params.model.trim() || DEFAULT_OPENCLAW_MODEL;
     const provider = {
-        baseUrl: `${base}/api/codex-auth/v1/proxy/v1`,
-        apiKey: params.apiKey,
-        api: "openai-responses",
-        models: [
-            { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
-            { id: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
-            { id: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
-            { id: "gpt-5.1-codex", name: "GPT-5.1 Codex" },
-        ],
+        baseUrl: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
+        apiKey: "${CODEX_LB_API_KEY}",
+        api: "openai-completions",
+        models: params.models,
     };
-    runOpenClawConfigCommand(["config", "set", "agents.defaults.model.primary", `openai/${model}`]);
+    runOpenClawConfigCommand([
+        "config",
+        "set",
+        "agents.defaults.model.primary",
+        `${OPENCLAW_PROVIDER_ID}/${params.model.trim() || DEFAULT_CODEX_MODEL}`,
+    ]);
     runOpenClawConfigCommand(["config", "set", "models.mode", "merge"]);
     runOpenClawConfigCommand([
         "config",
         "set",
-        "models.providers.openai",
+        `models.providers.${OPENCLAW_PROVIDER_ID}`,
         JSON.stringify(provider),
         "--json",
     ]);
 }
+function objectRecordOr(value, fallback) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return { ...value };
+    }
+    return fallback;
+}
+function openCodeModelsObject(models) {
+    const result = {};
+    for (const model of models) {
+        if (!model.id)
+            continue;
+        result[model.id] = { name: model.name || model.id };
+    }
+    return result;
+}
+async function writeOpenCodeConfig(params) {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    let existingRaw = "";
+    try {
+        existingRaw = await promises_1.default.readFile(configPath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+    }
+    let doc = {};
+    if (existingRaw.trim()) {
+        try {
+            doc = objectRecordOr(JSON.parse(existingRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in OpenCode config: ${configPath}`);
+        }
+    }
+    const providerRoot = objectRecordOr(doc.provider, {});
+    providerRoot[DEFAULT_PROVIDER_ID] = {
+        npm: "@ai-sdk/openai-compatible",
+        name: DEFAULT_PROVIDER_ID,
+        options: {
+            baseURL: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
+            apiKey: `{env:${ENV_KEY_NAME}}`,
+        },
+        models: openCodeModelsObject(params.models),
+    };
+    doc.provider = providerRoot;
+    doc.model = `${DEFAULT_PROVIDER_ID}/${params.model}`;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return configPath;
+}
 class SetupCommand extends base_command_1.BaseCommand {
     async run() {
         await this.runSafe(async () => {
@@ -210,64 +571,73 @@ class SetupCommand extends base_command_1.BaseCommand {
                     throw error;
             }
             const apiKey = (flags["api-key"] ?? managed?.apiKey ?? "").trim();
-            if (!apiKey) {
+            if (!apiKey)
                 throw new Error('API key is required. Run "theclawbay setup --api-key <key>".');
-            }
             const backendRaw = flags.backend ?? (0, api_key_1.tryInferBackendUrlFromApiKey)(apiKey) ?? managed?.backendUrl ?? DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
-            const clientChoice = await resolveClientChoice(flags.client);
-            const codexWanted = clientChoice === "codex" || clientChoice === "both";
-            const openClawWanted = clientChoice === "openclaw" || clientChoice === "both";
             await (0, config_1.writeManagedConfig)({ backendUrl, apiKey });
-            let codexConfigPath = null;
-            if (codexWanted) {
-                codexConfigPath = await writeCodexConfig({
+            const resolved = await resolveModels(backendUrl, apiKey);
+            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 hasOpenClaw = hasCommand("openclaw");
+            const hasOpenCode = hasCommand("opencode");
+            let openCodePath = null;
+            if (hasOpenClaw) {
+                setupOpenClaw({
                     backendUrl,
-                    providerId: flags.provider.trim() || DEFAULT_PROVIDER_ID,
-                    openaiSync: flags["openai-sync"],
+                    model: resolved.model,
+                    models: resolved.models,
                 });
             }
-            if (codexWanted && !flags["skip-login"]) {
-                if (!hasCommand("codex")) {
-                    throw new Error('codex CLI not found. Install @openai/codex, or run setup with --client openclaw.');
-                }
-                codexLoginWithApiKey(apiKey);
-            }
-            if (openClawWanted) {
-                if (!hasCommand("openclaw")) {
-                    throw new Error('openclaw CLI not found. Install OpenClaw, or run setup with --client codex.');
-                }
-                setupOpenClaw({
+            if (hasOpenCode) {
+                openCodePath = await writeOpenCodeConfig({
                     backendUrl,
-                    apiKey,
-                    model: flags["openclaw-model"],
+                    model: resolved.model,
+                    models: resolved.models,
                 });
             }
-            this.log(`Linked. Managed config written to ${paths_1.managedConfigPath}`);
-            this.log(`Backend: ${backendUrl}`);
-            if (codexConfigPath) {
-                this.log(`Codex config updated at ${codexConfigPath}`);
-                if (flags["openai-sync"]) {
-                    this.log("Codex configured in OpenAI-sync mode (ChatGPT-linked history view).");
-                }
-                else {
-                    this.log("Codex configured in local-history mode (default).");
-                }
+            this.log("Setup complete");
+            this.log(`- Managed config: ${paths_1.managedConfigPath}`);
+            this.log(`- Backend: ${backendUrl}`);
+            this.log(`- Codex config: ${codexConfigPath}`);
+            this.log(`- Codex model: ${resolved.model}`);
+            if (resolved.note)
+                this.log(resolved.note);
+            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 (openClawWanted) {
-                this.log("OpenClaw model provider updated for direct WAN API-key routing.");
+            if (sessionMigration.retimed > 0) {
+                this.log(`- Conversation ordering: repaired timestamps on ${sessionMigration.retimed} local sessions.`);
             }
-            if (codexWanted && flags["skip-login"]) {
-                this.log("Skipped Codex login. Run: printenv OPENAI_API_KEY | codex login --with-api-key");
+            this.log(`- API key env: ${ENV_FILE}`);
+            this.log(`- Shell profiles updated: ${updatedShellFiles.join(", ")}`);
+            this.log(`- VS Code env hooks updated: ${updatedVsCodeEnvFiles.join(", ")}`);
+            if (hasOpenClaw) {
+                this.log("- OpenClaw: configured");
             }
-            else if (codexWanted) {
-                this.log("Codex API-key login updated.");
+            else {
+                this.log("- OpenClaw: not detected (skipped)");
             }
-            this.log('Done. Users can run directly (no "theclawbay proxy" required in recommended setup).');
+            if (hasOpenCode) {
+                this.log(`- OpenCode: configured (${openCodePath})`);
+            }
+            else {
+                this.log("- OpenCode: not detected (skipped)");
+            }
+            this.log("- Codex login state: unchanged");
+            this.log("Next: restart terminal/VS Code window once so OpenClaw/OpenCode pick up CODEX_LB_API_KEY.");
         });
     }
 }
-SetupCommand.description = "One-time direct setup for Codex/OpenClaw: link key and route directly to The Claw Bay backend";
+SetupCommand.description = "One-time setup: configure Codex/OpenClaw/OpenCode to route through The Claw Bay using your API key";
 SetupCommand.flags = {
     backend: core_1.Flags.string({
         required: false,
@@ -278,31 +648,5 @@ SetupCommand.flags = {
         aliases: ["apiKey"],
         description: "API key issued by your The Claw Bay dashboard",
     }),
-    provider: core_1.Flags.string({
-        required: false,
-        default: DEFAULT_PROVIDER_ID,
-        description: "Codex model provider id to write into ~/.codex/config.toml",
-    }),
-    client: core_1.Flags.string({
-        required: false,
-        default: "auto",
-        options: ["auto", "codex", "openclaw", "both"],
-        description: "Client target to configure",
-    }),
-    "openclaw-model": core_1.Flags.string({
-        required: false,
-        default: DEFAULT_OPENCLAW_MODEL,
-        description: "OpenClaw model id to set as default (without provider prefix)",
-    }),
-    "skip-login": core_1.Flags.boolean({
-        required: false,
-        default: false,
-        description: "Skip `codex login --with-api-key`",
-    }),
-    "openai-sync": core_1.Flags.boolean({
-        required: false,
-        default: false,
-        description: "Enable OpenAI-synced conversation mode (writes chatgpt_base_url/requires_openai_auth); may prefer remote ChatGPT history over local-only history",
-    }),
 };
 exports.default = SetupCommand;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.2.4",
+  "version": "0.2.8",
   "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access, with optional relay fallback.",
   "license": "MIT",
   "bin": {