theclawbay 0.3.76 → 0.3.78

package/README.md

@@ -1,6 +1,6 @@
 # theclawbay
 
-CLI for connecting Codex, 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
 
@@ -16,9 +16,10 @@ Get your API key from `https://theclawbay.com/dashboard`.
 theclawbay setup --api-key <apiKey>
 ```
 
-In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, Windows Trae, and Zo.
+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/logout.js

@@ -71,6 +71,8 @@ const THECLAWBAY_CANONICAL_API_HOST = "api.theclawbay.com";
 const THECLAWBAY_WEBSITE_HOSTS = new Set(["theclawbay.com", "www.theclawbay.com"]);
 const SUPPORTED_MODEL_IDS = new Set((0, supported_models_1.getSupportedModelIds)());
 const CONTINUE_MODEL_NAME = "The Claw Bay";
+const HERMES_PROVIDER_NAME = "The Claw Bay";
+const HERMES_KEY_ENV_NAME = "HERMES_THECLAWBAY_API_KEY";
 const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
 const TRAE_BUNDLE_BACKUP_SUFFIX = ".theclawbay-managed-backup";
 const MANAGED_EDITOR_TERMINAL_ENV_NAMES = [
@@ -272,6 +274,36 @@ async function readFileIfExists(filePath) {
         throw error;
     }
 }
+function hermesHomeDir() {
+    const raw = process.env.HERMES_HOME?.trim();
+    if (raw)
+        return raw;
+    return node_path_1.default.join(node_os_1.default.homedir(), ".hermes");
+}
+function hermesConfigPath() {
+    return node_path_1.default.join(hermesHomeDir(), "config.yaml");
+}
+function hermesEnvPath() {
+    return node_path_1.default.join(hermesHomeDir(), ".env");
+}
+async function removeDotEnvValue(filePath, key) {
+    const existing = await readFileIfExists(filePath);
+    if (existing === null)
+        return false;
+    const nextLines = existing
+        .split(/\r?\n/)
+        .filter((line) => !new RegExp(`^\\s*${key}\\s*=`).test(line));
+    const next = `${nextLines.join("\n").trimEnd()}\n`;
+    const normalizedExisting = `${existing.trimEnd()}\n`;
+    if (next === normalizedExisting)
+        return false;
+    if (!next.trim()) {
+        return removeFileIfExists(filePath);
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, next, "utf8");
+    return true;
+}
 function localAppDataDir() {
     if (process.env.LOCALAPPDATA?.trim())
         return process.env.LOCALAPPDATA;
@@ -1308,6 +1340,85 @@ async function cleanupKiloConfig() {
         restoreStatePath: KILO_RESTORE_STATE_PATH,
     });
 }
+async function cleanupHermesConfig() {
+    const configPath = hermesConfigPath();
+    const envPath = hermesEnvPath();
+    const existingRaw = await readFileIfExists(configPath);
+    let configChanged = false;
+    let removedManagedProvider = false;
+    const removedProviderBaseUrls = new Set();
+    if (existingRaw !== null && existingRaw.trim()) {
+        try {
+            const existingConfig = objectRecordOr((0, yaml_1.parseDocument)(existingRaw).toJS(), {});
+            const nextConfig = { ...existingConfig };
+            const rawCustomProviders = Array.isArray(existingConfig.custom_providers)
+                ? existingConfig.custom_providers
+                : [];
+            const nextCustomProviders = rawCustomProviders.filter((entry) => {
+                if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                    return true;
+                const record = entry;
+                const name = typeof record.name === "string" ? record.name.trim() : "";
+                const providerBaseUrl = typeof record.base_url === "string" ? record.base_url.trim().replace(/\/+$/g, "") : "";
+                const keyEnv = typeof record.key_env === "string" ? record.key_env.trim() : "";
+                if (keyEnv === HERMES_KEY_ENV_NAME) {
+                    removedManagedProvider = true;
+                    if (providerBaseUrl)
+                        removedProviderBaseUrls.add(providerBaseUrl);
+                    return false;
+                }
+                if (name === HERMES_PROVIDER_NAME && isTheClawBayOpenAiCompatibleBaseUrl(providerBaseUrl)) {
+                    removedManagedProvider = true;
+                    if (providerBaseUrl)
+                        removedProviderBaseUrls.add(providerBaseUrl);
+                    return false;
+                }
+                return true;
+            });
+            if (nextCustomProviders.length !== rawCustomProviders.length) {
+                configChanged = true;
+            }
+            if (nextCustomProviders.length > 0) {
+                nextConfig.custom_providers = nextCustomProviders;
+            }
+            else if ("custom_providers" in nextConfig) {
+                delete nextConfig.custom_providers;
+                configChanged = true;
+            }
+            const modelConfig = objectRecordOr(existingConfig.model, {});
+            const provider = typeof modelConfig.provider === "string" ? modelConfig.provider.trim() : "";
+            const baseUrl = typeof modelConfig.base_url === "string" ? modelConfig.base_url.trim().replace(/\/+$/g, "") : "";
+            const apiMode = typeof modelConfig.api_mode === "string" ? modelConfig.api_mode.trim() : "";
+            const shouldRemoveManagedModel = provider === "custom" &&
+                (isTheClawBayOpenAiCompatibleBaseUrl(baseUrl) ||
+                    (removedManagedProvider && apiMode === "codex_responses" && removedProviderBaseUrls.has(baseUrl)));
+            if (shouldRemoveManagedModel) {
+                for (const key of ["provider", "default", "base_url", "api_mode", "api_key", "context_length"]) {
+                    if (key in modelConfig) {
+                        delete modelConfig[key];
+                        configChanged = true;
+                    }
+                }
+                if (Object.keys(modelConfig).length > 0) {
+                    nextConfig.model = modelConfig;
+                }
+                else if ("model" in nextConfig) {
+                    delete nextConfig.model;
+                    configChanged = true;
+                }
+            }
+            if (configChanged) {
+                await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+                await promises_1.default.writeFile(configPath, (0, yaml_1.stringify)(nextConfig), "utf8");
+            }
+        }
+        catch {
+            // Leave invalid user config untouched; still remove our dedicated env key below.
+        }
+    }
+    const envChanged = await removeDotEnvValue(envPath, HERMES_KEY_ENV_NAME);
+    return configChanged || envChanged;
+}
 async function cleanupTraeBundle() {
     const bundlePath = traeBundlePath();
     if (!bundlePath)
@@ -1359,6 +1470,7 @@ class LogoutCommand extends base_command_1.BaseCommand {
             let updatedOpenCodeConfig = false;
             let updatedKiloConfig = false;
             let updatedRooConfig = false;
+            let updatedHermesConfig = false;
             let updatedTraeBundle = false;
             let updatedAiderConfig = false;
             let sessionMigration;
@@ -1436,6 +1548,8 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 updatedKiloConfig = await cleanupKiloConfig();
                 progress.update("Reverting Roo Code");
                 updatedRooConfig = await cleanupRooConfig();
+                progress.update("Reverting Hermes");
+                updatedHermesConfig = await cleanupHermesConfig();
                 progress.update("Reverting Trae");
                 updatedTraeBundle = await cleanupTraeBundle();
                 progress.update("Reverting Aider");
@@ -1491,6 +1605,8 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 revertedTargets.push("Kilo Code");
             if (updatedRooConfig)
                 revertedTargets.push("Roo Code");
+            if (updatedHermesConfig)
+                revertedTargets.push("Hermes");
             if (updatedTraeBundle)
                 revertedTargets.push("Trae");
             if (updatedAiderConfig)
@@ -1595,6 +1711,7 @@ class LogoutCommand extends base_command_1.BaseCommand {
             this.log(`- OpenCode config cleaned: ${updatedOpenCodeConfig ? "yes" : "no"}`);
             this.log(`- Kilo config cleaned: ${updatedKiloConfig ? "yes" : "no"}`);
             this.log(`- Roo Code setup hook cleaned: ${updatedRooConfig ? "yes" : "no"}`);
+            this.log(`- Hermes config cleaned: ${updatedHermesConfig ? "yes" : "no"}`);
             this.log(`- Trae experimental patch cleaned: ${updatedTraeBundle ? "yes" : "no"}`);
             this.log(`- Aider config cleaned: ${updatedAiderConfig ? "yes" : "no"}`);
             this.log("Note: restart terminals/VS Code windows to clear already-loaded shell environment.");

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");
@@ -36,6 +37,7 @@ const DEFAULT_ROO_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_TRAE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_AIDER_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_ZO_MODEL = DEFAULT_CODEX_MODEL;
+const DEFAULT_HERMES_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_MODELS = [...SUPPORTED_MODEL_IDS];
 const PREFERRED_MODELS = [...SUPPORTED_MODEL_IDS];
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
@@ -92,7 +94,7 @@ 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]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = ["openai", DEFAULT_PROVIDER_ID, "theclawbay-wan"];
-const SETUP_CLIENT_IDS = ["codex", "claude", "continue", "cline", "gsd", "openclaw", "opencode", "kilo", "roo", "trae", "aider", "zo"];
+const SETUP_CLIENT_IDS = ["codex", "claude", "continue", "cline", "gsd", "openclaw", "opencode", "kilo", "roo", "trae", "aider", "zo", "hermes"];
 const LEGACY_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
 const CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/v1";
 const CANONICAL_CODEX_NATIVE_PROXY_SUFFIX = "/backend-api/codex";
@@ -113,6 +115,8 @@ const ZO_CONFIG_NAME_PREFIX = "The Claw Bay";
 const ZO_COOKIE_HOST = ".zo.computer";
 const ZO_ACCESS_TOKEN_COOKIE = "access_token";
 const ZO_API_BASE_URL = "https://api.zo.computer";
+const HERMES_PROVIDER_NAME = "The Claw Bay";
+const HERMES_KEY_ENV_NAME = "HERMES_THECLAWBAY_API_KEY";
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/g, "");
 }
@@ -1225,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)
@@ -1511,6 +1571,111 @@ async function detectZoClient() {
     }
     return false;
 }
+function hermesHomeDir() {
+    const raw = process.env.HERMES_HOME?.trim();
+    if (raw)
+        return raw;
+    return node_path_1.default.join(node_os_1.default.homedir(), ".hermes");
+}
+function hermesConfigPath() {
+    return node_path_1.default.join(hermesHomeDir(), "config.yaml");
+}
+function hermesEnvPath() {
+    return node_path_1.default.join(hermesHomeDir(), ".env");
+}
+async function detectHermesClient() {
+    if (hasCommand("hermes"))
+        return true;
+    const candidates = [
+        hermesHomeDir(),
+        hermesConfigPath(),
+        hermesEnvPath(),
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate))
+            return true;
+    }
+    return false;
+}
+function formatDotEnvValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function upsertDotEnvValue(filePath, key, value) {
+    const existing = (await readFileIfExists(filePath)) ?? "";
+    const lines = existing ? existing.split(/\r?\n/) : [];
+    const assignment = `${key}=${formatDotEnvValue(value)}`;
+    let changed = false;
+    let replaced = false;
+    const nextLines = lines.map((line) => {
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            replaced = true;
+            if (line === assignment)
+                return line;
+            changed = true;
+            return assignment;
+        }
+        return line;
+    });
+    if (!replaced) {
+        if (nextLines.length > 0 && nextLines[nextLines.length - 1]?.trim()) {
+            nextLines.push("");
+        }
+        nextLines.push(assignment);
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, `${nextLines.join("\n").trimEnd()}\n`, "utf8");
+    return true;
+}
+async function writeHermesConfig(params) {
+    const configPath = hermesConfigPath();
+    const envPath = hermesEnvPath();
+    const baseUrl = openAiCompatibleProxyUrl(params.backendUrl);
+    const selectedModel = params.model.trim() || DEFAULT_HERMES_MODEL;
+    const existingRaw = await readFileIfExists(configPath);
+    const existingConfig = existingRaw?.trim()
+        ? objectRecordOr((0, yaml_1.parseDocument)(existingRaw).toJS(), {})
+        : {};
+    const nextConfig = { ...existingConfig };
+    const modelConfig = objectRecordOr(existingConfig.model, {});
+    modelConfig.provider = "custom";
+    modelConfig.default = selectedModel;
+    modelConfig.base_url = baseUrl;
+    modelConfig.api_mode = "codex_responses";
+    delete modelConfig.api_key;
+    delete modelConfig.context_length;
+    nextConfig.model = modelConfig;
+    const rawCustomProviders = Array.isArray(existingConfig.custom_providers)
+        ? existingConfig.custom_providers
+        : [];
+    const nextCustomProviders = rawCustomProviders.filter((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return true;
+        const record = entry;
+        const name = typeof record.name === "string" ? record.name.trim() : "";
+        const providerBaseUrl = typeof record.base_url === "string" ? record.base_url.trim() : "";
+        const keyEnv = typeof record.key_env === "string" ? record.key_env.trim() : "";
+        if (keyEnv === HERMES_KEY_ENV_NAME)
+            return false;
+        if (name === HERMES_PROVIDER_NAME && providerBaseUrl === baseUrl)
+            return false;
+        return true;
+    });
+    nextCustomProviders.push({
+        name: HERMES_PROVIDER_NAME,
+        base_url: baseUrl,
+        key_env: HERMES_KEY_ENV_NAME,
+        model: selectedModel,
+        api_mode: "codex_responses",
+    });
+    nextConfig.custom_providers = nextCustomProviders;
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    await promises_1.default.writeFile(configPath, (0, yaml_1.stringify)(nextConfig), "utf8");
+    await upsertDotEnvValue(envPath, HERMES_KEY_ENV_NAME, params.apiKey);
+    return [configPath, envPath];
+}
 async function resolveModels(backendUrl, apiKey) {
     const { ids, failure } = await fetchBackendModelIds(backendUrl, apiKey);
     const available = new Set(ids ?? []);
@@ -1570,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 });
@@ -2892,7 +3080,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                 managed?.backendUrl ??
                 DEFAULT_BACKEND_URL;
             const backendUrl = normalizeUrl(backendRaw, "--backend");
-            const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, openCodeDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected] = await Promise.all([
+            const [codexDetected, claudeDetected, continueDetected, clineDetected, gsdDetected, openCodeDetected, kiloDetected, rooDetected, traeDetected, aiderDetected, zoDetected, hermesDetected] = await Promise.all([
                 detectCodexClient(),
                 detectClaudeClient(),
                 detectContinueClient(),
@@ -2904,6 +3092,7 @@ class SetupCommand extends base_command_1.BaseCommand {
                 detectTraeClient(),
                 detectAiderClient(),
                 detectZoClient(),
+                detectHermesClient(),
             ]);
             const setupClients = [
                 {
@@ -3014,6 +3203,15 @@ class SetupCommand extends base_command_1.BaseCommand {
                     icon: "◉",
                     siteUrl: "https://www.zo.computer",
                 },
+                {
+                    id: "hermes",
+                    label: "Hermes Agent",
+                    summaryLabel: "Hermes",
+                    detected: hermesDetected,
+                    recommended: true,
+                    icon: "☿",
+                    siteUrl: "https://hermes-agent.nousresearch.com/docs/",
+                },
             ];
             const selectedSetupClients = await resolveSetupClientSelection({
                 setupClients,
@@ -3058,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 = [];
@@ -3082,6 +3281,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             let traeBundlePathPatched = null;
             let aiderConfigPath = null;
             let zoConfigName = null;
+            let hermesConfigPaths = [];
             try {
                 if (selectedSetupClients.size > 0) {
                     progress.update("Resolving supported models");
@@ -3089,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,
@@ -3138,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 {
@@ -3226,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,
                     });
                 }
@@ -3272,6 +3506,14 @@ class SetupCommand extends base_command_1.BaseCommand {
                         apiKey: authCredential,
                     });
                 }
+                if (selectedSetupClients.has("hermes")) {
+                    progress.update("Configuring Hermes Agent");
+                    hermesConfigPaths = await writeHermesConfig({
+                        backendUrl,
+                        model: resolved?.model ?? DEFAULT_HERMES_MODEL,
+                        apiKey: authCredential,
+                    });
+                }
             }
             catch (error) {
                 progress.fail("Setup failed");
@@ -3286,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) {
@@ -3302,6 +3547,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (selectedSetupClients.has("zo")) {
                 summaryNotes.add("Zo uses an experimental account-level BYOK API integration. Keep Zo signed in while running setup.");
             }
+            if (selectedSetupClients.has("hermes")) {
+                summaryNotes.add("Hermes Agent: added a named custom provider that uses HERMES_THECLAWBAY_API_KEY, so Hermes can keep its custom-endpoint routing without depending on OPENAI_BASE_URL.");
+            }
             if (openClawCliWarning)
                 summaryNotes.add(openClawCliWarning);
             if ((stateDbMigration?.failed.length ?? 0) > 0) {
@@ -3337,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"}`);
@@ -3551,6 +3802,16 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Zo: not detected (skipped)");
             }
