theclawbay 0.3.58 → 0.3.60

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

@@ -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())
@@ -1948,14 +1962,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,6 +2078,12 @@ async function persistClaudeEditorSettings(params) {
                 nextEnv[name] = value;
                 changed = true;
             }
+            for (const name of MANAGED_CLAUDE_ENV_NAMES) {
+                if (name in desiredEnv || !(name in nextEnv))
+                    continue;
+                delete nextEnv[name];
+                changed = true;
+            }
             settings[CLAUDE_CODE_EDITOR_ENV_SETTING] = nextEnv;
             if (settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] !== true) {
                 settings[CLAUDE_CODE_EDITOR_DISABLE_LOGIN_PROMPT_SETTING] = true;
@@ -2093,6 +2108,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) => {
@@ -2846,6 +2981,7 @@ 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;
@@ -2908,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");
@@ -3137,6 +3289,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)

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/package.json

@@ -1,8 +1,12 @@
 {
   "name": "theclawbay",
-  "version": "0.3.58",
+  "version": "0.3.60",
   "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

@@ -17,6 +17,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",