theclawbay 0.3.77 → 0.3.78

package/README.md

@@ -1,6 +1,6 @@
 # theclawbay
 
-CLI for connecting Codex, Hermes Agent, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.
+CLI for connecting Codex, Claude Code, Hermes Agent, Gemini-compatible apps, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.
 
 ## Install
 
@@ -19,6 +19,7 @@ theclawbay setup --api-key <apiKey>
 In an interactive terminal, setup shows one picker for Codex, Hermes Agent, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, Windows Trae, and Zo.
 Each row includes a terminal-friendly icon plus the tool's official site, and you can toggle items with arrow keys plus `Enter` or by pressing `1-9` and `0`.
 Re-running setup also migrates legacy OpenCode and Kilo patches to the current reasoning-capable provider path and refreshes OpenClaw model metadata.
+Setup also creates a local backup before changing config files, and you can choose the default model with `--model <id>` or print the live backend model list with `--list-models`.
 
 ## Optional
 
@@ -33,3 +34,15 @@ Removes The Claw Bay-managed local config from this machine.
 `theclawbay usage`
 
 Shows your current shared 5-hour and weekly usage windows.
+
+`theclawbay backup`
+
+Creates a timestamped local backup of the managed config and supported client config paths.
+
+`theclawbay backup --list`
+
+Shows the saved backups with their date/time and captured target counts.
+
+`theclawbay backup --restore <backupId>`
+
+Restores a saved backup snapshot.

package/dist/commands/backup.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../lib/base-command";
+export default class BackupCommand extends BaseCommand {
+    static description: string;
+    static flags: {
+        list: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        restore: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/backup.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../lib/base-command");
+const backups_1 = require("../lib/backups");
+class BackupCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const { flags } = await this.parse(BackupCommand);
+            if (flags.list && flags.restore) {
+                throw new Error("--list and --restore cannot be used together.");
+            }
+            if (flags.list) {
+                const backups = await (0, backups_1.listBackups)();
+                if (backups.length === 0) {
+                    this.log("No backups found yet.");
+                    return;
+                }
+                this.log("Available backups:");
+                for (const backup of backups) {
+                    this.log(`- ${backup.id}  ${(0, backups_1.formatBackupTimestamp)(backup.createdAt)}  ${backup.capturedTargets}/${backup.totalTargets} targets  ${backup.reason}`);
+                }
+                return;
+            }
+            if (flags.restore) {
+                const restored = await (0, backups_1.restoreBackup)(flags.restore);
+                this.log(`Restored backup ${restored.id} from ${(0, backups_1.formatBackupTimestamp)(restored.createdAt)} (${restored.capturedTargets}/${restored.totalTargets} targets).`);
+                return;
+            }
+            const backup = await (0, backups_1.createBackup)(flags.reason?.trim() || "manual backup");
+            this.log(`Created backup ${backup.id} at ${(0, backups_1.formatBackupTimestamp)(backup.createdAt)} (${backup.capturedTargets}/${backup.totalTargets} targets).`);
+        });
+    }
+}
+BackupCommand.description = "Create, list, and restore local The Claw Bay client configuration backups";
+BackupCommand.flags = {
+    list: core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "List available backups instead of creating a new one",
+    }),
+    restore: core_1.Flags.string({
+        required: false,
+        description: "Restore a backup by id",
+    }),
+    reason: core_1.Flags.string({
+        required: false,
+        description: "Optional note to record with a newly created backup",
+    }),
+};
+exports.default = BackupCommand;

package/dist/commands/setup.d.ts

@@ -6,6 +6,10 @@ export default class SetupCommand extends BaseCommand {
         "api-key": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         "device-name": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         clients: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        model: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        "claude-models": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        "list-models": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        backup: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         "migrate-conversations": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         "debug-output": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/setup.js

@@ -13,6 +13,7 @@ const node_child_process_1 = require("node:child_process");
 const core_1 = require("@oclif/core");
 const yaml_1 = require("yaml");
 const base_command_1 = require("../lib/base-command");
+const backups_1 = require("../lib/backups");
 const codex_auth_seeding_1 = require("../lib/codex-auth-seeding");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
 const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
@@ -1228,6 +1229,62 @@ async function resolveDeviceLabel(params) {
         rl.close();
     }
 }
