@scrylog/cli 0.1.4 → 0.3.0

package/src/usage/providers/opencode-go.ts

@@ -3,35 +3,113 @@ import type { OpenCodeGoUsageSnapshot } from "../types";
 import type { UsageProviderEntry } from "../types";
 import { OpenCodeGoUsageClient } from "../clients/opencode-go-usage";
 import { mapOpenCodeGoToEntry } from "../mappers";
+import { classifyUsageError, isRecoverableAuthenticationError } from "../errors";
+import { usageWebSessionCache, type WebSessionCache } from "../web-session-cache";
+import { OpenCodeGoApiKeyUsageClient } from "../clients/opencode-go-api";
+import { OpenCodeGoLocalUsageReader, type OpenCodeGoLocalUsageFetcher } from "../local/opencode-go-local";
+import type { OpenCodeGoWebCredentials } from "../resolvers/opencode-go-web";
 
-export class OpenCodeGoUsageProvider {
-  private readonly client = new OpenCodeGoUsageClient();
+export interface OpenCodeGoApiKeyUsageClientLike {
+  fetch(): Promise<OpenCodeGoUsageSnapshot | null>;
+}
 
+const CACHE_KEY = "opencode-go";
+
+export class OpenCodeGoUsageProvider {
   constructor(
-    private readonly resolver: TokenResolver<{ cookies: string }>,
+    private readonly resolver: TokenResolver<OpenCodeGoWebCredentials>,
     private readonly serverFnId: string,
+    private readonly client = new OpenCodeGoUsageClient(),
+    private readonly cache: WebSessionCache = usageWebSessionCache,
+    private readonly localReader: OpenCodeGoLocalUsageFetcher = new OpenCodeGoLocalUsageReader(),
+    private readonly apiKeyClient: OpenCodeGoApiKeyUsageClientLike = new OpenCodeGoApiKeyUsageClient(),
   ) {}
 
   async fetch(options?: { signal?: AbortSignal }): Promise<{ entry: UsageProviderEntry; snapshot: OpenCodeGoUsageSnapshot | null }> {
-    const errors: string[] = [];
-    const available = await this.resolver.isAvailable();
-    if (!available) {
-      return { entry: mapOpenCodeGoToEntry(null, [], false), snapshot: null };
+    // Official Go usage API is authoritative and independent of browser cookies.
+    try {
+      const apiSnapshot = await this.apiKeyClient.fetch();
+      if (apiSnapshot) {
+        return { entry: mapOpenCodeGoToEntry(apiSnapshot, [], true), snapshot: apiSnapshot };
+      }
+    } catch {
+      // Fall through to cookie-based collection.
     }
+    return this.fetchWithCookies(options);
+  }
 
+  private async fetchWithCookies(options?: { signal?: AbortSignal }): Promise<{ entry: UsageProviderEntry; snapshot: OpenCodeGoUsageSnapshot | null }> {
+    const errors: string[] = [];
     const creds = await this.resolver.resolve();
-    if (!creds) {
-      // Should not happen if isAvailable() is correct
+    const observed = this.cache.observe(CACHE_KEY);
+    if (!observed.value && !creds?.candidates.length) {
       return { entry: mapOpenCodeGoToEntry(null, [], false), snapshot: null };
     }
 
-    try {
-      const snapshot = await this.client.fetch({ cookies: creds.cookies, serverFnId: this.serverFnId }, options);
-      return { entry: mapOpenCodeGoToEntry(snapshot, errors, true), snapshot };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      errors.push(`OpenCode Go: ${message}`);
-      return { entry: mapOpenCodeGoToEntry(null, errors, true), snapshot: null };
+    const attempts = [
+      ...(observed.value ? [{ cookies: observed.value, cached: true }] : []),
+      ...(creds?.candidates ?? [])
+        .filter((candidate) => candidate.cookies !== observed.value)
+        .map((candidate) => ({ cookies: candidate.cookies, cached: false })),
+    ].slice(0, 2);
+    let expectedRevision = observed.revision;
+
+    for (let index = 0; index < attempts.length; index++) {
+      const attempt = attempts[index]!;
+      let rotated = false;
+      try {
+        const snapshot = await this.client.fetch(
+          {
+            cookies: attempt.cookies,
+            serverFnId: this.serverFnId,
+            onCookieRotation: (cookies) => {
+              rotated = true;
+              const stored = this.cache.store(CACHE_KEY, cookies, expectedRevision);
+              if (stored) expectedRevision = stored.revision;
+            },
+          },
+          options,
+        );
+        if (!attempt.cached && !rotated && this.cache.observe(CACHE_KEY).revision === expectedRevision) {
+          const stored = this.cache.store(CACHE_KEY, attempt.cookies, expectedRevision);
+          if (stored) expectedRevision = stored.revision;
+        }
+        return { entry: mapOpenCodeGoToEntry(snapshot, [], true), snapshot };
+      } catch (error) {
+        const failure = classifyUsageError(error);
+        if (failure.kind === "cancelled") throw failure;
+        if (failure.kind === "invalid-credentials") {
+          if (this.cache.clear(CACHE_KEY, expectedRevision)) expectedRevision = 0;
+          // Advance the demand-driven cursor at most once per attempt, keeping
+          // the two-candidate bound across cached and imported candidates.
+          const imported = attempts.length < 2 ? (await creds?.importNext?.()) ?? null : null;
+          if (imported && !attempts.some((candidate) => candidate.cookies === imported.cookies)) {
+            attempts.push({ cookies: imported.cookies, cached: false });
+            continue;
+          }
+        }
+        if (!(isRecoverableAuthenticationError(failure) && index + 1 < attempts.length)) {
+          errors.push(`OpenCode Go: ${failure.message}`);
+          return this.fetchLocalFallback(errors);
+        }
+      }
+    }
+
+    return this.fetchLocalFallback(errors);
+  }
+
+  /**
+   * Last resort after every web attempt fails: report locally accumulated
+   * opencode-go costs as estimated windows instead of an error. Mirrors the
+   * CodexBar "local" source so a stale browser session stays usable.
+   */
+  private async fetchLocalFallback(errors: string[]): Promise<{ entry: UsageProviderEntry; snapshot: OpenCodeGoUsageSnapshot | null }> {
+    const local = await this.localReader.fetch();
+    if (local) {
+      // Keeping errors here would force status "error" in the mapper; the local
+      // snapshot is reported as a usable estimate instead.
+      return { entry: mapOpenCodeGoToEntry(local, [], true), snapshot: local };
     }
+    return { entry: mapOpenCodeGoToEntry(null, errors, true), snapshot: null };
   }
 }