@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.21

package/dist/usage/providers.js

@@ -20,12 +20,12 @@
  */
 import { readFile, writeFile, access, constants } from "node:fs/promises";
 import { readFileSync, readdirSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { execFile } from "node:child_process";
 import { getAgendHome } from "../paths.js";
 import { loadFleetConfig } from "../config.js";
 import { classicProfile, profileName, readClassicBindings } from "../classic-bindings.js";
-import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileLoginCommand, credentialProfileStoreHome, instanceCredentialProfile, } from "../backend/credential-profile.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLoginCommand, credentialProfileStoreHome, instanceCredentialProfile, isCredentialProfileName, } from "../backend/credential-profile.js";
 import { claudeKeychainService } from "../backend/claude-code.js";
 import { readKiroAuthTokens } from "../backend/kiro-auth-store.js";
 import { homedir, userInfo } from "node:os";
@@ -364,6 +364,9 @@ export async function fetchClaudeUsage(storeHome, scope = {}) {
         // limits down. This is the case the whole statusline source exists for.
         if (statusline)
             return statuslineUsage(statusline, null);
+        // #2236: a profile on the host that no instance uses, signed out: not set up here — no row.
+        if (profileHome !== null && scope.hostOnly)
+            return { status: "no-credentials", hint: "Not logged in.", metrics: [] };
         if (profileHome !== null) {
             // On screen (`ok`, as kiro's signed-out row), with what signs this profile in — never a fallback: from chat
             // (`/login claude-code <profile>`, #1699 part 2), or the exact line on the host — the same words as the auth alert.
@@ -510,10 +513,31 @@ export async function fetchClaudeUsage(storeHome, scope = {}) {
 // the app), so embedding it is the accepted norm, not a leaked key. It is
 // required for the refresh-token grant.
 const AGY_TOKEN_FILE = ["antigravity-cli", "antigravity-oauth-token"];
+/**
+ * The daily base first, the production base as the fallback. Checked live 2026-10-20 (#2240, a user's Google AI Pro
+ * account, read-only) against agy's own /quota: only the daily base, asked as agy's CLI asks (agyUserAgent), answers with
+ * the plan's Gemini quota and the Gemini 4 Argon group — agy's numbers exactly. The production base answers with a
+ * free-tier Gemini bucket and no Argon whatever the client says.
+ */
 const AGY_CLOUDCODE_URLS = [
     "https://daily-cloudcode-pa.googleapis.com",
     "https://cloudcode-pa.googleapis.com",
 ];
+/**
+ * The agy CLI version AgEnD names itself as, in agy's own User-Agent (`antigravity/cli/<version> (aidev_client; …)`, as
+ * captured from agy 1.4.3's /quota, #2240, 2026-10-20). The daily base gates its summary on it: as `antigravity/cli/1.2.0`
+ * there was no Argon group, from 1.3.0 on there was; as `antigravity/cli/1.0.0` no Gemini group either; without the
+ * `cli/` segment (`antigravity/2.24.0`, OpenUsage's value) Gemini but never Argon. If Google raises the gate past it, a
+ * group disappears again and the row falls back to the busiest model's quota — a visible gap, never wrong numbers.
+ * Bump it here.
+ */
+export const AGY_CLIENT_VERSION = "1.4.3";
+/** agy's own User-Agent shape (`antigravity/cli/%s (aidev_client; os_type=…; arch=…)`), for this host. */
+export function agyUserAgent(platform = process.platform, arch = process.arch) {
+    const os = platform === "win32" ? "windows" : platform;
+    const cpu = arch === "x64" ? "amd64" : arch;
+    return `antigravity/cli/${AGY_CLIENT_VERSION} (aidev_client; os_type=${os}; arch=${cpu})`;
+}
 /**
  * The Google installed-app OAuth client pair, READ FROM THE INSTALLED agy
  * BINARY rather than committed here.
@@ -555,17 +579,48 @@ export function agyQuotaBuckets(body) {
     const grouped = (body.groups ?? []).flatMap(g => (g.buckets ?? []).map(b => ({ ...b, group: g.displayName?.trim() || undefined })));
     return grouped.length ? grouped : (body.buckets ?? []);
 }
+/**
+ * Each model's quota as a per-model bucket. Only models with a reset time count: agy's internal models (tab completion,
+ * `chat_…`) report a bare 1 with none, which is no limit anyone runs into.
+ */
+export function agyModelBuckets(body) {
+    return Object.entries(body.models ?? {}).flatMap(([id, m]) => m?.quotaInfo?.resetTime
+        ? [{ bucketId: id, remainingFraction: m.quotaInfo.remainingFraction, resetTime: m.quotaInfo.resetTime, provider: m.modelProvider }]
+        : []);
+}
+/**
+ * The buckets to show: the summary's, then — for each pool the summary does not name — the models' own quotas
+ * (#2174). agy 1.4 (2026-10-19, this machine's live account) answered the summary with only the "Claude and GPT
+ * models" group while every Gemini model still had a quota of its own, so the Gemini pool vanished from the row.
+ */
+export function agyUsageBuckets(summary, models) {
+    const fromSummary = agyQuotaBuckets(summary);
+    const named = new Set(fromSummary.map(b => { const id = agyBucketId(b); return id ? agyPool(b, id) : null; }));
+    return [...fromSummary, ...(models ? agyModelBuckets(models).filter(b => !named.has(agyPool(b, b.bucketId))) : [])];
+}
+function agyBucketId(b) {
+    return b.bucketId?.trim() || (b.group ? b.displayName?.trim() : undefined);
+}
 const AGY_POOLED = {
     "gemini-5h": { pool: "Gemini", window: "session" },
     "gemini-weekly": { pool: "Gemini", window: "weekly" },
     "3p-5h": { pool: "Claude & others", window: "session" },
     "3p-weekly": { pool: "Claude & others", window: "weekly" },
 };
-/** The pool a bucket belongs to: its group when the summary names one (#1898), else a guess from the bucket id. */
+/**
+ * The pool a bucket belongs to: its group when the summary names one (#1898), else its model's provider, else its id.
+ * One nobody recognises is a pool of its own under its own name — never folded into another, so a vendor rename shows
+ * up as a new row instead of hiding one (#2174).
+ */
 function agyPool(b, id) {
     const pooled = AGY_POOLED[id];
     if (pooled)
         return pooled.pool;
+    // #2240: Gemini 4 Argon has a quota of its own on paid Pro plans ("Argon quota is separate", as agy shows it): its own pool,
+    // from a summary group or from its models (gemini-4-argon-*), never folded into Gemini's worst-of by the rule below.
+    const argon = agyArgonPool(b.group) ?? agyArgonPool(id);
+    if (argon)
+        return argon;
     const group = b.group;
     if (group) {
         if (/gemini/i.test(group))
@@ -574,7 +629,27 @@ function agyPool(b, id) {
             return "Claude & others";
         return group;
     }
-    return id.startsWith("gemini") ? "Gemini" : "Claude & others";
+    const provider = b.provider?.replace(/^MODEL_PROVIDER_/, "");
+    if (provider) {
+        if (provider === "GOOGLE")
+            return "Gemini";
+        if (provider === "ANTHROPIC" || provider === "OPENAI")
+            return "Claude & others";
+        if (provider !== "UNSPECIFIED")
+            return provider.replace(/_/g, " ");
+    }
+    if (/^gemini/i.test(id))
+        return "Gemini";
+    if (/^(claude|gpt|3p)\b/i.test(id))
+        return "Claude & others";
+    return id;
+}
+/** "Gemini 4 Argon", "GEMINI 4 ARGON", "gemini-4-argon-high" → "Gemini 4 Argon"; any other Argon → "Argon"; else null. */
+function agyArgonPool(text) {
+    if (!text || !/argon/i.test(text))
+        return null;
+    const version = /gemini[\s_-]*(\d+(?:\.\d+)?)[\s_-]*argon/i.exec(text);
+    return version ? `Gemini ${version[1]} Argon` : "Argon";
 }
 /** The limit a bucket counts against ("Five Hour Limit", window "5h" …), or null for a per-model bucket. */
 function agyWindow(b, id) {
@@ -626,7 +701,7 @@ function agyLabel(pool, window) {
 export function agyPoolMetrics(buckets) {
     const entries = new Map();
     for (const b of buckets) {
-        const id = b.bucketId?.trim() || (b.group ? b.displayName?.trim() : undefined);
+        const id = agyBucketId(b);
         if (!id || b.disabled === true || typeof b.remainingFraction !== "number" || !Number.isFinite(b.remainingFraction))
             continue;
         const pool = agyPool(b, id);
@@ -737,7 +812,76 @@ async function agyAccessToken() {
         return { error: "Could not reach oauth2.googleapis.com.", errorI18n: i18n("usage.error.unreachable", "oauth2.googleapis.com") };
     }
 }
-async function fetchAntigravityUsage() {
+/**
+ * The models' own quotas (`fetchAvailableModels`, the list agy's model picker reads), from the same base as the
+ * summary. Only what the summary leaves out is taken from it, so a failure here costs nothing: null. Optional, so it
+ * never costs the row the summary already in hand (#2176 review, as the Codex ticket list, #1246): once the summary
+ * has answered it gets only what is left before the provider deadline, less a margin, and is then cancelled.
+ */
+const AGY_MODELS_DEADLINE_MARGIN_MS = 1_000;
+function agyModels(base, token) {
+    return agyOptionalRead(base, token, "fetchAvailableModels", "{}");
+}
+/**
+ * The plan's name for the row (Google AI Pro …): `loadCodeAssist`, asked as agy asks it (its client metadata), read
+ * like the models' quotas — alongside the summary, optional, cancelled at the deadline. The paid tier wins over the
+ * current one, as OpenUsage reads it: a Pro account's current tier is "free-tier" (named "Antigravity").
+ */
+const AGY_LOAD_CODE_ASSIST_BODY = JSON.stringify({ metadata: { ideType: "ANTIGRAVITY", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" } });
+function agyCodeAssist(base, token) {
+    return agyOptionalRead(base, token, "loadCodeAssist", AGY_LOAD_CODE_ASSIST_BODY);
+}
+/** The plan's name from loadCodeAssist: the paid tier's, else the current tier's (its name, else its id), else null; at most
+ *  AGY_PLAN_MAX characters (it is a badge on one line, and the text comes from the server). */
+export function agyPlan(body) {
+    for (const tier of [body?.paidTier, body?.currentTier]) {
+        for (const v of [tier?.name, tier?.id])
+            if (typeof v === "string" && v.trim())
+                return truncatePlan(v.trim());
+    }
+    return null;
+}
+const AGY_PLAN_MAX = 64;
+function truncatePlan(name) {
+    const chars = [...name];
+    return chars.length <= AGY_PLAN_MAX ? name : `${chars.slice(0, AGY_PLAN_MAX - 1).join("")}…`;
+}
+/** One optional Cloud Code read beside the summary: its body, or null on any failure; bounded by the caller's budget. */
+function agyOptionalRead(base, token, method, requestBody) {
+    const abort = new AbortController();
+    const result = (async () => {
+        const res = await fetch(`${base}/v1internal:${method}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", "User-Agent": agyUserAgent() },
+            body: requestBody,
+            signal: AbortSignal.any([abort.signal, AbortSignal.timeout(LONGEST_SINGLE_FETCH_MS)]),
+        });
+        if (!res.ok)
+            return null;
+        const body = await res.json();
+        return body && typeof body === "object" ? body : null;
+    })().catch(() => null);
+    return {
+        cancel: () => abort.abort(),
+        async within(budgetMs) {
+            // No time left: an answer already in hand still counts (it settles first), nothing is waited for.
+            if (!(budgetMs > 0))
+                return Promise.race([result, Promise.resolve(null)]);
+            let timer;
+            // The timer settles the race, so a fetch that ignores its signal cannot hold the row; the caller then cancels it.
+            const timedOut = new Promise(resolve => { timer = setTimeout(() => resolve(null), budgetMs); });
+            try {
+                return await Promise.race([result, timedOut]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}
+export async function fetchAntigravityUsage() {
+    // Monotonic: the deadline the models' budget is measured against is a timer, which a wall-clock change does not move.
+    const startedAt = performance.now();
     // A CLI-observed rate limit outranks anything the quota API says. The bucket
     // summary cannot see the account-level individual cap: verified live, it
     // reported every bucket 0% used in the same minute the CLI was refusing work
@@ -763,38 +907,51 @@ async function fetchAntigravityUsage() {
     if ("error" in auth)
         return { status: "error", error: auth.error, errorI18n: auth.errorI18n, metrics: [] };
     for (const base of AGY_CLOUDCODE_URLS) {
-        let res;
-        try {
-            res = await fetch(`${base}/v1internal:retrieveUserQuotaSummary`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${auth.token}`,
-                    "Content-Type": "application/json",
-                    "User-Agent": "antigravity",
-                },
-                body: "{}",
-                signal: AbortSignal.timeout(LONGEST_SINGLE_FETCH_MS),
-            });
-        }
-        catch {
-            continue;
-        }
-        if (res.status === 401 || res.status === 403) {
-            return { status: "error", error: "Token rejected. Run `agy` once to refresh the login.", errorI18n: i18n("usage.error.token_rejected", "agy"), metrics: [] };
-        }
-        if (!res.ok)
-            continue; // try the other base
-        let body;
+        // Alongside the summary, not after it: one more round trip in the chain would push a slow-but-healthy pair past
+        // the provider deadline. Cancelled when the summary fails (it never rejects).
+        const models = agyModels(base, auth.token);
+        const codeAssist = agyCodeAssist(base, auth.token);
         try {
-            body = await res.json();
+            let res;
+            try {
+                res = await fetch(`${base}/v1internal:retrieveUserQuotaSummary`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${auth.token}`,
+                        "Content-Type": "application/json",
+                        "User-Agent": agyUserAgent(),
+                    },
+                    body: "{}",
+                    signal: AbortSignal.timeout(LONGEST_SINGLE_FETCH_MS),
+                });
+            }
+            catch {
+                continue;
+            }
+            if (res.status === 401 || res.status === 403) {
+                return { status: "error", error: "Token rejected. Run `agy` once to refresh the login.", errorI18n: i18n("usage.error.token_rejected", "agy"), metrics: [] };
+            }
+            if (!res.ok)
+                continue; // try the other base
+            let body;
+            try {
+                body = await res.json();
+            }
+            catch {
+                continue;
+            }
+            const budgetMs = providerDeadlineMs - (performance.now() - startedAt) - AGY_MODELS_DEADLINE_MARGIN_MS;
+            const [modelList, assist] = await Promise.all([models.within(budgetMs), codeAssist.within(budgetMs)]);
+            const metrics = agyPoolMetrics(agyUsageBuckets(body ?? {}, modelList));
+            const plan = agyPlan(assist);
+            return metrics.length
+                ? { status: "ok", plan, metrics }
+                : { status: "ok", plan, hint: "No quota information reported for this account.", hintI18n: i18n("usage.hint.no_quota"), metrics: [] };
         }
-        catch {
-            continue;
+        finally {
+            models.cancel(); // a base given up on, or a read already settled: nothing left to wait for
+            codeAssist.cancel();
         }
-        const metrics = agyPoolMetrics(agyQuotaBuckets(body ?? {}));
-        return metrics.length
-            ? { status: "ok", plan: null, metrics }
-            : { status: "ok", plan: null, hint: "No quota information reported for this account.", hintI18n: i18n("usage.hint.no_quota"), metrics: [] };
     }
     return { status: "error", error: "Could not reach the Cloud Code quota endpoints.", errorI18n: i18n("usage.error.unreachable", "Cloud Code quota endpoints"), metrics: [] };
 }
@@ -1434,6 +1591,8 @@ export function providersForConfig(config, base = DEFAULT_PROVIDERS) {
         const backendName = usageBackendForProviderId(provider.id);
         if (!backendName || !credentialHomeSpec(backendName))
             return [provider];
+        if (provider.id === "claude")
+            return claudeHostRows(config, provider, backendName);
         const profiles = effectiveCredentialProfiles(config, backendName);
         if (profiles.length === 0)
             return [provider];
@@ -1451,6 +1610,7 @@ export function providersForConfig(config, base = DEFAULT_PROVIDERS) {
             rows.push({
                 id: provider.id,
                 name: provider.id === "codex" ? `${provider.name} (default)` : provider.name,
+                ...(provider.id === "codex" ? { defaultLogin: true } : {}),
                 // Claude's shared row keeps its statusline fallback to the shared instances (#1699); others ignore the scope.
                 fetch: () => provider.fetch(undefined, { besideProfiles: true }),
             });
@@ -1464,6 +1624,48 @@ export function providersForConfig(config, base = DEFAULT_PROVIDERS) {
         return rows;
     });
 }
+/**
+ * #2236: one row per Claude login ON THE HOST, used by an instance or not — the default (shared) login and every
+ * credential profile there. A subscription at its limit is exactly the one a person stops using; it must not vanish
+ * because nothing runs on it (a user's first account, full, had no row once every instance moved to new profiles).
+ * The shared row is "Claude (default)" beside profiles (shown whenever that login exists); a profile no instance uses
+ * shows only when signed in. isHostLoginUsageProvider keeps these rows through the snapshot's running-instances filter.
+ */
+function claudeHostRows(config, provider, backendName) {
+    const inUse = effectiveCredentialProfiles(config, backendName);
+    const profiles = [...new Set([...inUse, ...claudeProfilesOnHost()])].sort();
+    if (profiles.length === 0)
+        return [provider];
+    const homes = profiles.map(profile => credentialProfileStoreHome(getAgendHome(), backendName, profile));
+    return [
+        { id: provider.id, name: `${provider.name} (default)`, defaultLogin: true, fetch: () => provider.fetch(undefined, { besideProfiles: true }) },
+        ...profiles.map((profile, i) => ({
+            id: `${provider.id}:${profile}`,
+            name: `${provider.name} (${profile})`,
+            profile,
+            fetch: () => provider.fetch(homes[i], inUse.includes(profile) ? { profile } : { profile, hostOnly: true }),
+        })),
+    ];
+}
+/** What a row says about whose login it reads: its profile (#2014), or that it is the default login beside profiles. */
+function rowTags(p) {
+    return { ...(p.profile ? { profile: p.profile } : {}), ...(p.defaultLogin ? { defaultLogin: true } : {}) };
+}
+/** #2236: the Claude credential profiles on this host (their directories), whether or not an instance uses them. */
+function claudeProfilesOnHost() {
+    try {
+        return readdirSync(dirname(credentialProfileHome(getAgendHome(), "claude-code", "x")), { withFileTypes: true })
+            .filter(e => e.isDirectory() && isCredentialProfileName(e.name))
+            .map(e => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** #2236: a Claude login's row — kept on screen whether or not a running instance uses it. */
+export function isHostLoginUsageProvider(id) {
+    return id === "claude" || id.startsWith("claude:");
+}
 /**
  * Whether at least one effective fleet binding uses the legacy shared login.
  *
@@ -1645,16 +1847,16 @@ export async function fetchAllUsage(config) {
                 // Fail soft: this row says it could not be read, the rest still answer,
                 // and the snapshot returns in bounded time.
                 return {
-                    id: p.id, name: p.name, ...(p.profile ? { profile: p.profile } : {}), status: "error",
+                    id: p.id, name: p.name, ...rowTags(p), status: "error",
                     error: `Could not reach ${p.name}.`,
                     errorI18n: i18n("usage.error.unreachable", p.name),
                     metrics: [],
                 };
             }
-            return { id: p.id, name: p.name, ...(p.profile ? { profile: p.profile } : {}), ...outcome };
+            return { id: p.id, name: p.name, ...rowTags(p), ...outcome };
         }
         catch (err) {
-            return { id: p.id, name: p.name, ...(p.profile ? { profile: p.profile } : {}), status: "error", error: String(err?.message ?? err), metrics: [] };
+            return { id: p.id, name: p.name, ...rowTags(p), status: "error", error: String(err?.message ?? err), metrics: [] };
         }
     }));
     return {