@prestyj/cli 5.3.1 → 5.4.1

package/dist/app-sidecar.js

@@ -29,7 +29,7 @@ import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-c
 import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
 import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, restoreUserRow, restoreAssistantTexts, autopilotMarkerCopySeed, } from "./core/session-history.js";
 import { AuthStorage } from "./core/auth-storage.js";
-import { MOONSHOT_OAUTH_KEY, XIAOMI_CREDITS_KEY } from "@prestyj/core";
+import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, } from "@prestyj/core";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
 import { loginOpenAI } from "./core/oauth/openai.js";
 import { loginGemini } from "./core/oauth/gemini.js";
@@ -509,6 +509,70 @@ async function main() {
         for (const ctx of sessions.values())
             ctx.broadcast("progress", { ...snapshot, origin: ctx.id === originId });
     });
+    const usageCache = new Map();
+    const usageRequests = new Map();
+    async function fetchUsageProvider(provider) {
+        const displayName = provider === "anthropic" ? "Anthropic" : "Codex";
+        if (!(await auth.hasProviderAuth(provider))) {
+            return { provider, displayName, connected: false, windows: [], fetchedAt: Date.now() };
+        }
+        try {
+            let credentials = await auth.resolveCredentials(provider);
+            try {
+                return { ...(await fetchSubscriptionUsage(provider, credentials)), connected: true };
+            }
+            catch (error) {
+                // A provider can revoke an access token before its stored expiry. Refresh
+                // once on 401, matching inference auth recovery, then retry the usage call.
+                if (error instanceof SubscriptionUsageError && error.status === 401) {
+                    credentials = await auth.resolveCredentials(provider, { forceRefresh: true });
+                    return { ...(await fetchSubscriptionUsage(provider, credentials)), connected: true };
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log("WARN", "app-sidecar", "subscription usage fetch failed", { provider, message });
+            const connected = await auth.hasProviderAuth(provider);
+            return {
+                provider,
+                displayName,
+                connected,
+                windows: [],
+                fetchedAt: Date.now(),
+                error: connected ? "Usage is temporarily unavailable." : undefined,
+            };
+        }
+    }
+    async function subscriptionUsage(provider) {
+        const cached = usageCache.get(provider);
+        if (cached && cached.expiresAt > Date.now())
+            return cached.result;
+        const inFlight = usageRequests.get(provider);
+        if (inFlight)
+            return inFlight;
+        const request = fetchUsageProvider(provider);
+        usageRequests.set(provider, request);
+        try {
+            const result = await request;
+            // Anthropic can return utilization before it assigns reset timestamps
+            // (notably before the account's first active request). Retry that partial
+            // snapshot quickly; complete snapshots keep the normal one-minute cache.
+            const missingReset = result.connected &&
+                result.windows.length > 0 &&
+                result.windows.some((window) => window.resetsAt === undefined);
+            usageCache.set(provider, {
+                result,
+                expiresAt: Date.now() + (missingReset ? 10_000 : 60_000),
+            });
+            return result;
+        }
+        finally {
+            if (usageRequests.get(provider) === request)
+                usageRequests.delete(provider);
+        }
+    }
     /** Resolve the target session id: the `x-gg-session` header, else a
      *  `?session=` query param (used by the SSE /events connection). */
     function sessionIdFromReq(req, url) {
@@ -583,6 +647,25 @@ async function main() {
             daemonJson(res, 200, progress.snapshot());
             return;
         }
+        // Subscription quota is account-wide, not project/session-specific. OAuth
+        // tokens stay in this daemon; only the active provider's normalized snapshot
+        // reaches the webview.
+        if (method === "GET" && (url === "/usage" || url.startsWith("/usage?"))) {
+            void (async () => {
+                const provider = new URL(url, `http://${host}`).searchParams.get("provider");
+                if (provider !== "anthropic" && provider !== "openai") {
+                    daemonJson(res, 400, { error: "unsupported usage provider" });
+                    return;
+                }
+                daemonJson(res, 200, await subscriptionUsage(provider));
+            })().catch((error) => {
+                log("ERROR", "app-sidecar", "subscription usage request failed", {
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                daemonJson(res, 500, { error: "Usage is temporarily unavailable." });
+            });
+            return;
+        }
         // ── Per-session delegation ───────────────────────────────────────────
         const id = sessionIdFromReq(req, url);
         const ctx = id ? sessions.get(id) : undefined;
@@ -788,6 +871,32 @@ async function createSession(deps, opts) {
         for (const c of clients)
             c.res.write(frame);
     }
+    // Replace CLI-specific guidance (slash commands, CLI tool names) with
+    // desktop-app equivalents so the webview never shows "run ezcoder login".
+    // Applied to BOTH the message and guidance fields — the auth "Not logged in…
+    // Run "ezcoder login"" string lives in `message`, not `guidance`.
+    function desktopGuidance(guidance) {
+        return (guidance
+            // Auth: `Run "ezcoder login"` / `Run 'ezcoder login'` / `Run `ezcoder login``
+            // (any quote style, or none) → button. Do this first so the whole phrase
+            // is rewritten cleanly instead of leaving a dangling `Run "…"`.
+            .replaceAll(/Run ["'`]?ezcoder login["'`]?/gi, "Use the Login to AI Providers button")
+            // Any remaining bare mention.
+            .replaceAll(/ezcoder login/gi, "the Login to AI Providers button")
+            // /compact: the app has NO manual compact command or button — it only
+            // auto-compacts (and now auto-recovers on overflow). If this guidance is
+            // reached, auto-compaction already couldn't reduce enough, so the only
+            // real affordance is a fresh session. Don't tell the user to run a
+            // command that doesn't exist in the app.
+            .replaceAll(/Run \/compact to shrink history, or start a new session\./gi, "Start a new session to reset the context.")
+            // /model: handle each phrasing pattern
+            .replaceAll(/switch to claude-fable-5 with \/model/gi, "switch to claude-fable-5 using the model selector")
+            .replaceAll(/Switch with \/model\./gi, "Switch using the model selector.")
+            .replaceAll(/try a different model with \/model\./gi, "try a different model using the model selector.")
+            .replaceAll(/Use \/model to switch/gi, "Use the model selector to switch")
+            // /help
+            .replaceAll(/see \/help/gi, "check the help menu"));
+    }
     // Turn any thrown value into the same clear headline/message/guidance shape
     // the TUI shows (see gg-ai's formatError) instead of a bare `err.message`, log
     // the full detail, and broadcast it under `type` ("error" or "nolan_error").
@@ -796,18 +905,20 @@ async function createSession(deps, opts) {
     // context that the CLI has always given.
     function broadcastError(type, logLabel, err) {
         const f = formatError(err);
+        const message = f.message ? desktopGuidance(f.message) : undefined;
+        const guidance = desktopGuidance(f.guidance);
         log("ERROR", "app-sidecar", logLabel, {
             headline: f.headline,
             source: f.source,
-            ...(f.message ? { message: f.message } : {}),
+            ...(message ? { message } : {}),
             ...(f.provider ? { provider: f.provider } : {}),
             ...(f.statusCode != null ? { statusCode: String(f.statusCode) } : {}),
             ...(f.requestId ? { requestId: f.requestId } : {}),
         });
         broadcast(type, {
             headline: f.headline,
-            ...(f.message ? { message: f.message } : {}),
-            guidance: f.guidance,
+            ...(message ? { message } : {}),
+            guidance,
             ...(f.provider ? { provider: f.provider } : {}),
             ...(f.statusCode != null ? { statusCode: f.statusCode } : {}),
             ...(f.resetsAt != null ? { resetsAt: f.resetsAt } : {}),
@@ -818,8 +929,8 @@ async function createSession(deps, opts) {
             .persistAppMarker("error", {
             scope: type,
             headline: f.headline,
-            ...(f.message ? { message: f.message } : {}),
-            guidance: f.guidance,
+            ...(message ? { message } : {}),
+            guidance,
         })
             .catch(() => { });
     }