+async function promptForPrimaryModel(models, defaultModel) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || models.length <= 1) {
+        return defaultModel;
+    }
+    const rl = (0, promises_2.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const lines = models.map((model, index) => {
+            const defaultSuffix = model.id === defaultModel ? " (default)" : "";
+            return `  ${index + 1}. ${model.name} — ${model.id}${defaultSuffix}`;
+        });
+        const answer = await rl.question(`\nChoose the default OpenAI-compatible model for local setup:\n${lines.join("\n")}\nSelect a number or press Enter for ${defaultModel}: `);
+        const trimmed = answer.trim();
+        if (!trimmed)
+            return defaultModel;
+        const asNumber = Number.parseInt(trimmed, 10);
+        if (Number.isInteger(asNumber) && asNumber >= 1 && asNumber <= models.length) {
+            return models[asNumber - 1]?.id ?? defaultModel;
+        }
+        const directMatch = models.find((model) => model.id === trimmed);
+        if (directMatch)
+            return directMatch.id;
+        throw new Error(`Unknown model selection "${trimmed}".`);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveConfiguredModelSelection(params) {
+    const requestedModel = params.requestedModel?.trim();
+    const availableIds = new Set(params.resolved.models.map((entry) => entry.id));
+    if (requestedModel) {
+        if (availableIds.size === 0 || availableIds.has(requestedModel)) {
+            return {
+                model: requestedModel,
+                note: availableIds.size === 0 && params.resolved.failure
+                    ? `Could not verify requested model ${requestedModel} against the live backend (${params.resolved.failure}).`
+                    : undefined,
+            };
+        }
+        throw new Error(`Requested model "${requestedModel}" is not advertised by the live backend.`);
+    }
+    if (params.skipPrompt || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return { model: params.resolved.model };
+    }
+    const selected = await promptForPrimaryModel(params.resolved.models, params.resolved.model);
+    if (selected === params.resolved.model) {
+        return { model: selected };
+    }
+    return {
+        model: selected,
+        note: `Using ${selected} as the default configured model for local tools.`,
+    };
+}
 function summarizeModelFetchFailure(detail) {
     const normalized = detail.replace(/\s+/g, " ").trim();
     if (!normalized)
@@ -1678,6 +1735,29 @@ async function resolveClaudeAccess(backendUrl, apiKey) {
         authRejected,
     };
 }
+function resolveConfiguredClaudeModels(params) {
+    const requestedModels = params.requestedModels
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (!requestedModels?.length || !params.access.enabled) {
+        return {
+            ...params.access,
+            selectedModels: params.access.models,
+        };
+    }
+    const available = new Set(params.access.models);
+    for (const modelId of requestedModels) {
+        if (!available.has(modelId)) {
+            throw new Error(`Requested Claude model "${modelId}" is not advertised by the live Claude endpoint.`);
+        }
+    }
+    return {
+        ...params.access,
+        selectedModels: requestedModels,
+        note: `Configured Claude-compatible clients with ${requestedModels.join(", ")}.`,
+    };
+}
 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 });
@@ -3176,6 +3256,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             const progress = this.createProgressHandle(!debugOutput);
             let resolved = null;
             let claudeAccess = null;
+            let backupSummary = null;
             let updatedShellFiles = [];
             let updatedFishFiles = [];
             let updatedPowerShellProfiles = [];
@@ -3208,14 +3289,48 @@ class SetupCommand extends base_command_1.BaseCommand {
                     if (resolved.authRejected) {
                         throw new Error(describeCredentialRejection(authType, resolved.failure));
                     }
+                    const configuredModel = await resolveConfiguredModelSelection({
+                        resolved,
+                        requestedModel: flags.model,
+                        skipPrompt: flags.yes,
+                    });
+                    resolved = {
+                        ...resolved,
+                        model: configuredModel.model,
+                        note: [resolved.note, configuredModel.note].filter(Boolean).join(" ").trim() || undefined,
+                    };
                 }
                 progress.update("Checking Claude access");
                 claudeAccess = await resolveClaudeAccess(backendUrl, authCredential);
                 if (!resolved?.authRejected && claudeAccess.authRejected) {
                     throw new Error(describeCredentialRejection(authType, claudeAccess.failure));
                 }
