theclawbay 0.3.59 → 0.3.61

package/README.md

@@ -29,3 +29,7 @@ Saves the API key without writing local client config.
 `theclawbay logout`
 
 Removes The Claw Bay-managed local config from this machine.
+
+`theclawbay usage`
+
+Shows your current shared 5-hour and weekly usage windows.

package/dist/commands/setup.js

@@ -27,7 +27,7 @@ const DEFAULT_PROVIDER_ID = "theclawbay";
 const CLI_HTTP_USER_AGENT = "theclawbay-cli";
 const SUPPORTED_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
 const MODEL_DISPLAY_NAMES = (0, supported_models_1.getSupportedModelDisplayNames)();
-const DEFAULT_CODEX_MODEL = SUPPORTED_MODEL_IDS[0] ?? "gpt-5.4";
+const DEFAULT_CODEX_MODEL = SUPPORTED_MODEL_IDS.includes("gpt-5.4") ? "gpt-5.4" : (SUPPORTED_MODEL_IDS[0] ?? "gpt-5.4");
 const DEFAULT_CONTINUE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_CLINE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_OPENCLAW_MODEL = DEFAULT_CODEX_MODEL;
@@ -37,7 +37,7 @@ const DEFAULT_TRAE_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_AIDER_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_ZO_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_MODELS = [...SUPPORTED_MODEL_IDS];
-const PREFERRED_MODELS = [...SUPPORTED_MODEL_IDS];
+const PREFERRED_MODELS = Array.from(new Set(["gpt-5.5", ...SUPPORTED_MODEL_IDS]));
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
 const CLAUDE_ENV_API_KEY_NAME = "ANTHROPIC_API_KEY";
 const CLAUDE_ENV_BASE_URL_NAME = "ANTHROPIC_BASE_URL";
@@ -49,6 +49,8 @@ const CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING = "claudeCode.disableLogin
 const ANTHROPIC_PROVIDER_ID = "anthropic";
 const MANAGED_EDITOR_TERMINAL_ENV_NAMES = [
     ENV_KEY_NAME,
+];
+const MANAGED_CLAUDE_ENV_NAMES = [
     CLAUDE_ENV_API_KEY_NAME,
     CLAUDE_ENV_BASE_URL_NAME,
     CLAUDE_ENV_SIMPLE_MODE_NAME,
@@ -736,6 +738,18 @@ async function readFileIfExists(filePath) {
         throw error;
     }
 }
