@cad0p/pi-usage 0.11.5 → 0.11.6

package/src/providers/antigravity.js

@@ -11,11 +11,11 @@
  * Response shape: `groups[].buckets[]` with
  * `{ bucketId, displayName, window, resetTime, remainingFraction, description }`.
  *
- * Google does not rotate this refresh token, but Pi owns the credential and this
- * project is read-only, so no refresh is performed here either.
+ * Google does not rotate this refresh token, so an expired access token may be
+ * renewed in memory. The renewed value is cached only for this process lifetime.
  */
 
-import { buildWindow, clampPercent, degradedResult, displayIdentity, finiteNumber, stringValue, windowFromName } from "../model.js";
+import { buildWindow, clampPercent, degradedResult, displayIdentity, finiteNumber, identityKind, stringValue, windowFromName } from "../model.js";
 import { requestJson } from "../http.js";
 import { describeOAuthClient, ensureFreshAccessToken } from "./antigravity-oauth.js";
 
@@ -109,6 +109,24 @@ function windowFromBucket(bucket, context, now) {
   });
 }
 
+/**
+ * The account line for a resolved project.
+ *
+ * Pi stores no e-mail for Antigravity, so the project id *is* the display
+ * identity; appending it again printed "project rising-f… · rising-f…". An
+ * account that has a better identity (an e-mail or an id) still gets the
+ * project, because the same login can hold several.
+ *
+ * @param {import("../auth/pi-auth.js").PiCredential} credential
+ * @param {string | null} projectId
+ * @returns {string}
+ */
+function accountLabel(credential, projectId) {
+  const identity = displayIdentity(credential);
+  if (!projectId || identityKind(credential) === "projectId") return identity;
+  return `${identity} · ${projectId.slice(0, 8)}…`;
+}
+
 /**
  * @param {import("../auth/pi-auth.js").PiCredential} credential
  * @param {{ now?: number, fetchFn?: typeof fetch, timeoutMs?: number, expiresInMin?: number | null, env?: Record<string, string | undefined>, refresh?: boolean }} [options]
@@ -139,7 +157,20 @@ export async function fetchQuota(credential, options = {}) {
     timeoutMs: options.timeoutMs,
     now,
     enabled: options.refresh,
+    env: options.env,
+    cacheKey: `${credential.source}\\u0000${credential.identity}`,
   });
+  // `expiresInMin` arrives from the engine as the freshness of the *stored*
+  // credential, and that is only the truth about this run when the refresh
+  // above did not happen: a token renewed in memory expires in an hour, so
+  // repeating the stored value made every surface print "token expired" (and
+  // the engine warn about it) next to healthy windows. A refresh that failed
+  // keeps the stored value — then the expiry claim is what the user must see.
+  const renewed = freshness.refreshed === true;
+  const expiresInMin = renewed ? null : options.expiresInMin ?? null;
+  // Present only when a renewal happened: an always-false field would be one
+  // more thing the JSON feed promises to keep.
+  const renewal = renewed ? { tokenRenewedInMemory: true } : {};
   let projectId = credential.projectId ?? null;
 
   /** @type {string | null} */
@@ -211,7 +242,9 @@ export async function fetchQuota(credential, options = {}) {
 
     return {
       ...base,
-      account: projectId ? `${displayIdentity(credential)} · ${projectId.slice(0, 8)}…` : displayIdentity(credential),
+      account: accountLabel(credential, projectId),
+      expiresInMin,
+      ...renewal,
       plan: stringValue(body.paidTier) ?? stringValue(body.currentTier),
       windows,
       error: null,
@@ -221,5 +254,11 @@ export async function fetchQuota(credential, options = {}) {
   }
 
   const suffix = authFailed ? ` (${describeOAuthClient({ env: options.env })})` : "";
-  return degradedResult({ ...base, error: `${lastError ?? "Antigravity quota unavailable"}${suffix}` });
+  return degradedResult({
+    ...base,
+    account: accountLabel(credential, projectId),
+    expiresInMin,
+    ...renewal,
+    error: `${lastError ?? "Antigravity quota unavailable"}${suffix}`,
+  });
 }

package/src/refresh.js

@@ -278,7 +278,10 @@ export async function collectWithCadence(options) {
     : null;
 
   const report = mergeReports([cachedPart, fresh], { families, now, reused });
-  writeCache(report, { path: cachePath, now });
+  // The cache carries the same per-family clocks this layer decided on, so a
+  // reader that only sees the cache (the CLI, the extension's first frame)
+  // judges each family by the time it was actually fetched.
+  writeCache(report, { path: cachePath, now, fetchedAtMs });
   writeRefreshState({ fetchedAtMs }, { statePath });
 
   /** @type {Record<string, number>} */