@anthonyhaussman/opencode-agy-auth 1.2.3-alpha.2 → 1.2.3-alpha.4

package/dist/index.js

@@ -104,6 +104,8 @@ function updateStaticModelsWithPricing(staticModels) {
 
 // src/constants.ts
 var AGY_PROVIDER_ID = "google-agy";
+var AGY_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+var AGY_TOKEN_URL = "https://oauth2.googleapis.com/token";
 var AGY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var AGY_CLIENT_SECRET = "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";
 var AGY_SCOPES = [
@@ -20664,6 +20666,9 @@ 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";
 var AGY_V2_QUOTA_COMMAND = "agy-quota";
 var AGY_V2_QUOTA_SUMMARY_COMMAND = "agy-quota-summary";
 var AGY_V2_QUOTA_COMMAND_TEMPLATE = `Retrieve Agy Code Assist quota usage for the current authenticated account.
@@ -20676,6 +20681,203 @@ var AGY_V2_QUOTA_SUMMARY_COMMAND_TEMPLATE = `Retrieve Agy Code Assist quota summ
 Immediately call \`${AGY_QUOTA_SUMMARY_TOOL_NAME}\` with no arguments and return its output verbatim.
 Do not call other tools.
 `;
+function getSafeHeader2(headers, key) {
+  if (!headers) {
+    return void 0;
+  }
+  const targetKey = key.toLowerCase();
+  if (typeof headers.get === "function") {
+    try {
+      return headers.get(targetKey) || void 0;
+    } catch {
+    }
+  }
+  if (Array.isArray(headers)) {
+    const found = headers.find((item) => {
+      if (Array.isArray(item) && typeof item[0] === "string") {
+        return item[0].toLowerCase() === targetKey;
+      }
+      return false;
+    });
+    return found ? String(found[1]) : void 0;
+  }
+  if (typeof headers === "object") {
+    const foundKey = Object.keys(headers).find((k) => k.toLowerCase() === targetKey);
+    return foundKey ? headers[foundKey] !== void 0 ? String(headers[foundKey]) : void 0 : void 0;
+  }
+  return void 0;
+}
+function setSafeHeaders2(initHeaders, newHeaders) {
+  if (typeof globalThis.Headers !== "undefined") {
+    const headers = new globalThis.Headers(initHeaders ?? {});
+    for (const [k, v] of Object.entries(newHeaders)) {
+      headers.set(k, v);
+    }
+    return headers;
+  }
+  if (Array.isArray(initHeaders)) {
+    const nextHeaders2 = [...initHeaders];
+    for (const [k, v] of Object.entries(newHeaders)) {
+      const idx = nextHeaders2.findIndex((item) => Array.isArray(item) && typeof item[0] === "string" && item[0].toLowerCase() === k.toLowerCase());
+      if (idx !== -1) {
+        nextHeaders2[idx] = [k, v];
+      } else {
+        nextHeaders2.push([k, v]);
+      }
+    }
+    return nextHeaders2;
+  }
+  const nextHeaders = {};
+  if (initHeaders && typeof initHeaders === "object") {
+    for (const [k, v] of Object.entries(initHeaders)) {
+      nextHeaders[k] = String(v);
+    }
+  }
+  for (const [k, v] of Object.entries(newHeaders)) {
+    const existingKey = Object.keys(nextHeaders).find((key) => key.toLowerCase() === k.toLowerCase());
+    if (existingKey) {
+      nextHeaders[existingKey] = v;
+    } else {
+      nextHeaders[k] = v;
+    }
+  }
+  return nextHeaders;
+}
+function toUrlString2(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const candidate = value.url;
+  if (candidate) {
+    return candidate;
+  }
+  return value.toString();
+}
+function resolveModelTier2(baseModelId, init) {
+  const parts = baseModelId.split("@");
+  const base = parts[0] || "";
+  const suffixTier = parts[1]?.toLowerCase();
+  const mapping = TIER_MAPPING[base];
+  if (!mapping) {
+    return baseModelId;
+  }
+  const headerTier = getSafeHeader2(init?.headers, "x-agy-tier")?.toLowerCase() || null;
+  const requestedTier = headerTier || suffixTier;
+  if (requestedTier && Object.prototype.hasOwnProperty.call(mapping, requestedTier)) {
+    return mapping[requestedTier] || baseModelId;
+  }
+  return mapping["medium"] ?? mapping["high"];
+}
+function loadStoredAuthFromJson() {
+  const authPath = join6(homedir4(), ".local", "share", "opencode", "auth.json");
+  try {
+    if (existsSync6(authPath)) {
+      const content = readFileSync5(authPath, "utf8");
+      const data = JSON.parse(content);
+      return data?.[AGY_PROVIDER_ID];
+    }
+  } catch {
+  }
+  return void 0;
+}
+function createV2FetchInterceptor(getAuthSnapshot) {
+  return async function agyV2Fetch(input, init) {
+    const isGL = isGenerativeLanguageRequest(input);
+    const isInternal = toUrlString2(input).includes("cloudcode-pa.googleapis.com");
+    if (!isGL && !isInternal) {
+      return agyFetch(input, init);
+    }
+    let rawAuth = getAuthSnapshot ? await getAuthSnapshot() : void 0;
+    if (!rawAuth) {
+      rawAuth = loadStoredAuthFromJson();
+    }
+    if (!rawAuth || !isOAuthAuth(rawAuth)) {
+      return agyFetch(input, init);
+    }
+    let authRecord = resolveCachedAuth(rawAuth);
+    if (accessTokenExpired(authRecord)) {
+      const refreshed = await refreshAccessToken(authRecord, { auth: { set: async () => {
+      } } });
+      if (refreshed) {
+        authRecord = refreshed;
+      }
+    }
+    if (!authRecord.access) {
+      return agyFetch(input, init);
+    }
+    if (isInternal) {
+      const hasAuth = getSafeHeader2(init?.headers, "Authorization") !== void 0;
+      if (hasAuth) {
+        return agyFetch(input, init);
+      }
+      const userAgent = buildAgyCliUserAgent();
+      const headers = setSafeHeaders2(init?.headers, {
+        Authorization: `Bearer ${authRecord.access}`,
+        "User-Agent": userAgent
+      });
+      return agyFetch(input, {
+        ...init,
+        headers
+      });
+    }
+    const requestTarget = parseGenerativeLanguageRequest(input);
+    const requestUserAgentModel = requestTarget?.effectiveModel;
+    let projectContext;
+    try {
+      projectContext = await ensureProjectContext(
+        authRecord,
+        { auth: { set: async () => {
+        } } },
+        void 0,
+        requestUserAgentModel
+      );
+    } catch {
+      projectContext = {
+        effectiveProjectId: parseRefreshParts(authRecord.refresh).projectId || "antigravity",
+        auth: authRecord
+      };
+    }
+    const originalRequestedModel = parseGenerativeLanguageRequest(input)?.effectiveModel;
+    let modifiedInput = input;
+    if (isGL && originalRequestedModel) {
+      const originalBase = originalRequestedModel.replace("google-agy/", "");
+      const resolvedBase = resolveModelTier2(originalBase, init);
+      if (originalBase !== resolvedBase) {
+        if (typeof modifiedInput === "string") {
+          modifiedInput = modifiedInput.replace(`models/${originalBase}`, `models/${resolvedBase}`);
+        } else if (typeof Request !== "undefined" && modifiedInput instanceof Request) {
+          const newUrl = modifiedInput.url.replace(`models/${originalBase}`, `models/${resolvedBase}`);
+          modifiedInput = new Request(newUrl, modifiedInput);
+        }
+      }
+    }
+    const transformed = prepareAgyRequest(
+      modifiedInput,
+      init,
+      authRecord.access,
+      projectContext.effectiveProjectId,
+      void 0
+    );
+    const chatLogger = createChatLogger();
+    if (chatLogger) {
+      chatLogger.logRequest(
+        toUrlString2(transformed.request),
+        transformed.init.method || "GET",
+        transformed.init.headers,
+        transformed.init.body
+      );
+    }
+    const response = await fetchWithRetry(transformed.request, transformed.init);
+    return transformAgyResponse(
+      response,
+      transformed.streaming,
+      null,
+      transformed.requestedModel,
+      transformed.sessionId,
+      chatLogger
+    );
+  };
+}
 async function setupOpenCodeV2(ctx) {
   ctx.catalog.transform(async (editor) => {
     if (!editor) return;
@@ -20695,6 +20897,8 @@ async function setupOpenCodeV2(ctx) {
         p.activation = "enabled";
         p.package = "aisdk:@ai-sdk/google";
         p.description = "Google Gemini Antigravity Code Assist OAuth provider";
+        p.settings = { ...p.settings || {}, apiKey: "dummy" };
+        p.integrationID = AGY_PROVIDER_ID;
       });
       if (typeof editor?.model?.update === "function") {
         for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
@@ -20728,9 +20932,20 @@ async function setupOpenCodeV2(ctx) {
       id: AGY_PROVIDER_ID,
       name: "Antigravity CLI",
       npm: "aisdk:@ai-sdk/google",
+      settings: { apiKey: "dummy" },
+      integrationID: AGY_PROVIDER_ID,
       models: { ...catalog.providers[AGY_PROVIDER_ID]?.models || {} },
       ...catalog.providers[AGY_PROVIDER_ID]
     };
+    if (catalog.providers[AGY_PROVIDER_ID].settings) {
+      catalog.providers[AGY_PROVIDER_ID].settings = {
+        ...catalog.providers[AGY_PROVIDER_ID].settings,
+        apiKey: "dummy"
+      };
+    } else {
+      catalog.providers[AGY_PROVIDER_ID].settings = { apiKey: "dummy" };
+    }
+    catalog.providers[AGY_PROVIDER_ID].integrationID = AGY_PROVIDER_ID;
     const targetModels = catalog.providers[AGY_PROVIDER_ID].models;
     for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
       const isClaude = modelId.startsWith("claude-");
@@ -20827,61 +21042,212 @@ async function setupOpenCodeV2(ctx) {
       editor[AGY_V2_QUOTA_SUMMARY_COMMAND] = commands[AGY_V2_QUOTA_SUMMARY_COMMAND];
     }
   });
-  ctx.session.hook("http.request", async (event) => {
-    if (!event) return;
-    const url2 = typeof event.url === "string" ? event.url : event.request?.url || "";
-    const isGL = isGenerativeLanguageRequest(url2);
-    const isInternal = url2.includes("cloudcode-pa.googleapis.com");
-    if (!isGL && !isInternal) {
-      return;
-    }
-    event.headers = event.headers || {};
-    let modelName;
-    if (isGL) {
-      const parsed = parseGenerativeLanguageRequest(url2);
-      modelName = parsed?.effectiveModel;
-    }
-    const userAgent = buildAgyCliUserAgent(modelName);
-    if (typeof event.headers.set === "function") {
-      if (!event.headers.get("User-Agent")) {
-        event.headers.set("User-Agent", userAgent);
-      }
-    } else {
-      if (!event.headers["User-Agent"] && !event.headers["user-agent"]) {
-        event.headers["User-Agent"] = userAgent;
+  ctx.integration?.transform?.((editor) => {
+    if (!editor) return;
+    editor.update?.(AGY_PROVIDER_ID, (integration) => {
+      integration.name = "Antigravity CLI (plugin)";
+    });
+    editor.method?.update?.({
+      integrationID: AGY_PROVIDER_ID,
+      method: {
+        id: "oauth",
+        type: "oauth",
+        label: "Antigravity CLI (OAuth)"
+      },
+      authorize: async () => {
+        const authUrl = new URL(AGY_AUTH_URL);
+        authUrl.searchParams.set("client_id", AGY_CLIENT_ID);
+        authUrl.searchParams.set("response_type", "code");
+        authUrl.searchParams.set("redirect_uri", "http://localhost");
+        authUrl.searchParams.set("scope", AGY_SCOPES.join(" "));
+        authUrl.searchParams.set("access_type", "offline");
+        authUrl.searchParams.set("prompt", "consent");
+        return {
+          mode: "code",
+          url: authUrl.toString(),
+          instructions: "Please complete Google account authorization in your browser. After authorization, copy the full redirect URL or code and paste it below:",
+          callback: async (code) => {
+            const trimmed = code.trim();
+            const parsed = parseOAuthCallbackInput(trimmed);
+            const authCode = parsed.code || trimmed;
+            if (!authCode) {
+              return { type: "failed", error: "Missing authorization code in callback input" };
+            }
+            const tokenResponse = await agyFetch(AGY_TOKEN_URL, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+              },
+              body: new URLSearchParams({
+                client_id: AGY_CLIENT_ID,
+                client_secret: AGY_CLIENT_SECRET,
+                code: authCode,
+                grant_type: "authorization_code",
+                redirect_uri: "http://localhost"
+              })
+            });
+            if (!tokenResponse.ok) {
+              const errorText = await tokenResponse.text();
+              return { type: "failed", error: errorText };
+            }
+            const tokenPayload = await tokenResponse.json();
+            if (!tokenPayload.refresh_token) {
+              return { type: "failed", error: "Missing refresh token in response" };
+            }
+            const initialRefresh = formatRefreshParts({
+              refreshToken: tokenPayload.refresh_token
+            });
+            let authRecord = {
+              type: "oauth",
+              refresh: initialRefresh,
+              access: tokenPayload.access_token,
+              expires: Date.now() + tokenPayload.expires_in * 1e3
+            };
+            try {
+              const projectContext = await ensureProjectContext(
+                authRecord,
+                { auth: { set: async () => {
+                } } }
+              );
+              authRecord = {
+                ...authRecord,
+                refresh: projectContext.auth.refresh
+              };
+            } catch {
+            }
+            return {
+              type: "success",
+              refresh: authRecord.refresh,
+              access: authRecord.access,
+              expires: authRecord.expires
+            };
+          }
+        };
       }
-    }
+    });
   });
-  ctx.session.hook("http.response", async (event) => {
+  ctx.aisdk?.hook("sdk", async (event) => {
     if (!event) return;
-    if (event.response?.status === 429) {
-      return;
-    }
+    const isMatchingProvider = event.providerID === AGY_PROVIDER_ID || event.model?.providerID === AGY_PROVIDER_ID;
+    if (!isMatchingProvider) return;
+    event.options = event.options || {};
+    event.options.apiKey = "dummy";
+    event.options.fetch = createV2FetchInterceptor();
   });
-  ctx.session.hook("retry", async (event) => {
-    if (!event) return;
-    const response = event.response;
-    if (response instanceof Response) {
-      if (response.status === 429 || response.status === 503) {
-        const quota = await classifyQuotaResponse(response);
-        if (quota?.retryDelayMs) {
-          event.retryDelayMs = quota.retryDelayMs;
+  ctx.session.hook(
+    "http.request",
+    async (event) => {
+      if (!event) return;
+      const rawUrl = typeof event.url === "string" ? event.url : event.request?.url || "";
+      const isGL = isGenerativeLanguageRequest(rawUrl);
+      const isInternal = rawUrl.includes("cloudcode-pa.googleapis.com");
+      if (!isGL && !isInternal) {
+        return;
+      }
+      event.headers = event.headers || {};
+      let modelName;
+      if (isGL) {
+        const parsed = parseGenerativeLanguageRequest(rawUrl);
+        modelName = parsed?.effectiveModel;
+        if (typeof event.headers.delete === "function") {
+          event.headers.delete("x-goog-api-key");
+          event.headers.delete("api-key");
         } else {
-          event.retryDelayMs = await resolveRetryDelayMs(response, event.attempt || 1);
+          for (const key of Object.keys(event.headers)) {
+            const lower = key.toLowerCase();
+            if (lower === "x-goog-api-key" || lower === "api-key") {
+              delete event.headers[key];
+            }
+          }
+        }
+        try {
+          const parsedUrl = new URL(rawUrl);
+          let urlChanged = false;
+          for (const param of ["key", "x-goog-api-key", "api-key"]) {
+            if (parsedUrl.searchParams.has(param)) {
+              parsedUrl.searchParams.delete(param);
+              urlChanged = true;
+            }
+          }
+          if (urlChanged) {
+            const cleanedUrl = parsedUrl.toString();
+            if (typeof event.url === "string") {
+              event.url = cleanedUrl;
+            }
+            if (event.request && typeof event.request === "object") {
+              if (typeof event.request.url === "string") {
+                event.request.url = cleanedUrl;
+              }
+            }
+          }
+        } catch {
+        }
+        const hasAuth = typeof event.headers.get === "function" ? !!event.headers.get("Authorization") : 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;
+          }
+          if (typeof event.headers.set === "function") {
+            event.headers.set("Authorization", `Bearer ${token || "dummy"}`);
+          } else {
+            event.headers["Authorization"] = `Bearer ${token || "dummy"}`;
+          }
         }
       }
-    } else if (event.details && Array.isArray(event.details)) {
-      const retryInfo = event.details.find(
-        (d) => d && d["@type"] === "type.googleapis.com/google.rpc.RetryInfo"
-      );
-      if (retryInfo?.retryDelay) {
-        const delayMs = retryInternals.parseRetryDelayValue(retryInfo.retryDelay);
-        if (delayMs !== null) {
-          event.retryDelayMs = delayMs;
+      const userAgent = buildAgyCliUserAgent(modelName);
+      if (typeof event.headers.set === "function") {
+        if (!event.headers.get("User-Agent")) {
+          event.headers.set("User-Agent", userAgent);
+        }
+      } else {
+        if (!event.headers["User-Agent"] && !event.headers["user-agent"]) {
+          event.headers["User-Agent"] = userAgent;
         }
       }
-    }
-  });
+    },
+    { providerID: AGY_PROVIDER_ID }
+  );
+  ctx.session.hook(
+    "http.response",
+    async (event) => {
+      if (!event) return;
+      if (event.response?.status === 429) {
+        return;
+      }
+    },
+    { providerID: AGY_PROVIDER_ID }
+  );
+  ctx.session.hook(
+    "retry",
+    async (event) => {
+      if (!event) return;
+      const response = event.response;
+      if (response instanceof Response) {
+        if (response.status === 429 || response.status === 503) {
+          const quota = await classifyQuotaResponse(response);
+          if (quota?.retryDelayMs) {
+            event.retryDelayMs = quota.retryDelayMs;
+          } else {
+            event.retryDelayMs = await resolveRetryDelayMs(response, event.attempt || 1);
+          }
+        }
+      } else if (event.details && Array.isArray(event.details)) {
+        const retryInfo = event.details.find(
+          (d) => d && d["@type"] === "type.googleapis.com/google.rpc.RetryInfo"
+        );
+        if (retryInfo?.retryDelay) {
+          const delayMs = retryInternals.parseRetryDelayValue(retryInfo.retryDelay);
+          if (delayMs !== null) {
+            event.retryDelayMs = delayMs;
+          }
+        }
+      }
+    },
+    { providerID: AGY_PROVIDER_ID }
+  );
 }
 var v2PluginDefinition = defineOpenCodeV2Plugin({
   id: AGY_PROVIDER_ID,