@cortexkit/opencode-antigravity-auth 3.0.1 → 3.0.2

package/dist/server.js

@@ -28984,7 +28984,7 @@ function createStoreAccountLimits(input2) {
 }
 
 // src/sidebar-state.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname15, join as join13 } from "node:path";
 
@@ -29008,7 +29008,7 @@ if (xdgConfig) {
 }
 
 // src/sidebar-state.ts
-var SIDEBAR_STATE_VERSION = 1;
+var SIDEBAR_STATE_VERSION = 2;
 var DEFAULT_SIDEBAR_STATE = {
   version: SIDEBAR_STATE_VERSION,
   checkedAt: 0,
@@ -29069,7 +29069,7 @@ function normalizeSidebarState(input2) {
   }
   const record2 = input2;
   const version = record2.version;
-  if (version !== SIDEBAR_STATE_VERSION) {
+  if (version !== 1 && version !== SIDEBAR_STATE_VERSION) {
     return {
       ...DEFAULT_SIDEBAR_STATE,
       lastError: `unsupported-version:${stringifySafe(version)}`
@@ -29124,6 +29124,7 @@ function normalizeAccount(input2) {
   return {
     id,
     label,
+    ...typeof record2.email === "string" ? { email: record2.email } : {},
     enabled,
     health,
     current,
@@ -29145,6 +29146,7 @@ function normalizeQuota(input2) {
   if (!isObject(input2)) return null;
   const record2 = input2;
   const remaining = toFiniteNumber(record2.remainingPercent);
+  const fraction = toFiniteNumber(record2.remainingFraction);
   if (remaining === null) return null;
   const resetAt = toFiniteNumber(record2.resetAt) ?? void 0;
   const checkedAt = toFiniteNumber(record2.checkedAt) ?? void 0;
@@ -29158,10 +29160,12 @@ function normalizeQuota(input2) {
       );
       const ra = toFiniteNumber(w.resetAt);
       const ca = toFiniteNumber(w.checkedAt);
+      const rf = toFiniteNumber(w.remainingFraction);
       if (win !== "weekly" && win !== "5h" || rp === null) return null;
       return {
         window: win,
         remainingPercent: clampNumber(rp, 0, 100),
+        ...rf !== null ? { remainingFraction: clampNumber(rf, 0, 1) } : {},
         resetAt: ra ?? void 0,
         ...ca !== null && ca >= 0 ? { checkedAt: ca } : {}
       };
@@ -29170,6 +29174,7 @@ function normalizeQuota(input2) {
   }
   return {
     remainingPercent: clampNumber(remaining, 0, 100),
+    ...fraction !== null ? { remainingFraction: clampNumber(fraction, 0, 1) } : {},
     resetAt,
     ...checkedAt !== void 0 ? { checkedAt } : {},
     windows
@@ -29221,6 +29226,7 @@ function stringifySafe(value) {
 }
 function ensureSidebarStateDir(path5 = getSidebarStateFile()) {
   mkdirSync3(dirname15(path5), { recursive: true, mode: SIDEBAR_STATE_DIR_MODE });
+  chmodSync3(dirname15(path5), SIDEBAR_STATE_DIR_MODE);
 }
 function pruneActiveRouting(map, now) {
   const cutoff = now - ACTIVE_ROUTING_MAX_AGE_MS;
@@ -29299,6 +29305,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
       0,
       100
     ),
+    remainingFraction: clampNumber(w.remainingFraction, 0, 1),
     resetAt: typeof w.resetTime === "string" && w.resetTime.length > 0 ? (() => {
       const parsed = Date.parse(w.resetTime);
       return Number.isFinite(parsed) ? parsed : void 0;
@@ -29306,6 +29313,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
   })) : void 0;
   return {
     remainingPercent,
+    remainingFraction: clampNumber(fraction, 0, 1),
     resetAt,
     windows,
     ...readingAt !== void 0 ? { checkedAt: readingAt } : {}
@@ -29342,6 +29350,7 @@ function redactAccountForSidebar(source) {
   return {
     id,
     label,
+    ...typeof source.email === "string" ? { email: source.email } : {},
     enabled,
     health,
     current,
@@ -29664,6 +29673,7 @@ async function pushSidebarQuotaSnapshot(getAccounts, backoffUntil = 0, getActive
         accounts.map((entry) => ({
           index: entry.index,
           label: entry.label,
+          email: entry.email,
           enabled: entry.enabled,
           current: activeByFamily ? isAccountCurrent(entry.index, activeByFamily) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -31095,7 +31105,7 @@ function clearSignatureCache(sessionId) {
 }
 
 // src/plugin/image-saver.ts
-import { chmodSync as chmodSync3, existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join15 } from "node:path";
 function getImageOutputDir(outputDir) {
@@ -31103,7 +31113,7 @@ function getImageOutputDir(outputDir) {
   if (!existsSync9(resolved)) {
     mkdirSync5(resolved, { recursive: true, mode: 448 });
   }
-  chmodSync3(resolved, 448);
+  chmodSync4(resolved, 448);
   return resolved;
 }
 function generateImageFilename(mimeType) {
@@ -31124,7 +31134,7 @@ function saveImageToDisk(base64Data, mimeType, outputDir) {
     const resolvedOutputDir = getImageOutputDir(outputDir);
     const filePath = join15(resolvedOutputDir, generateImageFilename(mimeType));
     writeFileSync3(filePath, Buffer.from(base64Data, "base64"), { mode: 384 });
-    chmodSync3(filePath, 384);
+    chmodSync4(filePath, 384);
     return filePath;
   } catch (error) {
     console.error("[image-saver] Failed to save image:", error);
@@ -43858,10 +43868,32 @@ function createGaRpcActivation(options) {
       accountsStatus: { kind: "complete" },
       accounts: accounts.rows.map(({ selector, row }) => ({
         selector,
-        ...redactAccountForSidebar(row)
+        ...gaAccountFields(redactAccountForSidebar(row))
       }))
     };
   };
+  const gaAccountFields = (account) => {
+    const { email: _email, quota, ...rest } = account;
+    const entry = (value) => {
+      if (value === void 0) return void 0;
+      const { remainingFraction: _fraction, windows, ...fields } = value;
+      return windows === void 0 ? fields : {
+        ...fields,
+        windows: windows.map(
+          ({ remainingFraction: _windowFraction, ...window }) => window
+        )
+      };
+    };
+    const gemini = entry(quota.gemini);
+    const nonGemini = entry(quota["non-gemini"]);
+    return {
+      ...rest,
+      quota: {
+        ...gemini ? { gemini } : {},
+        ...nonGemini ? { "non-gemini": nonGemini } : {}
+      }
+    };
+  };
   const state = async (input2, signal) => {
     const parsed = AntigravityStateInputSchema.parse(input2);
     if (!parsed.ok) throw new GaRpcInputError(parsed.issues);
@@ -49045,6 +49077,7 @@ function createAuthLoader({
             return {
               index: entry.index,
               label: entry.label,
+              email: entry.email,
               enabled: entry.enabled,
               current: isAccountCurrent(entry.index, activeByFamily),
               coolingDownUntil: entry.coolingDownUntil,
@@ -49298,6 +49331,185 @@ function createAuthLoader({
   return authLoader;
 }
 
+// src/plugin/vault-quota-refresh.ts
+async function checkAndPublishVaultQuota(input2, publishSidebar) {
+  const report = await checkVaultQuota(input2);
+  if (report.checked > 0 && !input2.signal.aborted) await publishSidebar();
+  return report;
+}
+
+// src/plugin/vault-sidebar-projection.ts
+function quotaReadingForVaultRoute(route, state) {
+  const stored = state.accounts[route.accountIdentity];
+  return stored?.observed.routeId === route.routeId && stored.observed.credentialId === route.credentialId ? stored.quota : void 0;
+}
+function buildVaultSidebarProjection(pool, state, checkedAt = Date.now()) {
+  const projection = buildSidebarMachineStateFromAccounts(
+    pool.selector.rows.map((row) => {
+      const quota = quotaReadingForVaultRoute(row.route, state);
+      return {
+        index: row.index,
+        email: row.route.email,
+        enabled: row.enabled,
+        current: false,
+        coolingDownUntil: row.coolingDownUntil,
+        healthScore: pool.selector.healthTracker.getScore(row.index),
+        cachedQuota: quota ? cachedQuotaOf(quota) : void 0,
+        cachedQuotaUpdatedAt: quota?.cachedQuotaUpdatedAt ?? void 0
+      };
+    }),
+    { checkedAt }
+  );
+  return {
+    ...projection,
+    accounts: projection.accounts.map((account) => ({
+      ...account,
+      id: `vault-${account.id}`
+    }))
+  };
+}
+
+// src/plugin/background-vault-quota-refresh.ts
+var BackgroundVaultQuotaRefresh = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.random = options.random ?? Math.random;
+    this.acquireLock = options.acquireLock ?? acquireFencedFileLock;
+  }
+  options;
+  timer = null;
+  inFlight = null;
+  controller = null;
+  disposed = false;
+  started = false;
+  now;
+  random;
+  acquireLock;
+  start() {
+    if (this.disposed || this.started) return;
+    this.started = true;
+    this.schedule(Math.floor(this.random() * 3e4));
+  }
+  /** Custody notifications cancel admitted work as soon as authority changes. */
+  abortTick() {
+    this.controller?.abort();
+  }
+  async dispose() {
+    this.disposed = true;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.abortTick();
+    await this.inFlight;
+  }
+  schedule(delay) {
+    if (this.disposed || !this.started) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.tick();
+    }, delay);
+    this.timer.unref?.();
+  }
+  /** One serialized tick; also used by deterministic composition tests. */
+  tick() {
+    if (this.disposed) return Promise.resolve();
+    if (this.inFlight) return this.inFlight;
+    const controller = new AbortController();
+    this.controller = controller;
+    let extraJitter = 0;
+    this.inFlight = this.runTick(controller).catch(() => {
+      extraJitter = 15e3;
+    }).finally(() => {
+      this.inFlight = null;
+      this.controller = null;
+      this.schedule(
+        this.options.intervalMs + Math.floor(this.random() * this.options.intervalMs * 0.1) + extraJitter
+      );
+    });
+    return this.inFlight;
+  }
+  async assertActive(controller) {
+    if (this.disposed || await this.options.readAuthority() !== "vault")
+      controller.abort();
+    controller.signal.throwIfAborted();
+  }
+  async runTick(controller) {
+    await this.assertActive(controller);
+    ensureSidebarStateDir(this.options.sidebarStateFile);
+    const lock = await this.acquireLock({
+      path: this.options.sidebarStateFile,
+      name: "bg-vault-quota-poll",
+      ttlMs: 6e4,
+      renew: true
+    });
+    if (!lock) return;
+    let released = false;
+    void lock.whenLost().then(() => {
+      if (!released) controller.abort();
+    });
+    try {
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const { source, pool } = await this.options.currentVaultPool();
+      await this.assertActive(controller);
+      await pool.sync();
+      await this.assertActive(controller);
+      const state = await this.options.readProviderState();
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const threshold = Math.max(
+        this.options.intervalMs - 6e4,
+        Math.floor(this.options.intervalMs / 2)
+      );
+      const now = this.now();
+      const due = pool.selector.rows.some((row) => {
+        const quota = quotaReadingForVaultRoute(row.route, state);
+        const at = quota?.cachedQuotaUpdatedAt;
+        return quota?.cachedQuota == null || typeof at !== "number" || !Number.isFinite(at) || at < 0 || now - at >= threshold;
+      });
+      if (!due) return;
+      await checkAndPublishVaultQuota(
+        {
+          pool,
+          signal: controller.signal,
+          now: this.now,
+          fetchReading: async (ref, signal) => {
+            await this.assertActive(controller);
+            const reading = await fetchVaultAccountQuota({
+              source,
+              ref,
+              signal,
+              logger: this.options.logger,
+              transport: async (url, init, extra) => {
+                await this.assertActive(controller);
+                await lock.assertOwned();
+                controller.signal.throwIfAborted();
+                return this.options.transport(
+                  url,
+                  { ...init, signal: extra.signal ?? controller.signal },
+                  extra
+                );
+              }
+            });
+            await this.assertActive(controller);
+            await lock.assertOwned();
+            return reading;
+          }
+        },
+        async () => {
+          await this.assertActive(controller);
+          await lock.assertOwned();
+          await this.options.publishSidebar();
+        }
+      );
+    } finally {
+      released = true;
+      await lock.release().catch(() => {
+      });
+    }
+  }
+};
+
 // src/plugin/prompt-context.ts
 function isRecord15(value) {
   return typeof value === "object" && value !== null;
@@ -50568,6 +50780,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       await drainSidebarWrites();
     }
   });
+  let vaultQuotaPoller;
   const vaultCustody = createOpenCodeVaultCustody({
     accountFile: resolve11(getStoragePath()),
     readHostSlot: async () => {
@@ -50578,7 +50791,10 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     // The request executor reports failed bearer authorization to Claustrum,
     // which decides whether its served credential needs replacement.
     reporterSource: "direct",
-    onAuthorityChanged: () => scheduleSidebarPublication(),
+    onAuthorityChanged: (authority) => {
+      if (authority !== "vault") vaultQuotaPoller?.abortTick();
+      scheduleSidebarPublication();
+    },
     onRosterChanged: () => scheduleSidebarPublication()
   });
   let vaultPool;
@@ -50625,6 +50841,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return manager.getAccounts().map((entry) => ({
         index: entry.index,
         label: entry.label,
+        email: entry.email,
         enabled: entry.enabled,
         current: isAccountCurrent(entry.index, activeByFamily),
         coolingDownUntil: entry.coolingDownUntil,
@@ -50652,6 +50869,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return buildSidebarMachineStateFromAccounts(
         manager?.getAccounts().map((entry) => ({
           index: entry.index,
+          email: entry.email,
           enabled: entry.enabled,
           current: active2 ? isAccountCurrent(entry.index, active2) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -50669,23 +50887,13 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     vault: async () => {
       const { pool } = await currentVaultPool();
       await pool.sync();
-      const projection = buildSidebarMachineStateFromAccounts(
-        pool.selector.rows.map((entry) => ({
-          index: entry.index,
-          enabled: entry.enabled,
-          current: false,
-          coolingDownUntil: entry.coolingDownUntil,
-          healthScore: pool.selector.healthTracker.getScore(entry.index),
-          cachedQuota: entry.cachedQuota,
-          cachedQuotaUpdatedAt: entry.cachedQuotaUpdatedAt
-        }))
+      const projection = buildVaultSidebarProjection(
+        pool,
+        await vaultCustody.readState(),
+        dependencies.clock.now()
       );
       return {
         ...projection,
-        accounts: projection.accounts.map((account) => ({
-          ...account,
-          id: `vault-${account.id}`
-        })),
         ...projection.accounts.length === 0 ? { lastError: VAULT_ACCOUNT_REMEDY } : {}
       };
     },
@@ -50764,6 +50972,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     options._onPollerCreated?.(poller);
     poller.start();
     lifecycle.register({ dispose: () => poller.dispose() }, "producer");
+    vaultQuotaPoller = new BackgroundVaultQuotaRefresh({
+      intervalMs: config.background_quota_refresh_interval_minutes * 6e4,
+      sidebarStateFile: getSidebarStateFile(),
+      readAuthority: readAuthority2,
+      currentVaultPool,
+      readProviderState: () => vaultCustody.readState(),
+      publishSidebar: () => sidebarPublisher.publish(),
+      transport: dependencies.fetchImpl,
+      logger,
+      now: dependencies.clock.now,
+      random: dependencies.clock.random
+    });
+    options._onVaultPollerCreated?.(vaultQuotaPoller);
+    vaultQuotaPoller.start();
+    lifecycle.register(vaultQuotaPoller, "producer");
   }
   const operatorSettings = createOperatorSettingsController({
     projectConfigPath: join29(directory, ".opencode", "antigravity.json"),
@@ -50887,17 +51110,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
                 vaultSelectors2.set(key, selector);
                 return selector;
               },
-              (signal) => checkVaultQuota({
-                pool,
-                signal,
-                fetchReading: (ref, check) => fetchVaultAccountQuota({
-                  source,
-                  ref,
-                  signal: check,
-                  logger,
-                  transport: dependencies.fetchImpl
-                })
-              })
+              (signal) => checkAndPublishVaultQuota(
+                {
+                  pool,
+                  signal,
+                  now: dependencies.clock.now,
+                  fetchReading: (ref, check) => fetchVaultAccountQuota({
+                    source,
+                    ref,
+                    signal: check,
+                    logger,
+                    transport: dependencies.fetchImpl
+                  })
+                },
+                () => sidebarPublisher.publish()
+              )
             )
           })
         };
@@ -51145,10 +51372,8 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     apply: async (request) => {
       const current = await currentMenu();
       if (current.kind === "unavailable") throw new Error(current.message);
-      const result = await current.menu.apply(
-        request,
-        menuInvocation(pushNotification, request.sessionId)
-      );
+      const invocation = menuInvocation(pushNotification, request.sessionId);
+      const result = await current.menu.apply(request, invocation);
       try {
         if (await readAuthority2() === "local")
           await lifecycle.getAccountManager()?.refreshFromRepository();
@@ -51165,6 +51390,11 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
           request.sessionId
         );
       }
+      const refreshed = await currentMenu();
+      if (refreshed.kind === "menu" && refreshed.menu !== current.menu) {
+        const payload = await refreshed.menu.open(invocation);
+        return { ...result, menu: payload.menu };
+      }
       return result;
     },
     drain: drainNotifications