+            if (selectedSetupClients.has("hermes")) {
+                this.log(`- Hermes Agent: configured (${hermesConfigPaths.join(", ")})`);
+                this.log("- Hermes Agent note: saved a named custom provider plus HERMES_THECLAWBAY_API_KEY so Hermes can reuse its custom-provider credential-pool path without relying on OPENAI_BASE_URL.");
+            }
+            else if (hermesDetected) {
+                this.log("- Hermes Agent: detected but skipped");
+            }
+            else {
+                this.log("- Hermes Agent: not detected (skipped)");
+            }
             if (selectedSetupClients.has("claude")) {
                 this.log(`- Claude Code: ${claudeAccess?.enabled ? "configured via shared env" : "selected, but no Claude access was detected for this credential"}`);
             }
@@ -3582,7 +3843,26 @@ SetupCommand.flags = {
     }),
     clients: core_1.Flags.string({
         required: false,
-        description: "Detected local clients to configure: codex, claude, continue, cline, gsd, openclaw, opencode, kilo, roo, trae, aider, zo",
+        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,

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,11 +1,11 @@
 {
   "name": "theclawbay",
-  "version": "0.3.76",
-  "description": "CLI for connecting Codex, Gemini-compatible apps, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
+  "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": {
     "type": "git",
-    "url": "git+https://github.com/RCRTCBHAL900/TheClawBay.git"
+    "url": "https://github.com/RCRTCBHAL900/TheClawBay"
   },
   "bin": {
     "theclawbay": "dist/index.js"
@@ -40,6 +40,7 @@
     "api-key",
     "continue",
     "cline",
+    "hermes",
     "gsd",
     "openclaw",
     "opencode",

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
   }
 ]