@anthonyhaussman/opencode-agy-auth 1.2.3-alpha.7 → 1.2.3-alpha.9

package/dist/index.js

@@ -20694,7 +20694,7 @@ function defineOpenCodeV2Plugin(def) {
 // src/plugin/v2.ts
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import "http";
 var AGY_V2_QUOTA_COMMAND = "agy-quota";
 var AGY_V2_QUOTA_SUMMARY_COMMAND = "agy-quota-summary";
@@ -20811,6 +20811,34 @@ function loadStoredAuthFromJson() {
   }
   return void 0;
 }
+function saveStoredAuthToJson(authRecord) {
+  if (process.env.NODE_ENV === "test" || process.env.VITEST || storedAuthOverrideForTesting !== void 0) {
+    return;
+  }
+  try {
+    const dirPath = join6(homedir4(), ".local", "share", "opencode");
+    if (!existsSync6(dirPath)) {
+      mkdirSync5(dirPath, { recursive: true });
+    }
+    const authPath = join6(dirPath, "auth.json");
+    let data = {};
+    if (existsSync6(authPath)) {
+      try {
+        data = JSON.parse(readFileSync5(authPath, "utf8")) || {};
+      } catch {
+        data = {};
+      }
+    }
+    data[AGY_PROVIDER_ID] = {
+      type: "oauth",
+      refresh: authRecord.refresh,
+      access: authRecord.access,
+      expires: authRecord.expires
+    };
+    writeFileSync5(authPath, JSON.stringify(data, null, 2), "utf8");
+  } catch {
+  }
+}
 function createV2FetchInterceptor(getAuthSnapshot) {
   return async function agyV2Fetch(input, init) {
     const isGL = isGenerativeLanguageRequest(input);
@@ -21126,8 +21154,10 @@ async function setupOpenCodeV2(ctx) {
               };
             } catch {
             }
+            saveStoredAuthToJson(authRecord);
             return {
-              type: "success",
+              type: "oauth",
+              methodID: "oauth",
               refresh: authRecord.refresh,
               access: authRecord.access,
               expires: authRecord.expires
@@ -21145,6 +21175,7 @@ async function setupOpenCodeV2(ctx) {
     event.options.apiKey = "dummy";
     event.options.fetch = createV2FetchInterceptor();
   });
+  let lastInterceptedModel;
   ctx.session.hook(
     "http.request",
     async (event) => {
@@ -21157,9 +21188,31 @@ async function setupOpenCodeV2(ctx) {
       }
       event.headers = event.headers || {};
       let modelName;
+      let rawAuth = event.auth;
+      if (rawAuth && !rawAuth.type) {
+        const tokenVal = rawAuth.access || rawAuth.token;
+        if (tokenVal || rawAuth.refresh) {
+          rawAuth = { type: "oauth", access: tokenVal, ...rawAuth };
+        }
+      }
+      if (!rawAuth || !isOAuthAuth(rawAuth)) {
+        rawAuth = loadStoredAuthFromJson();
+      }
+      let authRecord = rawAuth && isOAuthAuth(rawAuth) ? resolveCachedAuth(rawAuth) : void 0;
+      if (authRecord && accessTokenExpired(authRecord)) {
+        const refreshed = await refreshAccessToken(authRecord, { auth: { set: async () => {
+        } } });
+        if (refreshed) {
+          authRecord = refreshed;
+          saveStoredAuthToJson(refreshed);
+        }
+      }
       if (isGL) {
         const parsed = parseGenerativeLanguageRequest(rawUrl);
         modelName = parsed?.effectiveModel;
+        if (modelName) {
+          lastInterceptedModel = modelName;
+        }
         if (typeof event.headers.delete === "function") {
           event.headers.delete("x-goog-api-key");
           event.headers.delete("api-key");
@@ -21184,6 +21237,7 @@ async function setupOpenCodeV2(ctx) {
             }
           }
         }
+        let cleanUrl = rawUrl;
         try {
           const parsedUrl = new URL(rawUrl);
           let urlChanged = false;
@@ -21194,63 +21248,187 @@ async function setupOpenCodeV2(ctx) {
             }
           }
           if (urlChanged) {
-            const cleanedUrl = parsedUrl.toString();
-            if (typeof event.url === "string") {
-              event.url = cleanedUrl;
+            cleanUrl = parsedUrl.toString();
+          }
+        } catch {
+        }
+        if (authRecord && authRecord.access) {
+          let projectContext;
+          try {
+            projectContext = await ensureProjectContext(
+              authRecord,
+              { auth: { set: async () => {
+              } } },
+              void 0,
+              modelName
+            );
+          } catch {
+            projectContext = {
+              effectiveProjectId: parseRefreshParts(authRecord.refresh).projectId || "antigravity",
+              auth: authRecord
+            };
+          }
+          const originalRequestedModel = modelName;
+          let modifiedUrl = cleanUrl;
+          if (originalRequestedModel) {
+            const originalBase = originalRequestedModel.replace("google-agy/", "");
+            const initHeaders = event.headers instanceof Headers ? event.headers : event.request?.headers;
+            const resolvedBase = resolveModelTier2(originalBase, { headers: initHeaders });
+            if (originalBase !== resolvedBase) {
+              modifiedUrl = modifiedUrl.replace(`models/${originalBase}`, `models/${resolvedBase}`);
             }
-            if (event.request && typeof event.request === "object") {
-              if (typeof event.request.url === "string") {
-                event.request.url = cleanedUrl;
+          }
+          let bodyPayload = event.body;
+          if (bodyPayload === void 0 && event.request) {
+            if (typeof event.request.clone === "function") {
+              try {
+                bodyPayload = await event.request.clone().text();
+              } catch {
               }
+            } else if (event.request.body !== void 0) {
+              bodyPayload = event.request.body;
             }
           }
-        } catch {
-        }
-        const hasAuth = typeof event.headers?.get === "function" ? !!event.headers.get("Authorization") : event.headers && Object.keys(event.headers).some((k) => k.toLowerCase() === "authorization");
-        if (!hasAuth) {
-          let token;
-          if (typeof event.auth?.access === "string" && event.auth.access) {
-            token = event.auth.access;
-          } else if (typeof event.auth?.token === "string" && event.auth.token) {
-            token = event.auth.token;
-          } else {
-            const storedAuth = loadStoredAuthFromJson();
-            if (storedAuth && isOAuthAuth(storedAuth)) {
-              const resolved = resolveCachedAuth(storedAuth);
-              token = resolved.access;
+          let preExistingUserAgent;
+          if (typeof event.headers?.get === "function") {
+            preExistingUserAgent = event.headers.get("user-agent") || event.headers.get("User-Agent") || void 0;
+          } else if (event.headers && typeof event.headers === "object") {
+            preExistingUserAgent = event.headers["user-agent"] || event.headers["User-Agent"] || void 0;
+          }
+          if (!preExistingUserAgent && typeof event.request?.headers?.get === "function") {
+            preExistingUserAgent = event.request.headers.get("user-agent") || event.request.headers.get("User-Agent") || void 0;
+          } else if (!preExistingUserAgent && event.request?.headers && typeof event.request.headers === "object") {
+            preExistingUserAgent = event.request.headers["user-agent"] || event.request.headers["User-Agent"] || void 0;
+          }
+          const method = event.method || event.request?.method || "POST";
+          const requestHeaders = event.headers || event.request?.headers;
+          const transformed = prepareAgyRequest(
+            modifiedUrl,
+            {
+              method,
+              headers: requestHeaders,
+              body: bodyPayload
+            },
+            authRecord.access,
+            projectContext.effectiveProjectId
+          );
+          const targetUrl = toUrlString2(transformed.request);
+          if (typeof event.url === "string") {
+            event.url = targetUrl;
+          }
+          if (event.request && typeof event.request === "object") {
+            if (typeof Request !== "undefined" && event.request instanceof Request) {
+              event.request = new Request(targetUrl, {
+                method: transformed.init.method,
+                headers: transformed.init.headers,
+                body: transformed.init.body
+              });
+            } else if (typeof event.request.url === "string") {
+              try {
+                event.request.url = targetUrl;
+              } catch {
+              }
             }
           }
-          if (token) {
+          const headerEntries = transformed.init.headers instanceof Headers ? Array.from(transformed.init.headers.entries()) : Object.entries(transformed.init.headers || {});
+          for (const [k, v] of headerEntries) {
+            const lowerK = k.toLowerCase();
+            if (lowerK === "user-agent") {
+              if (preExistingUserAgent) {
+                continue;
+              }
+              if (typeof event.headers?.set === "function") {
+                event.headers.set("User-Agent", v);
+              } else if (event.headers) {
+                event.headers["User-Agent"] = v;
+              }
+              if (event.request?.headers && typeof event.request.headers.set === "function") {
+                event.request.headers.set("User-Agent", v);
+              } else if (event.request?.headers && typeof event.request.headers === "object") {
+                event.request.headers["User-Agent"] = v;
+              }
+              continue;
+            }
             if (typeof event.headers?.set === "function") {
-              event.headers.set("Authorization", `Bearer ${token}`);
+              event.headers.set(k, v);
             } else if (event.headers) {
-              event.headers["Authorization"] = `Bearer ${token}`;
+              event.headers[k] = v;
             }
             if (event.request?.headers && typeof event.request.headers.set === "function") {
-              event.request.headers.set("Authorization", `Bearer ${token}`);
+              event.request.headers.set(k, v);
+            } else if (event.request?.headers && typeof event.request.headers === "object") {
+              event.request.headers[k] = v;
             }
           }
+          if (transformed.init.body !== void 0) {
+            event.body = transformed.init.body;
+            if (event.request && typeof event.request === "object" && !(event.request instanceof Request)) {
+              event.request.body = transformed.init.body;
+            }
+          }
+        } else {
+          if (typeof event.url === "string") {
+            event.url = cleanUrl;
+          }
+          if (event.request && typeof event.request === "object") {
+            if (typeof event.request.url === "string") {
+              event.request.url = cleanUrl;
+            }
+          }
+        }
+      }
+      if (authRecord && authRecord.access) {
+        if (typeof event.headers?.set === "function") {
+          event.headers.set("Authorization", `Bearer ${authRecord.access}`);
+        } else if (event.headers) {
+          event.headers["Authorization"] = `Bearer ${authRecord.access}`;
+        }
+        if (event.request?.headers && typeof event.request.headers.set === "function") {
+          event.request.headers.set("Authorization", `Bearer ${authRecord.access}`);
+        } else if (event.request?.headers && typeof event.request.headers === "object") {
+          event.request.headers["Authorization"] = `Bearer ${authRecord.access}`;
         }
       }
       const userAgent = buildAgyCliUserAgent(modelName);
-      if (typeof event.headers.set === "function") {
-        if (!event.headers.get("User-Agent")) {
+      if (typeof event.headers?.set === "function") {
+        if (!event.headers.get("User-Agent") && !event.headers.get("user-agent")) {
           event.headers.set("User-Agent", userAgent);
         }
-      } else {
+      } else if (event.headers) {
         if (!event.headers["User-Agent"] && !event.headers["user-agent"]) {
           event.headers["User-Agent"] = userAgent;
         }
       }
+      if (event.request?.headers && typeof event.request.headers.set === "function") {
+        if (!event.request.headers.get("User-Agent") && !event.request.headers.get("user-agent")) {
+          event.request.headers.set("User-Agent", userAgent);
+        }
+      } else if (event.request?.headers && typeof event.request.headers === "object") {
+        if (!event.request.headers["User-Agent"] && !event.request.headers["user-agent"]) {
+          event.request.headers["User-Agent"] = userAgent;
+        }
+      }
     },
     { providerID: AGY_PROVIDER_ID }
   );
   ctx.session.hook(
     "http.response",
     async (event) => {
-      if (!event) return;
-      if (event.response?.status === 429) {
-        return;
+      if (!event || !event.response) return;
+      const rawUrl = typeof event.url === "string" ? event.url : event.request?.url || "";
+      const isInternal = rawUrl.includes("cloudcode-pa.googleapis.com");
+      if (isInternal && event.response instanceof Response) {
+        const isStreaming = rawUrl.includes(":streamGenerateCode") || event.response.headers.get("content-type")?.includes("text/event-stream");
+        const parsedModel = parseGenerativeLanguageRequest(rawUrl)?.effectiveModel || lastInterceptedModel;
+        const transformed = await transformAgyResponse(
+          event.response,
+          !!isStreaming,
+          null,
+          parsedModel,
+          void 0,
+          void 0
+        );
+        event.response = transformed;
       }
     },
     { providerID: AGY_PROVIDER_ID }