opencode-gemini-auth 1.4.2 → 1.4.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [

package/src/plugin/retry/index.ts

@@ -57,11 +57,9 @@ export async function fetchWithRetry(
     }
 
     const delayMs = await resolveRetryDelayMs(response, attempt, quotaContext?.retryDelayMs);
-    if (delayMs <= 0) {
-      return response;
+    if (delayMs > 0) {
+      await wait(delayMs);
     }
-
-    await wait(delayMs);
     attempt += 1;
   }
 

package/src/plugin/retry.test.ts

@@ -95,6 +95,27 @@ describe("fetchWithRetry", () => {
     expect(response.status).toBe(429);
     expect(fetchMock.mock.calls.length).toBe(1);
   });
+
+  it("retries immediately when server returns Retry-After: 0", async () => {
+    const fetchMock = mock(async () => {
+      if (fetchMock.mock.calls.length === 1) {
+        return new Response("rate limited", {
+          status: 429,
+          headers: { "retry-after": "0" },
+        });
+      }
+      return new Response("ok", { status: 200 });
+    });
+    (globalThis as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch;
+
+    const response = await fetchWithRetry("https://example.com", {
+      method: "POST",
+      body: JSON.stringify({ hello: "world" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(fetchMock.mock.calls.length).toBe(2);
+  });
 });
 
 describe("retryInternals", () => {

package/src/plugin/token.test.ts

@@ -1,9 +1,11 @@
-import { beforeEach, describe, expect, it, mock } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 
 import { GEMINI_PROVIDER_ID } from "../constants";
 import { refreshAccessToken } from "./token";
 import type { OAuthAuthDetails, PluginClient } from "./types";
 
+const originalSetTimeout = globalThis.setTimeout;
+
 const baseAuth: OAuthAuthDetails = {
   type: "oauth",
   refresh: "refresh-token|project-123",
@@ -24,6 +26,14 @@ function createClient() {
 describe("refreshAccessToken", () => {
   beforeEach(() => {
     mock.restore();
+    (globalThis as { setTimeout: typeof setTimeout }).setTimeout = ((fn: (...args: any[]) => void) => {
+      fn();
+      return 0 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout;
+  });
+
+  afterEach(() => {
+    (globalThis as { setTimeout: typeof setTimeout }).setTimeout = originalSetTimeout;
   });
 
   it("updates the caller but skips persisting when refresh token is unchanged", async () => {
@@ -102,4 +112,50 @@ describe("refreshAccessToken", () => {
     expect(firstResult?.access).toBe("deduped-access");
     expect(secondResult?.access).toBe("deduped-access");
   });
+
+  it("retries transient network errors during token refresh", async () => {
+    const client = createClient();
+    const fetchMock = mock(async () => {
+      if (fetchMock.mock.calls.length === 1) {
+        const err = new Error("socket reset") as Error & { code?: string };
+        err.code = "ECONNRESET";
+        throw err;
+      }
+      return new Response(
+        JSON.stringify({
+          access_token: "recovered-access",
+          expires_in: 3600,
+        }),
+        { status: 200 },
+      );
+    });
+    (globalThis as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch;
+
+    const result = await refreshAccessToken(baseAuth, client);
+
+    expect(result?.access).toBe("recovered-access");
+    expect(fetchMock.mock.calls.length).toBe(2);
+  });
+
+  it("retries retryable HTTP errors from token endpoint", async () => {
+    const client = createClient();
+    const fetchMock = mock(async () => {
+      if (fetchMock.mock.calls.length === 1) {
+        return new Response("temporarily unavailable", { status: 503 });
+      }
+      return new Response(
+        JSON.stringify({
+          access_token: "recovered-after-503",
+          expires_in: 3600,
+        }),
+        { status: 200 },
+      );
+    });
+    (globalThis as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch;
+
+    const result = await refreshAccessToken(baseAuth, client);
+
+    expect(result?.access).toBe("recovered-after-503");
+    expect(fetchMock.mock.calls.length).toBe(2);
+  });
 });

package/src/plugin/token.ts

@@ -11,6 +11,14 @@ import {
   logGeminiDebugMessage,
 } from "./debug";
 import { invalidateProjectContextCache } from "./project";
+import {
+  DEFAULT_MAX_ATTEMPTS,
+  getExponentialDelayWithJitter,
+  isRetryableNetworkError,
+  isRetryableStatus,
+  resolveRetryDelayMs,
+  wait,
+} from "./retry/helpers";
 import type { OAuthAuthDetails, PluginClient, RefreshParts } from "./types";
 
 interface OAuthErrorPayload {
@@ -98,21 +106,7 @@ async function refreshAccessTokenInternal(
   parts: RefreshParts,
 ): Promise<OAuthAuthDetails | undefined> {
   try {
-    if (isGeminiDebugEnabled()) {
-      logGeminiDebugMessage("OAuth refresh: POST https://oauth2.googleapis.com/token");
-    }
-    const response = await fetch("https://oauth2.googleapis.com/token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: parts.refreshToken,
-        client_id: GEMINI_CLIENT_ID,
-        client_secret: GEMINI_CLIENT_SECRET,
-      }),
-    });
+    const response = await fetchTokenRefresh(parts.refreshToken);
 
     if (!response.ok) {
       let errorText: string | undefined;
@@ -209,3 +203,48 @@ async function refreshAccessTokenInternal(
     return undefined;
   }
 }
+
+async function fetchTokenRefresh(refreshToken: string): Promise<Response> {
+  const tokenUrl = "https://oauth2.googleapis.com/token";
+  const init: RequestInit = {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: GEMINI_CLIENT_ID,
+      client_secret: GEMINI_CLIENT_SECRET,
+    }),
+  };
+
+  let attempt = 1;
+  while (attempt <= DEFAULT_MAX_ATTEMPTS) {
+    if (isGeminiDebugEnabled()) {
+      logGeminiDebugMessage(`OAuth refresh attempt ${attempt}: POST ${tokenUrl}`);
+    }
+
+    try {
+      const response = await fetch(tokenUrl, init);
+      if (!isRetryableStatus(response.status) || attempt >= DEFAULT_MAX_ATTEMPTS) {
+        return response;
+      }
+
+      const delayMs = await resolveRetryDelayMs(response, attempt);
+      if (delayMs > 0) {
+        await wait(delayMs);
+      }
+      attempt += 1;
+      continue;
+    } catch (error) {
+      if (attempt >= DEFAULT_MAX_ATTEMPTS || !isRetryableNetworkError(error)) {
+        throw error;
+      }
+      await wait(getExponentialDelayWithJitter(attempt));
+      attempt += 1;
+    }
+  }
+
+  return fetch(tokenUrl, init);
+}