castle-web-cli 0.4.175 → 0.4.177

package/dist/agent-failures.d.ts

@@ -9,6 +9,8 @@ export interface AgentFailure {
     suggestion?: string;
     resetAtMs?: number;
     castleCreditsExhausted?: boolean;
+    castleCreditsInsufficient?: boolean;
+    castleSpendLimit?: boolean;
 }
 export declare function failureForStatus(status: number, body: string, model?: string): AgentFailure | undefined;
 export declare function classifyProviderError(text: string | undefined, model?: string): AgentFailure | undefined;

package/dist/agent-failures.js

@@ -46,8 +46,35 @@ export function failureForStatus(status, body, model) {
         return config("bad-key");
     if (status === 402)
         return config("no-credits");
-    if (status === 403)
+    if (status === 403) {
+        // Castle's proxy deliberately uses provider-shaped 403s for its own spend
+        // and model gates. A request-size reservation can refuse while the account
+        // still has a small positive balance, so pre-flight cannot catch this case.
+        // Keep the matches tied to the proxy's Castle-specific copy: a provider's
+        // ordinary permission/content 403 must continue to read as a refusal.
+        if (/Castle AI request[^.]*balance can(?:not|'t) cover|add credits at castle\.xyz\/credits/i.test(body)) {
+            return {
+                kind: "limit",
+                detail,
+                model,
+                verbose: `HTTP ${status}: ${body}`,
+                castleCreditsInsufficient: true,
+            };
+        }
+        if (/model\s+.+\s+(?:isn['’]t|is not) available on this Castle account/i.test(body)) {
+            return config("model-not-allowed");
+        }
+        if (/Castle AI spending limit reached/i.test(body)) {
+            return {
+                kind: "limit",
+                detail,
+                model,
+                verbose: `HTTP ${status}: ${body}`,
+                castleSpendLimit: true,
+            };
+        }
         return config("flagged");
+    }
     if (status === 429 || status >= 500) {
         return { kind: "transient", detail, model, verbose: `HTTP ${status}: ${body}` };
     }
@@ -178,9 +205,15 @@ export function failureCopy(opts) {
         case "config":
             return `${configCopy(opts.failure)}${tasksNote}`;
         case "limit":
+            if (opts.failure.castleCreditsInsufficient) {
+                return `Not enough Castle AI credits for this request — get more at castle.xyz/credits${tasksNote}`;
+            }
             if (opts.failure.castleCreditsExhausted) {
                 return `Out of Castle AI credits — get more at castle.xyz/credits${tasksNote}`;
             }
+            if (opts.failure.castleSpendLimit) {
+                return `Castle AI spending limit reached — check your balance at castle.xyz/credits${tasksNote}`;
+            }
             return `Daily Castle AI limit reached${resetsClause(opts.failure.resetAtMs)}. Runs on your own API key or login aren't limited.${tasksNote}`;
         case "transient":
             return `OpenRouter is busy right now and I couldn't get through. Send that again in a moment.${tasksNote}`;

package/dist/agent.js

@@ -31,7 +31,7 @@ import { applyPlanOps, buildRouterPromptParts, buildTaskPrompt, parsePlanOps, pl
 import { readCastleJson } from './castleJson.js';
 import { checkOpenrouterKey, checkOpenrouterModel, openrouterCatalogEntry, primeOpenrouterCatalog, } from './openrouter-catalog.js';
 import { classifyProviderError, failureCopy, setReaderTimeZone, } from './agent-failures.js';
-import { castleCreditsExhausted, fetchAiCredits, fetchBudget, meteringHeaders, newAgentSessionId, reportCursorRun, spendableMicros, withCustomHeaders, } from './metering.js';
+import { castleCreditsExhausted, createRefreshQueue, fetchAiCredits, fetchBudget, meteringHeaders, newAgentSessionId, reportCursorRun, spendableMicros, withCustomHeaders, } from './metering.js';
 import { anthropicKeyHelperCommand, claudeHasSavedLogin, cursorAuthPath, cursorHasUserLogin, resolveAnthropicAuth, userKey, ANTHROPIC_CREDENTIAL_ENV, ANTHROPIC_PROXY_ENV, CASTLE_USER_KEYS_PATH, } from './byo-auth.js';
 import { accountsSnapshot, loginProviderFor, watchCredentials, writeCredential, } from './byo-accounts.js';
 import { cancelLogin, logout, startLogin, submitLoginCode } from './byo-login.js';
@@ -2101,19 +2101,24 @@ function createUsageFeed(opts) {
     let latest = null;
     let credits = null;
     let budgetPolls = 0;
-    async function refreshAsync(refreshCredits = false) {
+    async function readUsage(refreshCredits = false) {
         if (!opts.castlePaid()) {
             credits = null;
-            publishUsage(null);
-            return;
+            return null;
         }
-        const [budget, nextCredits] = await Promise.all([
-            fetchBudget(),
-            refreshCredits ? fetchAiCredits() : Promise.resolve(credits),
-        ]);
-        if (refreshCredits)
-            credits = nextCredits;
-        publishUsage(usageFrame(budget, credits));
+        // Budget is the authoritative spendable amount and its read can force a
+        // stale proxy gate to sync after a purchase. Read credits second so the
+        // descriptive fields (plan, rate, reload state) describe that same or a
+        // newer account snapshot instead of racing ahead of the gate refresh.
+        const budget = await fetchBudget();
+        if (refreshCredits) {
+            const nextCredits = await fetchAiCredits();
+            // Once the richer field has loaded, a transient GraphQL failure should
+            // not erase it and fall the UI back to the legacy daily presentation.
+            if (nextCredits)
+                credits = nextCredits;
+        }
+        return usageFrame(budget, credits);
     }
     function publishUsage(next) {
         if (JSON.stringify(next ?? null) === JSON.stringify(latest ?? null))
@@ -2121,13 +2126,18 @@ function createUsageFeed(opts) {
         latest = next;
         opts.broadcast({ type: 'usage', usage: next });
     }
-    const refresh = () => void refreshAsync(true);
+    // Focus, host relay, popover-open and run-finished can all arrive together.
+    const refreshQueue = createRefreshQueue({ read: readUsage, publish: publishUsage });
+    const requestRefresh = (withCredits) => {
+        void refreshQueue.request(withCredits);
+    };
+    const refresh = () => requestRefresh(true);
     const stopRunWatch = onAgentRunFinished(refresh);
     const timer = setInterval(() => {
         if (!opts.hasClients())
             return;
         budgetPolls += 1;
-        void refreshAsync(budgetPolls % 5 === 0);
+        requestRefresh(budgetPolls % 5 === 0);
     }, USAGE_POLL_MS);
     timer.unref?.();
     refresh();

package/dist/metering.d.ts

@@ -66,6 +66,17 @@ export interface AiCredits {
     };
 }
 export declare function spendableMicros(budget: CastleBudget): number | null;
+/**
+ * Coalesce asynchronous refresh triggers without letting an older read finish
+ * after and overwrite a newer one. `withFullState` is sticky across queued
+ * calls: a cheap poll cannot downgrade a pending user-requested full refresh.
+ */
+export declare function createRefreshQueue<T>(opts: {
+    read: (withFullState: boolean) => Promise<T>;
+    publish: (value: T) => void;
+}): {
+    request: (withFullState: boolean) => Promise<void>;
+};
 export declare function castleCreditsExhausted(budget: CastleBudget, credits: AiCredits | null): boolean;
 /** Rich credit state, or null when ghost/proxy cannot provide the new field. */
 export declare function fetchAiCredits(): Promise<AiCredits | null>;

package/dist/metering.js

@@ -120,6 +120,39 @@ export function spendableMicros(budget) {
         return null;
     return Math.max(0, budget.limitMicros - budget.usedMicros);
 }
+/**
+ * Coalesce asynchronous refresh triggers without letting an older read finish
+ * after and overwrite a newer one. `withFullState` is sticky across queued
+ * calls: a cheap poll cannot downgrade a pending user-requested full refresh.
+ */
+export function createRefreshQueue(opts) {
+    let queued = false;
+    let queuedFullState = false;
+    let active = null;
+    const request = (withFullState) => {
+        queued = true;
+        queuedFullState ||= withFullState;
+        if (active)
+            return active;
+        active = (async () => {
+            while (queued) {
+                const fullState = queuedFullState;
+                queued = false;
+                queuedFullState = false;
+                const value = await opts.read(fullState);
+                // If another trigger arrived while this read was in flight, its result
+                // is already the one the caller wants. Skip the older intermediate
+                // frame instead of flashing it before the trailing refresh completes.
+                if (!queued)
+                    opts.publish(value);
+            }
+        })().finally(() => {
+            active = null;
+        });
+        return active;
+    };
+    return { request };
+}
 const EXHAUSTED_BALANCE_CREDITS = 50;
 export function castleCreditsExhausted(budget, credits) {
     if (!budget.blocked || credits?.plan !== "credits")

package/dist/serve.js

@@ -1021,11 +1021,13 @@ async function serveDetached(projectDir, options) {
     // this serve and it dies with the session.
     // `.unref()` is what lets the calling node process exit either way.
     const fullDetach = process.env.CASTLE_WEB_CLI_DETACH === '1';
+    const childEnv = { ...process.env };
+    delete childEnv.CASTLE_WEB_CLI_DETACH;
     const child = spawn(process.execPath, [entry, ...args], {
         cwd: projectDir,
         detached: fullDetach,
         stdio: ['ignore', logFd, logFd],
-        env: process.env,
+        env: childEnv,
     });
     child.unref();
     fs.closeSync(logFd);