+                claudeAccess = resolveConfiguredClaudeModels({
+                    access: claudeAccess,
+                    requestedModels: flags["claude-models"],
+                });
+                if (flags["list-models"]) {
+                    if (resolved) {
+                        this.log("\nOpenAI-compatible models:");
+                        for (const model of resolved.models) {
+                            const marker = model.id === resolved.model ? " (default)" : "";
+                            this.log(`- ${model.id}${marker}`);
+                        }
+                    }
+                    if (claudeAccess.models.length > 0) {
+                        this.log("\nClaude models:");
+                        for (const modelId of claudeAccess.models) {
+                            const marker = claudeAccess.selectedModels?.includes(modelId) ? " (selected)" : "";
+                            this.log(`- ${modelId}${marker}`);
+                        }
+                    }
+                }
                 const claudeSelected = selectedSetupClients.has("claude");
                 const claudeEnvEnabled = claudeSelected && claudeAccess.enabled;
+                if (flags.backup) {
+                    progress.update("Creating local config backup");
+                    backupSummary = await (0, backups_1.createBackup)("pre-setup backup");
+                }
                 progress.update("Saving shared machine config");
                 await (0, config_1.writeManagedConfig)({
                     backendUrl,
@@ -3257,7 +3372,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                         claudeDesktop3pConfigPathManaged = await writeClaudeDesktop3pConfig({
                             backendUrl,
                             apiKey: authCredential,
-                            claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
+                            claudeModels: claudeAccess?.enabled ? (claudeAccess.selectedModels ?? claudeAccess.models) : [],
                         });
                     }
                     else {
@@ -3345,7 +3460,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                         backendUrl,
                         model: resolved?.model ?? DEFAULT_CODEX_MODEL,
                         models: resolved?.models ?? [{ id: DEFAULT_CODEX_MODEL, name: modelDisplayName(DEFAULT_CODEX_MODEL) }],
-                        claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
+                        claudeModels: claudeAccess?.enabled ? (claudeAccess.selectedModels ?? claudeAccess.models) : [],
                         apiKey: authCredential,
                     });
                 }
@@ -3413,6 +3528,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             const summaryNotes = new Set();
             if (resolved?.note)
                 summaryNotes.add(resolved.note);