+async function removeFileIfExists(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
 async function readJsonObjectFile(filePath) {
     const existingRaw = await readFileIfExists(filePath);
     if (existingRaw === null || !existingRaw.trim())
@@ -1519,7 +1533,6 @@ async function writeCodexConfig(params) {
         'name = "OpenAI"',
         `base_url = "${nativeCodexBaseUrl}"`,
         'wire_api = "responses"',
-        "requires_openai_auth = true",
         "supports_websockets = true",
         `experimental_bearer_token = "${params.apiKey}"`,
         MANAGED_END,
@@ -1948,14 +1961,9 @@ function terminalIntegratedEnvSettingsKey() {
     return "terminal.integrated.env.linux";
 }
 function buildManagedEditorTerminalEnv(params) {
-    const env = {
+    return {
         [ENV_KEY_NAME]: params.apiKey,
     };
-    if (params.claudeEnabled) {
-        env[CLAUDE_ENV_API_KEY_NAME] = params.apiKey;
-        env[CLAUDE_ENV_BASE_URL_NAME] = anthropicCompatibleProxyUrl(params.backendUrl);
-    }
-    return env;
 }
 function buildManagedClaudeEditorEnv(params) {
     return {
@@ -2069,7 +2077,7 @@ async function persistClaudeEditorSettings(params) {
                 nextEnv[name] = value;
                 changed = true;
             }
-            for (const name of MANAGED_EDITOR_TERMINAL_ENV_NAMES) {
+            for (const name of MANAGED_CLAUDE_ENV_NAMES) {
                 if (name in desiredEnv || !(name in nextEnv))
                     continue;
                 delete nextEnv[name];
@@ -2099,6 +2107,126 @@ async function persistClaudeEditorSettings(params) {
     await writeJsonObjectFile(CLAUDE_EDITOR_SETTINGS_STATE_PATH, Array.from(snapshotByPath.values()), 0o600);
     return managedPaths;
 }
+async function cleanupClaudeEditorSettings() {
+    const snapshotRaw = await readFileIfExists(CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return [];
+    let entries = [];
+    try {
+        entries = JSON.parse(snapshotRaw);
+    }
+    catch {
+        return [];
+    }
+    const updated = [];
+    for (const entry of entries) {
+        const settings = await readJsonObjectFile(entry.settingsPath);
+        if (!entry.envHadKey) {
+            delete settings[CLAUDE_CODE_EDITOR_ENV_SETTING];
+        }
+        else {
+            settings[CLAUDE_CODE_EDITOR_ENV_SETTING] = entry.envPreviousValue;
+        }
+        if (!entry.disableLoginPromptHadKey) {
+            delete settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING];
+        }
+        else {
+            settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = entry.disableLoginPromptPreviousValue;
+        }
+        if (entry.existed || Object.keys(settings).length > 0) {
+            await writeJsonObjectFile(entry.settingsPath, settings);
+            updated.push(entry.settingsPath);
+            continue;
+        }
+        if (await removeFileIfExists(entry.settingsPath)) {
+            updated.push(entry.settingsPath);
+        }
+    }
+    await removeFileIfExists(CLAUDE_EDITOR_SETTINGS_STATE_PATH);
+    return updated;
+}
+async function cleanupClaudeDesktop3pConfig() {
+    const snapshotRaw = await readFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return false;
+    let snapshot = null;
+    try {
+        snapshot = JSON.parse(snapshotRaw);
+    }
+    catch {
+        snapshot = null;
+    }
+    if (!snapshot?.configPath) {
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    if (!snapshot.existed) {
+        const removed = await removeFileIfExists(snapshot.configPath);
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return removed;
+    }
+    const previousRaw = snapshot.previousRaw ?? "";
+    const existingRaw = await readFileIfExists(snapshot.configPath);
+    if (existingRaw === previousRaw) {
+        await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+        return false;
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(snapshot.configPath), { recursive: true });
+    await promises_1.default.writeFile(snapshot.configPath, previousRaw, "utf8");
+    await removeFileIfExists(CLAUDE_DESKTOP_3P_STATE_PATH);
+    return true;
+}
+async function cleanupLegacyClaudeEditorTerminalEnvSettings(params) {
+    const snapshotRaw = await readFileIfExists(EDITOR_TERMINAL_ENV_STATE_PATH);
+    if (snapshotRaw === null || !snapshotRaw.trim())
+        return [];
+    let entries = [];
+    try {
+        entries = JSON.parse(snapshotRaw);
+    }
+    catch {
+        return [];
+    }
+    const settingsKey = terminalIntegratedEnvSettingsKey();
+    const managedClaudeEnv = {
+        [CLAUDE_ENV_API_KEY_NAME]: params.apiKey,
+        [CLAUDE_ENV_BASE_URL_NAME]: anthropicCompatibleProxyUrl(params.backendUrl),
+    };
+    const updated = [];
+    for (const entry of entries) {
+        const settings = await readJsonObjectFile(entry.settingsPath);
+        const currentValue = settings[settingsKey];
+        if (typeof currentValue !== "object" || currentValue === null || Array.isArray(currentValue))
+            continue;
+        const currentEnv = { ...currentValue };
+        const previousEnv = typeof entry.previousValue === "object" &&
+            entry.previousValue !== null &&
+            !Array.isArray(entry.previousValue)
+            ? { ...entry.previousValue }
+            : {};
+        let changed = false;
+        for (const name of MANAGED_CLAUDE_ENV_NAMES) {
+            const expectedManagedValue = managedClaudeEnv[name];
+            const currentManagedValue = currentEnv[name];
+            const currentMatchesManaged = typeof expectedManagedValue === "string" ? currentManagedValue === expectedManagedValue : false;
+            if (!currentMatchesManaged)
+                continue;
+            if (Object.prototype.hasOwnProperty.call(previousEnv, name)) {
+                currentEnv[name] = previousEnv[name];
+            }
+            else {
+                delete currentEnv[name];
+            }
+            changed = true;
+        }
+        if (!changed)
+            continue;
+        settings[settingsKey] = currentEnv;
+        await writeJsonObjectFile(entry.settingsPath, settings);
+        updated.push(entry.settingsPath);
+    }
+    return updated;
+}
 function expandClaudeDesktopInferenceModels(modelIds) {
     const expanded = [];
     const add = (value) => {
@@ -2285,10 +2413,12 @@ function objectRecordOr(value, fallback) {
 function modelContextLimit(modelId) {
     if (modelId === "gpt-5.4")
         return 1050000;
+    if (modelId === "gpt-5.5")
+        return 1000000;
     return 272000;
 }
 function modelOutputLimit(modelId) {
-    if (modelId === "gpt-5.4")
+    if (modelId === "gpt-5.4" || modelId === "gpt-5.5")
         return 128000;
     return 65536;
 }
@@ -2852,9 +2982,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             let updatedVsCodeEnvFiles = [];
             let updatedEditorTerminalSettings = [];
             let updatedClaudeEditorSettings = [];
+            let restoredClaudeDesktop3pConfig = false;
             let claudeDesktop3pConfigPathManaged = null;
             let sessionMigration = null;
-            let authSeed = null;
             let authSeedCleanup = null;
             let stateDbMigration = null;
             let modelCacheMigration = null;
@@ -2914,18 +3044,34 @@ class SetupCommand extends base_command_1.BaseCommand {
                         backendUrl,
                         claudeEnabled: claudeEnvEnabled,
                     });
-                    if (selectedSetupClients.has("claude")) {
-                        updatedClaudeEditorSettings = await persistClaudeEditorSettings({
-                            apiKey: authCredential,
-                            backendUrl,
-                            claudeEnabled: claudeEnvEnabled,
-                        });
+                }
+                if (selectedSetupClients.has("claude")) {
+                    updatedClaudeEditorSettings = await persistClaudeEditorSettings({
+                        apiKey: authCredential,
+                        backendUrl,
+                        claudeEnabled: claudeEnvEnabled,
+                    });
+                    if (claudeEnvEnabled) {
                         claudeDesktop3pConfigPathManaged = await writeClaudeDesktop3pConfig({
                             backendUrl,
                             apiKey: authCredential,
                             claudeModels: claudeAccess?.enabled ? claudeAccess.models : [],
                         });
                     }
+                    else {
+                        restoredClaudeDesktop3pConfig = await cleanupClaudeDesktop3pConfig();
+                    }
+                }
+                else {
+                    updatedEditorTerminalSettings = [
+                        ...updatedEditorTerminalSettings,
+                        ...await cleanupLegacyClaudeEditorTerminalEnvSettings({
+                            apiKey: authCredential,
+                            backendUrl,
+                        }),
+                    ];
+                    updatedClaudeEditorSettings = await cleanupClaudeEditorSettings();
+                    restoredClaudeDesktop3pConfig = await cleanupClaudeDesktop3pConfig();
                 }
                 if (selectedSetupClients.has("codex")) {
                     progress.update("Configuring Codex");
@@ -2944,10 +3090,6 @@ class SetupCommand extends base_command_1.BaseCommand {
                     authSeedCleanup = await (0, codex_auth_seeding_1.cleanupSeededCodexAuth)({
                         codexHome: paths_1.codexDir,
                     });
-                    authSeed = await (0, codex_auth_seeding_1.ensureCodexUsageLimitAuth)({
-                        codexHome: paths_1.codexDir,
-                        apiKey: authCredential,
-                    });
                     if (migrateCodexConversations) {
                         stateDbMigration = await (0, codex_history_migration_1.migrateStateDbProviders)({
                             codexHome: paths_1.codexDir,
@@ -3086,12 +3228,13 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             if (modelCacheMigration?.warning)
                 summaryNotes.add(modelCacheMigration.warning);
-            if (authSeed?.warning)
-                summaryNotes.add(authSeed.warning);
             if (authSeedCleanup?.warning)
                 summaryNotes.add(authSeedCleanup.warning);
-            if (authSeed?.replacedExistingAuth) {
-                summaryNotes.add("Codex usage visibility temporarily replaced your existing local Codex auth. `theclawbay logout` restores it.");
+            if (authSeedCleanup?.action === "removed") {
+                summaryNotes.add("Removed an older The Claw Bay Codex auth override that newer Codex releases now treat as invalid ChatGPT OAuth.");
+            }
+            else if (authSeedCleanup?.action === "restored_backup") {
+                summaryNotes.add("Restored the Codex auth that existed before an older The Claw Bay auth override.");
             }
             if (selectedSetupClients.has("codex") && !migrateCodexConversations) {
                 summaryNotes.add("Left existing Codex conversations untouched.");
@@ -3143,6 +3286,9 @@ class SetupCommand extends base_command_1.BaseCommand {
             if (updatedClaudeEditorSettings.length > 0) {
                 this.log(`- Claude editor settings updated: ${updatedClaudeEditorSettings.join(", ")}`);
             }
+            if (restoredClaudeDesktop3pConfig) {
+                this.log("- Claude Desktop 3P config: restored the pre-The Claw Bay config.");
+            }
             if (selectedSetupClients.has("codex")) {
                 this.log(`- Codex: configured (${codexConfigPath})`);
                 if (resolved)
@@ -3171,19 +3317,19 @@ class SetupCommand extends base_command_1.BaseCommand {
                     this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
                 }
                 if (modelCacheMigration?.action === "seeded") {
-                    this.log("- Codex model cache: added GPT-5.4 / GPT-5.4 Mini to the local picker cache.");
+                    this.log("- Codex model cache: added the current The Claw Bay model catalog to the local picker cache.");
                 }
                 else if (modelCacheMigration?.action === "created") {
-                    this.log("- Codex model cache: created a local picker cache with GPT-5.4 / GPT-5.4 Mini.");
+                    this.log("- Codex model cache: created a local picker cache with the current The Claw Bay model catalog.");
                 }
                 else if (modelCacheMigration?.action === "refreshed") {
-                    this.log("- Codex model cache: refreshed the local picker cache for GPT-5.4 / GPT-5.4 Mini.");
+                    this.log("- Codex model cache: refreshed the local picker cache for the current The Claw Bay model catalog.");
                 }
                 else if (modelCacheMigration?.action === "already_seeded") {
-                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini were already seeded locally.");
+                    this.log("- Codex model cache: the current The Claw Bay model catalog was already seeded locally.");
                 }
                 else if (modelCacheMigration?.action === "already_present") {
-                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini already existed locally.");
+                    this.log("- Codex model cache: the current The Claw Bay model catalog already existed locally.");
                 }
                 else if (modelCacheMigration?.warning) {
                     this.log(`- Codex model cache: ${modelCacheMigration.warning}`);
@@ -3191,6 +3337,18 @@ class SetupCommand extends base_command_1.BaseCommand {
                 else if (modelCacheMigration) {
                     this.log("- Codex model cache: no change.");
                 }
+                if (authSeedCleanup?.action === "restored_backup") {
+                    this.log("- Codex login state: restored the auth that existed before an older The Claw Bay override.");
+                }
+                else if (authSeedCleanup?.action === "removed") {
+                    this.log("- Codex login state: removed the older The Claw Bay ChatGPT-token override for compatibility with current Codex releases.");
+                }
+                else if (authSeedCleanup?.warning) {
+                    this.log(`- Codex login state: ${authSeedCleanup.warning}`);
+                }
+                else {
+                    this.log("- Codex login state: using provider-scoped bearer auth only; no fake ChatGPT auth tokens were seeded.");
+                }
             }
             else if (codexDetected) {
                 this.log("- Codex: detected but skipped");
@@ -3319,36 +3477,6 @@ class SetupCommand extends base_command_1.BaseCommand {
             else {
                 this.log("- Claude Code: not detected (skipped)");
             }
-            if (authSeed?.action === "seeded" && authSeed.mode === "chatgpt-auth-tokens") {
-                this.log("- Codex login state: seeded local Codex auth so remaining usage can be shown.");
-            }
-            else if (authSeed?.action === "updated" && authSeed.mode === "chatgpt-auth-tokens") {
-                this.log("- Codex login state: refreshed the local usage-limit auth seed.");
-            }
-            else if (authSeed?.action === "already_seeded" && authSeed.mode === "chatgpt-auth-tokens") {
-                this.log("- Codex login state: the local usage-limit auth seed was already present.");
-            }
-            else if (authSeed?.action === "seeded") {
-                this.log("- Codex login state: seeded local API-key auth.");
-            }
-            else if (authSeed?.action === "updated") {
-                this.log("- Codex login state: refreshed the local API-key auth seed.");
-            }
-            else if (authSeed?.action === "already_seeded") {
-                this.log("- Codex login state: the local API-key auth seed was already present.");
-            }
-            else if (authSeed?.action === "already_present") {
-                this.log("- Codex login state: preserved existing local Codex auth.");
-            }
-            else if (authSeed?.warning) {
-                this.log(`- Codex login state: ${authSeed.warning}`);
-            }
-            else if (authSeed) {
-                this.log("- Codex login state: no change.");
-            }
-            if (authSeedCleanup?.action === "restored_backup") {
-                this.log("- Codex login state: restored the auth that existed before an older The Claw Bay Codex auth override.");
-            }
             this.log("Next: restart Continue, Cline, Roo Code, Trae, or Zo only if they were already open during setup.");
         });
     }

package/dist/commands/usage.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../lib/base-command";
+export default class UsageCommand extends BaseCommand {
+    static description: string;
+    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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/usage.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../lib/base-command");
+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";
+function formatPercent(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return "n/a";
+    return `${value.toFixed(value >= 10 ? 1 : 2).replace(/\.0+$/u, "").replace(/(\.\d*?)0+$/u, "$1")}%`;
+}
+function formatUsd(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return "n/a";
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(value);
+}
+function formatTimestamp(value) {
+    if (!value)
+        return "n/a";
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        return value;
+    return new Date(parsed).toISOString();
+}
+function formatDuration(seconds) {
+    const totalSeconds = Math.max(0, Math.round(seconds));
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const remainingSeconds = totalSeconds % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (parts.length === 0 || (parts.length < 2 && remainingSeconds > 0)) {
+        parts.push(`${remainingSeconds}s`);
+    }
+    return parts.slice(0, 2).join(" ");
+}
+function printWindow(log, label, window, showCosts) {
+    log(`${label}`);
+    log(`  Used: ${formatPercent(window.progressPercentUsed ?? window.percentUsed)}`);
+    log(`  Remaining: ${formatPercent(window.percentRemaining)}`);
+    log(`  Requests: ${window.requestCount} total, ${window.successCount} succeeded, ${window.failedCount} failed`);
+    log(`  Runtime: ${window.runtimeSecondsUsed.toFixed(1)}s`);
+    log(`  Resets: ${formatDuration(window.secondsUntilReset)} (${formatTimestamp(window.windowEnd)})`);
+    if (showCosts) {
+        log(`  Cost: ${formatUsd(window.estimatedCostUsdUsed)} used / ${formatUsd(window.costUsdLimit)} limit / ${formatUsd(window.costUsdRemaining)} remaining`);
+    }
+    log(`  Last request: ${formatTimestamp(window.lastRequestAt)}`);
+    if (window.limitReached) {
+        log("  Status: limit reached");
+    }
+}
+class UsageCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const { flags } = await this.parse(UsageCommand);
+            let managed = null;
+            try {
+                managed = await (0, config_1.readManagedConfig)();
+            }
+            catch (error) {
+                if (!(error instanceof errors_1.ManagedConfigMissingError))
+                    throw error;
+            }
+            const credential = (flags["api-key"] ?? managed?.credential ?? "").trim();
+            if (!credential) {
+                this.error('No saved credential found. Run "theclawbay setup" or pass --api-key.');
+            }
+            const backendRaw = flags.backend ??
+                (0, api_key_1.tryInferBackendUrlFromApiKey)(credential) ??
+                managed?.backendUrl ??
+                DEFAULT_BACKEND_URL;
+            const backendUrl = backendRaw.replace(/\/+$/u, "");
+            const response = await fetch(`${backendUrl}/api/codex-auth/v1/quota`, {
+                headers: {
+                    Authorization: `Bearer ${credential}`,
+                    Accept: "application/json",
+                },
+                signal: AbortSignal.timeout(20000),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok) {
+                this.error(body.error || `Failed to load usage (HTTP ${response.status})`);
+            }
+            if (flags.json) {
+                this.log(JSON.stringify(body, null, 2));
+                return;
+            }
+            const showCosts = body.usageLimitPresentation !== "percent_only";
+            this.log("The Claw Bay usage");
+            this.log(`Observed: ${formatTimestamp(body.observedAt)}`);
+            this.log(`Auth scope: ${body.pooled ? "shared pooled usage" : body.mode}`);
+            if (body.mode === "direct" && typeof body.planMultiplier === "number" && Number.isFinite(body.planMultiplier)) {
+                this.log(`Plan multiplier: ${body.planMultiplier}x`);
+            }
+            if (body.anyLimitReached) {
+                this.log("Status: at least one usage window has been reached");
+            }
+            this.log("");
+            printWindow((message) => this.log(message), "5-hour window", body.usage.fiveHour, showCosts);
+            this.log("");
+            printWindow((message) => this.log(message), "Weekly window", body.usage.weekly, showCosts);
+        });
+    }
+}
+UsageCommand.description = "Show your current The Claw Bay pooled 5-hour and weekly usage";
+UsageCommand.flags = {
+    backend: core_1.Flags.string({
+        required: false,
+        description: "Backend base URL override (default: saved managed config or https://theclawbay.com)",
+    }),
+    "api-key": core_1.Flags.string({
+        required: false,
+        aliases: ["apiKey"],
+        description: "API key or linked device-session token override",
+    }),
+    json: core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Print the raw quota response as JSON",
+    }),
+};
+exports.default = UsageCommand;

package/dist/lib/codex-auth-seeding.js

@@ -240,12 +240,11 @@ async function ensureCodexApiKeyAuth(params) {
     });
 }
 async function ensureCodexUsageLimitAuth(params) {
-    return ensureCodexAuth({
-        codexHome: params.codexHome,
-        apiKey: params.apiKey,
-        mode: "chatgpt-auth-tokens",
-        replaceExistingAuth: true,
-    });
+    // Current Codex releases treat chatgptAuthTokens.access_token as a real
+    // ChatGPT JWT and use it against chatgpt.com. The Claw Bay credentials are
+    // provider-scoped bearer tokens, so the legacy fake-ChatGPT seed path is no
+    // longer safe to apply here.
+    return ensureCodexApiKeyAuth(params);
 }
 async function cleanupSeededCodexAuth(params) {
     const authPath = node_path_1.default.join(params.codexHome, AUTH_FILE);

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

@@ -14,13 +14,15 @@ const supported_models_1 = require("./supported-models");
 const MODELS_CACHE_FILE = "models_cache.json";
 const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
-const TARGET_MODEL_IDS = ["gpt-5.4", "gpt-5.4-mini"];
+const TARGET_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)();
 const TARGET_MODEL_ID_SET = new Set(TARGET_MODEL_IDS);
 const SEED_MARKER_KEY = "_theclawbay_seeded";
 // Older releases stored the model id as the marker value; accept those so cleanup still works.
 const SEED_MARKER_VALUE = "theclawbay";
-const LEGACY_SEED_MARKER_VALUES = new Set(["gpt-5.4", SEED_MARKER_VALUE, true]);
-const TEMPLATE_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)().filter((id) => !TARGET_MODEL_ID_SET.has(id));
+const LEGACY_SEED_MARKER_VALUES = new Set([...TARGET_MODEL_IDS, SEED_MARKER_VALUE, true]);
+const SUPPORTED_MODELS = (0, supported_models_1.getSupportedModels)();
+const SUPPORTED_MODEL_CONFIG = new Map(SUPPORTED_MODELS.map((model) => [model.id, model]));
+const TEMPLATE_MODEL_IDS = TARGET_MODEL_IDS;
 const DEFAULT_REASONING_LEVELS = [
     { effort: "low", description: "Fast responses with lighter reasoning" },
     { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
@@ -166,14 +168,13 @@ function applySeedMarker(model) {
     return next;
 }
 function seedDescription(modelId) {
-    if (modelId === "gpt-5.4-mini")
-        return "Smaller GPT-5.4 variant for quick iterations.";
-    return "Latest frontier agentic coding model.";
+    return SUPPORTED_MODEL_CONFIG.get(modelId)?.note ?? "The Claw Bay model.";
 }
 function normalizeSeedModel(template, modelId) {
+    const modelConfig = SUPPORTED_MODEL_CONFIG.get(modelId);
     const seed = applySeedMarker(template ?? {});
     seed.slug = modelId;
-    seed.display_name = modelId;
+    seed.display_name = modelConfig?.label ?? modelId;
     seed.description = seedDescription(modelId);
     if (typeof seed.default_reasoning_level !== "string") {
         seed.default_reasoning_level = "medium";
@@ -387,7 +388,7 @@ async function ensureCodexModelCacheHasGpt54(params) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe GPT-5.4 / GPT-5.4 Mini seed.",
+                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe The Claw Bay model seed.",
                 };
             }
             const docModels = [];
@@ -411,7 +412,7 @@ async function ensureCodexModelCacheHasGpt54(params) {
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped GPT-5.4 / GPT-5.4 Mini seed.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped The Claw Bay model seed.",
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
@@ -522,7 +523,7 @@ async function cleanupSeededCodexModelCache(params) {
         if (!doc) {
             return {
                 action: "none",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; left GPT-5.4 / GPT-5.4 Mini cache patch state untouched.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; left The Claw Bay model cache patch state untouched.",
             };
         }
         let removed = 0;

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "theclawbay",
-  "version": "0.3.59",
+  "version": "0.3.61",
   "description": "CLI for connecting Codex, Continue, Cline, GSD, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RCRTCBHAL900/TheClawBay"
+  },
   "bin": {
     "theclawbay": "dist/index.js"
   },

package/theclawbay-supported-models.json

@@ -1,4 +1,13 @@
 [
+  {
+    "id": "gpt-5.5",
+    "label": "GPT-5.5",
+    "note": "Newest Codex model for stronger coding and agentic work.",
+    "tone": "coral",
+    "inputPer1M": 5.0,
+    "cachedInputPer1M": 0.5,
+    "outputPer1M": 30.0
+  },
   {
     "id": "gpt-5.4",
     "label": "GPT-5.4",
@@ -17,6 +26,15 @@
     "cachedInputPer1M": 0.125,
     "outputPer1M": 10.0
   },
+  {
+    "id": "gpt-image-1.5",
+    "label": "GPT Image 1.5",
+    "note": "Native image generation model for direct image outputs.",
+    "tone": "coral",
+    "inputPer1M": 8.0,
+    "cachedInputPer1M": 2.0,
+    "outputPer1M": 32.0
+  },
   {
     "id": "gpt-5.3-codex",
     "label": "GPT-5.3 Codex",