+            if (backupSummary) {
+                summaryNotes.add(`Created a local backup snapshot (${backupSummary.id}) before changing client configs.`);
+            }
             if (selectedSetupClients.has("claude") && claudeAccess?.enabled) {
                 summaryNotes.add("Claude Code: exported ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY.");
                 if (claudeDesktop3pConfigPathManaged) {
@@ -3467,6 +3585,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             this.log(`- Managed config: ${paths_1.managedConfigPath}`);
             this.log(`- Backend: ${backendUrl}`);
             this.log(`- Auth mode: ${authType}`);
+            if (backupSummary) {
+                this.log(`- Backup: ${backupSummary.id} (${backupSummary.directory})`);
+            }
             if (authType === "device-session") {
                 this.log(`- Device session id: ${deviceSessionId ?? "n/a"}`);
                 this.log(`- Device label: ${deviceLabel ?? "n/a"}`);
@@ -3724,6 +3845,25 @@ SetupCommand.flags = {
         required: false,
         description: "Detected local clients to configure: codex, claude, continue, cline, gsd, openclaw, opencode, kilo, roo, trae, aider, zo, hermes",
     }),
+    model: core_1.Flags.string({
+        required: false,
+        description: "Default OpenAI-compatible model to configure for local tools",
+    }),
+    "claude-models": core_1.Flags.string({
+        required: false,
+        description: "Comma-separated Claude model ids to configure for Claude-compatible tools",
+    }),
+    "list-models": core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Print the live OpenAI-compatible and Claude model ids discovered during setup",
+    }),
+    backup: core_1.Flags.boolean({
+        required: false,
+        allowNo: true,
+        default: true,
+        description: "Create a local backup before changing client configs",
+    }),
     yes: core_1.Flags.boolean({
         required: false,
         char: "y",

package/dist/lib/backups.d.ts

@@ -0,0 +1,30 @@
+export type BackupTargetKind = "file" | "directory";
+export type BackupTargetManifestEntry = {
+    id: string;
+    label: string;
+    targetPath: string;
+    kind: BackupTargetKind;
+    existed: boolean;
+    snapshotRelativePath: string | null;
+};
+export type BackupManifest = {
+    version: 1;
+    id: string;
+    createdAt: string;
+    reason: string;
+    hostname: string;
+    platform: NodeJS.Platform;
+    targets: BackupTargetManifestEntry[];
+};
+export type BackupSummary = {
+    id: string;
+    createdAt: string;
+    reason: string;
+    totalTargets: number;
+    capturedTargets: number;
+    directory: string;
+};
+export declare function formatBackupTimestamp(isoString: string): string;
+export declare function createBackup(reason: string): Promise<BackupSummary>;
+export declare function listBackups(): Promise<BackupSummary[]>;
+export declare function restoreBackup(id: string): Promise<BackupSummary>;

package/dist/lib/backups.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBackupTimestamp = formatBackupTimestamp;
+exports.createBackup = createBackup;
+exports.listBackups = listBackups;
+exports.restoreBackup = restoreBackup;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const paths_1 = require("./config/paths");
+function homePath(...parts) {
+    return node_path_1.default.join(node_os_1.default.homedir(), ...parts);
+}
+function shellRcTargets() {
+    return [
+        [".bashrc", "Bash profile"],
+        [".bash_profile", "Bash login profile"],
+        [".bash_login", "Alternate bash login profile"],
+        [".zshrc", "Zsh profile"],
+        [".zprofile", "Zsh login profile"],
+        [".zlogin", "Zsh post-login profile"],
+        [".profile", "POSIX shell profile"],
+    ].map(([fileName, label]) => ({
+        id: `shell-${fileName.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase()}`,
+        label,
+        targetPath: homePath(fileName),
+        kind: "file",
+    }));
+}
+function editorSettingsTargets() {
+    const home = node_os_1.default.homedir();
+    const targets = [];
+    if (process.platform === "darwin") {
+        const appSupport = homePath("Library", "Application Support");
+        targets.push([node_path_1.default.join(appSupport, "Code", "User", "settings.json"), "VS Code settings"], [node_path_1.default.join(appSupport, "Code - Insiders", "User", "settings.json"), "VS Code Insiders settings"], [node_path_1.default.join(appSupport, "Cursor", "User", "settings.json"), "Cursor settings"], [node_path_1.default.join(appSupport, "Windsurf", "User", "settings.json"), "Windsurf settings"], [node_path_1.default.join(appSupport, "VSCodium", "User", "settings.json"), "VSCodium settings"], [node_path_1.default.join(appSupport, "Claude-3p", "claude_desktop_config.json"), "Claude Desktop 3P config"]);
+    }
+    else if (process.platform === "win32") {
+        const appData = process.env.APPDATA?.trim() || node_path_1.default.join(home, "AppData", "Roaming");
+        targets.push([node_path_1.default.join(appData, "Code", "User", "settings.json"), "VS Code settings"], [node_path_1.default.join(appData, "Code - Insiders", "User", "settings.json"), "VS Code Insiders settings"], [node_path_1.default.join(appData, "Cursor", "User", "settings.json"), "Cursor settings"], [node_path_1.default.join(appData, "Windsurf", "User", "settings.json"), "Windsurf settings"], [node_path_1.default.join(appData, "VSCodium", "User", "settings.json"), "VSCodium settings"]);
+    }
+    else {
+        targets.push([homePath(".config", "Code", "User", "settings.json"), "VS Code settings"], [homePath(".config", "Code - Insiders", "User", "settings.json"), "VS Code Insiders settings"], [homePath(".config", "Cursor", "User", "settings.json"), "Cursor settings"], [homePath(".config", "Windsurf", "User", "settings.json"), "Windsurf settings"], [homePath(".config", "VSCodium", "User", "settings.json"), "VSCodium settings"]);
+    }
+    return targets.map(([targetPath, label]) => ({
+        id: `editor-${label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`,
+        label,
+        targetPath,
+        kind: "file",
+    }));
+}
+function backupTargets() {
+    const targets = [
+        {
+            id: "theclawbay-config",
+            label: "The Claw Bay config directory",
+            targetPath: paths_1.theclawbayConfigDir,
+            kind: "directory",
+        },
+        {
+            id: "codex-home",
+            label: "Codex home directory",
+            targetPath: paths_1.codexDir,
+            kind: "directory",
+        },
+        {
+            id: "continue-home",
+            label: "Continue config directory",
+            targetPath: homePath(".continue"),
+            kind: "directory",
+        },
+        {
+            id: "cline-home",
+            label: "Cline config directory",
+            targetPath: homePath(".cline"),
+            kind: "directory",
+        },
+        {
+            id: "gsd-home",
+            label: "GSD agent directory",
+            targetPath: homePath(".gsd"),
+            kind: "directory",
+        },
+        {
+            id: "openclaw-home",
+            label: "OpenClaw config directory",
+            targetPath: homePath(".openclaw"),
+            kind: "directory",
+        },
+        {
+            id: "opencode-config-dir",
+            label: "OpenCode config directory",
+            targetPath: homePath(".config", "opencode"),
+            kind: "directory",
+        },
+        {
+            id: "opencode-home-file",
+            label: "OpenCode home config file",
+            targetPath: homePath(".opencode.json"),
+            kind: "file",
+        },
+        {
+            id: "kilo-config-dir",
+            label: "Kilo config directory",
+            targetPath: homePath(".config", "kilo"),
+            kind: "directory",
+        },
+        {
+            id: "kilo-home-dir",
+            label: "Legacy Kilo home directory",
+            targetPath: homePath(".kilo"),
+            kind: "directory",
+        },
+        {
+            id: "aider-config",
+            label: "Aider config file",
+            targetPath: homePath(".aider.conf.yml"),
+            kind: "file",
+        },
+        {
+            id: "fish-config",
+            label: "Fish The Claw Bay env file",
+            targetPath: homePath(".config", "fish", "conf.d", "theclawbay.fish"),
+            kind: "file",
+        },
+    ];
+    const deduped = new Map();
+    for (const target of [...targets, ...shellRcTargets(), ...editorSettingsTargets()]) {
+        deduped.set(target.targetPath, target);
+    }
+    return [...deduped.values()];
+}
+async function pathExists(targetPath) {
+    try {
+        await promises_1.default.lstat(targetPath);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function ensureCleanDirectory(targetPath) {
+    await promises_1.default.rm(targetPath, { recursive: true, force: true });
+    await promises_1.default.mkdir(targetPath, { recursive: true });
+}
+async function writeManifest(directory, manifest) {
+    await promises_1.default.writeFile(node_path_1.default.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+function backupIdFromDate(date) {
+    const pad = (value) => String(value).padStart(2, "0");
+    return [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate()),
+        "-",
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+        pad(date.getSeconds()),
+    ].join("");
+}
+function formatBackupTimestamp(isoString) {
+    const date = new Date(isoString);
+    if (Number.isNaN(date.getTime()))
+        return isoString;
+    return new Intl.DateTimeFormat(undefined, {
+        dateStyle: "medium",
+        timeStyle: "short",
+    }).format(date);
+}
+async function createBackup(reason) {
+    const now = new Date();
+    const id = backupIdFromDate(now);
+    const backupDirectory = node_path_1.default.join(paths_1.theclawbayBackupDir, id);
+    const snapshotRoot = node_path_1.default.join(backupDirectory, "files");
+    await ensureCleanDirectory(snapshotRoot);
+    const manifestTargets = [];
+    for (const target of backupTargets()) {
+        const existed = await pathExists(target.targetPath);
+        const snapshotRelativePath = existed ? node_path_1.default.join("files", target.id) : null;
+        if (existed && snapshotRelativePath) {
+            const snapshotPath = node_path_1.default.join(backupDirectory, snapshotRelativePath);
+            await promises_1.default.cp(target.targetPath, snapshotPath, { recursive: true, force: true });
+        }
+        manifestTargets.push({
+            id: target.id,
+            label: target.label,
+            targetPath: target.targetPath,
+            kind: target.kind,
+            existed,
+            snapshotRelativePath,
+        });
+    }
+    const manifest = {
+        version: 1,
+        id,
+        createdAt: now.toISOString(),
+        reason,
+        hostname: node_os_1.default.hostname(),
+        platform: process.platform,
+        targets: manifestTargets,
+    };
+    await writeManifest(backupDirectory, manifest);
+    return {
+        id,
+        createdAt: manifest.createdAt,
+        reason,
+        totalTargets: manifestTargets.length,
+        capturedTargets: manifestTargets.filter((target) => target.existed).length,
+        directory: backupDirectory,
+    };
+}
+async function readManifest(directory) {
+    try {
+        const raw = await promises_1.default.readFile(node_path_1.default.join(directory, "manifest.json"), "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function listBackups() {
+    try {
+        const entries = await promises_1.default.readdir(paths_1.theclawbayBackupDir, { withFileTypes: true });
+        const manifests = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const directory = node_path_1.default.join(paths_1.theclawbayBackupDir, entry.name);
+            const manifest = await readManifest(directory);
+            if (!manifest)
+                return null;
+            return {
+                id: manifest.id,
+                createdAt: manifest.createdAt,
+                reason: manifest.reason,
+                totalTargets: manifest.targets.length,
+                capturedTargets: manifest.targets.filter((target) => target.existed).length,
+                directory,
+            };
+        }));
+        return manifests
+            .filter((entry) => entry !== null)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function restoreBackup(id) {
+    const trimmed = id.trim();
+    if (!trimmed)
+        throw new Error("backup id is required for restore.");
+    const backupDirectory = node_path_1.default.join(paths_1.theclawbayBackupDir, trimmed);
+    const manifest = await readManifest(backupDirectory);
+    if (!manifest) {
+        throw new Error(`Backup "${trimmed}" was not found.`);
+    }
+    for (const target of manifest.targets) {
+        if (!target.existed || !target.snapshotRelativePath) {
+            await promises_1.default.rm(target.targetPath, { recursive: true, force: true });
+            continue;
+        }
+        const snapshotPath = node_path_1.default.join(backupDirectory, target.snapshotRelativePath);
+        await promises_1.default.rm(target.targetPath, { recursive: true, force: true });
+        await promises_1.default.mkdir(node_path_1.default.dirname(target.targetPath), { recursive: true });
+        await promises_1.default.cp(snapshotPath, target.targetPath, { recursive: true, force: true });
+    }
+    return {
+        id: manifest.id,
+        createdAt: manifest.createdAt,
+        reason: manifest.reason,
+        totalTargets: manifest.targets.length,
+        capturedTargets: manifest.targets.filter((target) => target.existed).length,
+        directory: backupDirectory,
+    };
+}

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

@@ -213,7 +213,11 @@ function normalizeSeedModel(template, modelId) {
         seed.supports_parallel_tool_calls = true;
     }
     if (typeof seed.context_window !== "number") {
-        seed.context_window = 272000;
+        const configuredContextWindow = SUPPORTED_MODEL_CONFIG.get(modelId)?.contextWindow;
+        seed.context_window =
+            typeof configuredContextWindow === "number" && Number.isFinite(configuredContextWindow)
+                ? configuredContextWindow
+                : 272000;
     }
     if (modelId === "gpt-5.5" && typeof seed.minimal_client_version !== "string") {
         seed.minimal_client_version = "0.124.0";

package/dist/lib/config/paths.d.ts

@@ -1,6 +1,7 @@
 export declare const codexDir: string;
 export declare const theclawbayConfigDir: string;
 export declare const theclawbayStateDir: string;
+export declare const theclawbayBackupDir: string;
 export declare const managedConfigPath: string;
 export declare const updateCheckStatePath: string;
 export declare const legacyManagedConfigPathClayBay: string;

package/dist/lib/config/paths.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.legacyManagedConfigPathCodexAuth = exports.legacyManagedConfigPathClayBay = exports.updateCheckStatePath = exports.managedConfigPath = exports.theclawbayStateDir = exports.theclawbayConfigDir = exports.codexDir = void 0;
+exports.legacyManagedConfigPathCodexAuth = exports.legacyManagedConfigPathClayBay = exports.updateCheckStatePath = exports.managedConfigPath = exports.theclawbayBackupDir = exports.theclawbayStateDir = exports.theclawbayConfigDir = exports.codexDir = void 0;
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 exports.codexDir = node_path_1.default.join(node_os_1.default.homedir(), ".codex");
 exports.theclawbayConfigDir = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay");
 exports.theclawbayStateDir = node_path_1.default.join(exports.theclawbayConfigDir, "state");
+exports.theclawbayBackupDir = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay-backups");
 exports.managedConfigPath = node_path_1.default.join(exports.codexDir, "theclawbay.managed.json");
 exports.updateCheckStatePath = node_path_1.default.join(exports.codexDir, "theclawbay.update-check.json");
 exports.legacyManagedConfigPathClayBay = node_path_1.default.join(exports.codexDir, "theclaybay.managed.json");

package/dist/lib/supported-models.d.ts

@@ -7,6 +7,7 @@ export type SupportedModelConfig = {
     inputPer1M: number;
     cachedInputPer1M: number;
     outputPer1M: number;
+    contextWindow?: number | null;
 };
 export declare function getSupportedModels(): SupportedModelConfig[];
 export declare function getSupportedModelIds(): string[];

package/dist/lib/supported-models.js

@@ -28,6 +28,9 @@ function parseSupportedModels(raw) {
         const inputPer1M = typeof record.inputPer1M === "number" ? record.inputPer1M : NaN;
         const cachedInputPer1M = typeof record.cachedInputPer1M === "number" ? record.cachedInputPer1M : NaN;
         const outputPer1M = typeof record.outputPer1M === "number" ? record.outputPer1M : NaN;
+        const contextWindow = typeof record.contextWindow === "number" && Number.isFinite(record.contextWindow) && record.contextWindow > 0
+            ? Math.round(record.contextWindow)
+            : null;
         if (!id || !label || !note) {
             throw new Error("supported-models config is missing required text fields");
         }
@@ -45,6 +48,7 @@ function parseSupportedModels(raw) {
             inputPer1M,
             cachedInputPer1M,
             outputPer1M,
+            contextWindow,
         };
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.77",
+  "version": "0.3.78",
   "description": "CLI for connecting Codex, Hermes Agent, Gemini-compatible apps, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "repository": {

package/theclawbay-supported-models.json

@@ -44,42 +44,6 @@
     "cachedInputPer1M": 2.0,
     "outputPer1M": 32.0
   },
-  {
-    "id": "gpt-5.3-codex",
-    "label": "GPT-5.3 Codex",
-    "note": "Strong daily-driver Codex model for heavier work.",
-    "tone": "ink",
-    "inputPer1M": 1.75,
-    "cachedInputPer1M": 0.175,
-    "outputPer1M": 14.0
-  },
-  {
-    "id": "codex-auto-review",
-    "label": "Codex Auto Review",
-    "note": "Compatibility alias for Codex IDE auto-review flows.",
-    "tone": "ink",
-    "inputPer1M": 1.75,
-    "cachedInputPer1M": 0.175,
-    "outputPer1M": 14.0
-  },
-  {
-    "id": "gpt-5.2-codex",
-    "label": "GPT-5.2 Codex",
-    "note": "Stable compatibility option for older Codex flows.",
-    "tone": "sea",
-    "inputPer1M": 1.75,
-    "cachedInputPer1M": 0.175,
-    "outputPer1M": 14.0
-  },
-  {
-    "id": "gpt-5.2",
-    "label": "GPT-5.2",
-    "note": "Balanced GPT-5 path when you want a non-Codex option.",
-    "tone": "ink",
-    "inputPer1M": 1.75,
-    "cachedInputPer1M": 0.175,
-    "outputPer1M": 14.0
-  },
   {
     "id": "gpt-5.1-codex-max",
     "label": "GPT-5.1 Codex Max",
@@ -151,5 +115,25 @@
     "inputPer1M": 0.5,
     "cachedInputPer1M": 0.05,
     "outputPer1M": 3.0
+  },
+  {
+    "id": "deepseek-v4-flash",
+    "label": "DeepSeek V4 Flash",
+    "note": "Lowest-cost DeepSeek path with 1M context through CliRelay.",
+    "tone": "sea",
+    "inputPer1M": 0.14,
+    "cachedInputPer1M": 0.0028,
+    "outputPer1M": 0.28,
+    "contextWindow": 1000000
+  },
+  {
+    "id": "deepseek-v4-pro",
+    "label": "DeepSeek V4 Pro",
+    "note": "Flagship DeepSeek reasoning path with 1M context through CliRelay.",
+    "tone": "coral",
+    "inputPer1M": 0.435,
+    "cachedInputPer1M": 0.003625,
+    "outputPer1M": 0.87,
+    "contextWindow": 1000000
   }
 ]