@hashimkarim/usagestat-linux-x64-gnu 2.0.0-alpha.1

package/plugins/antigravity/plugin.js

@@ -0,0 +1,739 @@
+(function () {
+  var LS_SERVICE = "exa.language_server_pb.LanguageServerService"
+  var AGY_KEYCHAIN_SERVICE = "gemini"
+  var AGY_KEYCHAIN_ACCOUNT = "antigravity"
+  var CLOUD_CODE_URLS = [
+    "https://daily-cloudcode-pa.googleapis.com",
+    "https://cloudcode-pa.googleapis.com",
+  ]
+  var LOAD_CODE_ASSIST_PATH = "/v1internal:loadCodeAssist"
+  var FETCH_MODELS_PATH = "/v1internal:fetchAvailableModels"
+  var RETRIEVE_QUOTA_PATH = "/v1internal:retrieveUserQuota"
+  var LOGIN_MESSAGE = "Start Antigravity or run `agy` and try again."
+  var GOOGLE_OAUTH_URL = "https://oauth2.googleapis.com/token"
+  var GOOGLE_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"
+  var GOOGLE_CLIENT_SECRET = "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"
+  var OAUTH_TOKEN_KEY = "antigravityUnifiedStateSync.oauthToken"
+  var OAUTH_TOKEN_SENTINEL = "oauthTokenInfoSentinelKey"
+  var CC_MODEL_BLACKLIST = {
+    "MODEL_CHAT_20706": true,
+    "MODEL_CHAT_23310": true,
+    "MODEL_GOOGLE_GEMINI_2_5_FLASH": true,
+    "MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING": true,
+    "MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE": true,
+    "MODEL_GOOGLE_GEMINI_2_5_PRO": true,
+    "MODEL_PLACEHOLDER_M19": true,
+    "MODEL_PLACEHOLDER_M9": true,
+    "MODEL_PLACEHOLDER_M12": true,
+  }
+  // --- Protobuf wire-format decoder ---
+
+  function readVarint(s, pos) {
+    var v = 0
+    var shift = 0
+    while (pos < s.length) {
+      var b = s.charCodeAt(pos++)
+      v += (b & 0x7f) * Math.pow(2, shift)
+      if ((b & 0x80) === 0) return { v: v, p: pos }
+      shift += 7
+    }
+    return null
+  }
+
+  function readFields(s) {
+    var fields = {}
+    var pos = 0
+    while (pos < s.length) {
+      var tag = readVarint(s, pos)
+      if (!tag) break
+      pos = tag.p
+      var fieldNum = Math.floor(tag.v / 8)
+      var wireType = tag.v % 8
+      if (wireType === 0) {
+        var val = readVarint(s, pos)
+        if (!val) break
+        fields[fieldNum] = { type: 0, value: val.v }
+        pos = val.p
+      } else if (wireType === 1) {
+        if (pos + 8 > s.length) break
+        pos += 8
+      } else if (wireType === 2) {
+        var len = readVarint(s, pos)
+        if (!len) break
+        pos = len.p
+        if (pos + len.v > s.length) break
+        fields[fieldNum] = { type: 2, data: s.substring(pos, pos + len.v) }
+        pos += len.v
+      } else if (wireType === 5) {
+        if (pos + 4 > s.length) break
+        pos += 4
+      } else {
+        break
+      }
+    }
+    return fields
+  }
+
+  // --- SQLite credential reading ---
+
+  function providerSettings(ctx) { return (ctx.provider && ctx.provider.settings) || {} }
+
+  function antigravityStateDbPaths(ctx) {
+    var opts = providerSettings(ctx)
+    if (opts.userDataDir) return [opts.userDataDir.replace(/[\\/]+$/, "") + "/User/globalStorage/state.vscdb"]
+    var variants = {"antigravity": "Antigravity", "antigravity-ide": "Antigravity IDE"}
+    if (opts.ideVariant && !variants[opts.ideVariant]) throw {code: "failed", message: "Unknown Antigravity ideVariant; use antigravity or antigravity-ide."}
+    return (opts.ideVariant ? [opts.ideVariant] : Object.keys(variants)).map(function(id) {
+      return ctx.host.fs.appSupportPath(variants[id] + "/User/globalStorage/state.vscdb")
+    }).filter(function(path) { return !!path && ctx.host.fs.exists(path) })
+  }
+
+  // Antigravity wraps OAuth state in a double-base64 envelope:
+  //   b64(outer.f1 = wrapper{ f1=sentinel, f2=payload{ f1=b64(inner proto) } }).
+  // The inner base64 layer is the unusual part - it's a UTF-8 string field, not raw bytes.
+  function unwrapOAuthSentinel(ctx, base64Text) {
+    var trimmed = String(base64Text || "").replace(/^\s+|\s+$/g, "")
+    if (!trimmed) return null
+    var outer = ctx.base64.decode(trimmed)
+    var outerFields = readFields(outer)
+    if (!outerFields[1] || outerFields[1].type !== 2) return null
+    var wrapper = readFields(outerFields[1].data)
+    var sentinel = (wrapper[1] && wrapper[1].type === 2) ? wrapper[1].data : null
+    var payload = (wrapper[2] && wrapper[2].type === 2) ? wrapper[2].data : null
+    if (sentinel !== OAUTH_TOKEN_SENTINEL || !payload) return null
+    var payloadFields = readFields(payload)
+    if (!payloadFields[1] || payloadFields[1].type !== 2) return null
+    var innerText = payloadFields[1].data.replace(/^\s+|\s+$/g, "")
+    if (!innerText) return null
+    return ctx.base64.decode(innerText)
+  }
+
+  function loadOAuthTokensFromDb(ctx, dbPath) {
+    try {
+      var rows = ctx.host.sqlite.query(
+        dbPath,
+        "SELECT value FROM ItemTable WHERE key = '" + OAUTH_TOKEN_KEY + "' LIMIT 1"
+      )
+      var parsed = ctx.util.tryParseJson(rows)
+      if (!parsed || !parsed.length || !parsed[0].value) return null
+      var inner = unwrapOAuthSentinel(ctx, parsed[0].value)
+      if (!inner) return null
+      var fields = readFields(inner)
+      var accessToken = (fields[1] && fields[1].type === 2) ? fields[1].data : null
+      var refreshToken = (fields[3] && fields[3].type === 2) ? fields[3].data : null
+      var expirySeconds = null
+      if (fields[4] && fields[4].type === 2) {
+        var ts = readFields(fields[4].data)
+        if (ts[1] && ts[1].type === 0) expirySeconds = ts[1].value
+      }
+      if (!accessToken && !refreshToken) return null
+      return { accessToken: accessToken, refreshToken: refreshToken, expirySeconds: expirySeconds }
+    } catch (e) {
+      ctx.host.log.warn("failed to read unified oauth token from " + dbPath + ": " + String(e))
+      return null
+    }
+  }
+
+  function loadOAuthTokenCandidates(ctx) {
+    var candidates = []
+    var paths = antigravityStateDbPaths(ctx)
+    for (var i = 0; i < paths.length; i++) {
+      var tokens = loadOAuthTokensFromDb(ctx, paths[i])
+      if (tokens) {
+        tokens.profileKey = ctx.host.crypto.sha256Hex(paths[i] + "\n" + (tokens.refreshToken || tokens.accessToken))
+        candidates.push(tokens)
+      }
+    }
+    if (candidates.length > 1) throw {code: "failed", message: "Multiple Antigravity credential profiles found; set settings.ideVariant or userDataDir."}
+    return candidates
+  }
+
+  // --- Google OAuth token refresh ---
+
+  function refreshAccessToken(ctx, refreshTokenValue, profileKey) {
+    if (!refreshTokenValue) {
+      ctx.host.log.warn("refresh skipped: no refresh token")
+      return null
+    }
+    ctx.host.log.info("attempting Google OAuth token refresh")
+    try {
+      var resp = ctx.host.http.request({
+        method: "POST",
+        url: GOOGLE_OAUTH_URL,
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        bodyText:
+          "client_id=" + encodeURIComponent(GOOGLE_CLIENT_ID) +
+          "&client_secret=" + encodeURIComponent(GOOGLE_CLIENT_SECRET) +
+          "&refresh_token=" + encodeURIComponent(refreshTokenValue) +
+          "&grant_type=refresh_token",
+        timeoutMs: 15000,
+      })
+      if (resp.status < 200 || resp.status >= 300) {
+        ctx.host.log.warn("Google OAuth refresh returned status: " + resp.status)
+        return null
+      }
+      var body = ctx.util.tryParseJson(resp.bodyText)
+      if (!body || !body.access_token) {
+        ctx.host.log.warn("Google OAuth refresh response missing access_token")
+        return null
+      }
+      var expiresIn = (typeof body.expires_in === "number") ? body.expires_in : 3600
+      cacheToken(ctx, body.access_token, expiresIn, profileKey)
+      return body.access_token
+    } catch (e) {
+      ctx.host.log.warn("Google OAuth refresh failed: " + String(e))
+      return null
+    }
+  }
+
+  // --- Token cache ---
+
+  function loadCachedToken(ctx, profileKey) {
+    var path = ctx.app.pluginDataDir + "/auth.json"
+    try {
+      if (!ctx.host.fs.exists(path)) return null
+      var data = ctx.util.tryParseJson(ctx.host.fs.readText(path))
+      if (!data || !profileKey || data.profileKey !== profileKey || !data.accessToken || !data.expiresAtMs) return null
+      if (data.expiresAtMs <= Date.now()) return null
+      return data.accessToken
+    } catch (e) {
+      ctx.host.log.warn("failed to read cached token: " + String(e))
+      return null
+    }
+  }
+
+  function cacheToken(ctx, accessToken, expiresInSeconds, profileKey) {
+    var path = ctx.app.pluginDataDir + "/auth.json"
+    try {
+      ctx.host.fs.writeText(path, JSON.stringify({
+        accessToken: accessToken,
+        profileKey: profileKey,
+        expiresAtMs: Date.now() + (expiresInSeconds || 3600) * 1000,
+      }))
+    } catch (e) {
+      ctx.host.log.warn("failed to cache refreshed token: " + String(e))
+    }
+  }
+
+  // --- agy keychain token ---
+
+  function trimString(value) {
+    return typeof value === "string" ? value.trim() : ""
+  }
+
+  function decodeBase64(ctx, text) {
+    try {
+      return ctx.base64.decode(text)
+    } catch (e) {
+      return null
+    }
+  }
+
+  function unwrapAgyKeychainText(ctx, raw) {
+    var text = trimString(raw)
+    if (!text) return null
+    if (text.indexOf("go-keyring-base64:") === 0) {
+      text = trimString(decodeBase64(ctx, text.slice("go-keyring-base64:".length)))
+    }
+    return text || null
+  }
+
+  function extractTokenFromObject(obj) {
+    if (!obj || typeof obj !== "object") return null
+
+    var directKeys = [
+      "access_token",
+      "accessToken",
+      "token",
+      "id_token",
+      "idToken",
+      "bearerToken",
+      "auth_token",
+      "authToken",
+    ]
+    for (var i = 0; i < directKeys.length; i++) {
+      var value = obj[directKeys[i]]
+      if (typeof value === "string" && value.trim()) return value.trim()
+    }
+
+    var nestedKeys = ["token", "tokens", "oauth", "oauth2", "credentials", "auth"]
+    for (var j = 0; j < nestedKeys.length; j++) {
+      var nested = extractTokenFromObject(obj[nestedKeys[j]])
+      if (nested) return nested
+    }
+
+    return null
+  }
+
+  function extractAgyAccessToken(ctx, raw) {
+    var text = unwrapAgyKeychainText(ctx, raw)
+    if (!text) return null
+
+    var parsed = ctx.util.tryParseJson(text)
+    if (typeof parsed === "string" && parsed.trim()) return parsed.trim()
+    if (parsed) return extractTokenFromObject(parsed)
+
+    if (text.indexOf("Bearer ") === 0) return text.slice("Bearer ".length).trim() || null
+    return text
+  }
+
+  function loadAgyKeychainToken(ctx) {
+    if (!ctx.host.keychain || typeof ctx.host.keychain.readGenericPassword !== "function") {
+      return null
+    }
+    try {
+      var raw = ctx.host.keychain.readGenericPassword(AGY_KEYCHAIN_SERVICE, AGY_KEYCHAIN_ACCOUNT)
+      return extractAgyAccessToken(ctx, raw)
+    } catch (e) {
+      ctx.host.log.info("agy keychain read failed: " + String(e))
+      return null
+    }
+  }
+
+  // --- LS discovery ---
+
+  function discoverNative(ctx, options) {
+    if (typeof ctx.host.ls.discoverStatus !== "function") return ctx.host.ls.discover(options)
+    var report = ctx.host.ls.discoverStatus(options)
+    if (report.status === "ready") return report.result
+    if (report.status === "missing") return null
+    if (report.status === "ambiguous") throw {code: "failed", message: "Multiple Antigravity processes found; select settings.ideProcessId or use the separate CLI provider."}
+    throw {code: report.status === "unsupported" ? "unsupported" : report.reasonCode === "ide-discovery-timed-out" ? "timed-out" : "failed", message: "Antigravity process discovery is unavailable; run the backend and app as the same signed-in user."}
+  }
+
+  function discoverLs(ctx) {
+    var options = {processName: "language_server", markers: ["antigravity", "antigravity-ide"], csrfFlag: "--csrf_token", portFlag: "--extension_server_port"}
+    var pid = providerSettings(ctx).ideProcessId
+    if (pid != null) {
+      if (!Number.isInteger(Number(pid)) || Number(pid) <= 0 || Number(pid) > 4294967295) throw {code: "failed", message: "Invalid Antigravity ideProcessId."}
+      options.pid = Number(pid)
+    }
+    return discoverNative(ctx, options)
+  }
+
+  function discoverAgyLs(ctx) {
+    return discoverNative(ctx, {processName: "agy", markers: [], csrfFlag: "", portFlag: null})
+  }
+
+  function probePort(ctx, scheme, port, csrf) {
+    ctx.host.http.request({
+      method: "POST",
+      url: scheme + "://127.0.0.1:" + port + "/" + LS_SERVICE + "/GetUnleashData",
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-codeium-csrf-token": csrf,
+      },
+      bodyText: JSON.stringify({
+        context: {
+          properties: {
+            devMode: "false",
+            extensionVersion: "unknown",
+            ide: "antigravity",
+            ideVersion: "unknown",
+            os: "macos",
+          },
+        },
+      }),
+      timeoutMs: 5000,
+      dangerouslyIgnoreTls: scheme === "https",
+    })
+    // Any HTTP response means this port is alive (even 400 validation errors).
+    return true
+  }
+
+  function findWorkingPort(ctx, discovery) {
+    var ports = discovery.ports || []
+    for (var i = 0; i < ports.length; i++) {
+      var port = ports[i]
+      // Try HTTPS first (LS may use self-signed cert), then HTTP
+      try { if (probePort(ctx, "https", port, discovery.csrf)) return { port: port, scheme: "https" } } catch (e) { /* ignore */ }
+      try { if (probePort(ctx, "http", port, discovery.csrf)) return { port: port, scheme: "http" } } catch (e) { /* ignore */ }
+      ctx.host.log.info("port " + port + " probe failed on both schemes")
+    }
+    if (discovery.extensionPort) return { port: discovery.extensionPort, scheme: "http" }
+    return null
+  }
+
+  function callLs(ctx, port, scheme, csrf, method, body) {
+    var resp = ctx.host.http.request({
+      method: "POST",
+      url: scheme + "://127.0.0.1:" + port + "/" + LS_SERVICE + "/" + method,
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-codeium-csrf-token": csrf,
+      },
+      bodyText: JSON.stringify(body || {}),
+      timeoutMs: 10000,
+      dangerouslyIgnoreTls: scheme === "https",
+    })
+    if (resp.status < 200 || resp.status >= 300) {
+      ctx.host.log.warn("callLs " + method + " returned " + resp.status)
+      return null
+    }
+    return ctx.util.tryParseJson(resp.bodyText)
+  }
+
+  // --- Line builders ---
+
+  function normalizeLabel(label) {
+    // "Gemini 3 Pro (High)" -> "Gemini 3 Pro"
+    return label.replace(/\s*\([^)]*\)\s*$/, "").trim()
+  }
+
+  function poolLabel(normalizedLabel) {
+    var lower = normalizedLabel.toLowerCase()
+    if (lower.indexOf("gemini") !== -1 && lower.indexOf("pro") !== -1) return "Gemini Pro"
+    if (lower.indexOf("gemini") !== -1 && lower.indexOf("flash") !== -1) return "Gemini Flash"
+    // All non-Gemini models (Claude, GPT-OSS, etc.) share a single quota pool
+    return "Claude"
+  }
+
+  function modelSortKey(label) {
+    var lower = label.toLowerCase()
+    // Gemini Pro variants first, then other Gemini, then Claude Opus, then other Claude, then rest
+    if (lower.indexOf("gemini") !== -1 && lower.indexOf("pro") !== -1) return "0a_" + label
+    if (lower.indexOf("gemini") !== -1) return "0b_" + label
+    if (lower.indexOf("claude") !== -1 && lower.indexOf("opus") !== -1) return "1a_" + label
+    if (lower.indexOf("claude") !== -1) return "1b_" + label
+    return "2_" + label
+  }
+
+  var QUOTA_PERIOD_MS = 5 * 60 * 60 * 1000 // 5 hours
+
+  function modelLine(ctx, label, remainingFraction, resetTime) {
+    var clamped = Math.max(0, Math.min(1, remainingFraction))
+    var used = Math.round((1 - clamped) * 100)
+    return ctx.line.progress({
+      label: label,
+      used: used,
+      limit: 100,
+      format: { kind: "percent" },
+      resetsAt: resetTime || undefined,
+      periodDurationMs: QUOTA_PERIOD_MS,
+    })
+  }
+
+  function buildModelLines(ctx, configs) {
+    var deduped = {}
+    for (var i = 0; i < configs.length; i++) {
+      var c = configs[i]
+      var label = (typeof c.label === "string") ? c.label.trim() : ""
+      if (!label) continue
+      var qi = c.quotaInfo
+      var frac = (qi && typeof qi.remainingFraction === "number") ? qi.remainingFraction : 0
+      var rtime = (qi && qi.resetTime) || undefined
+      var pool = poolLabel(normalizeLabel(label))
+      if (!deduped[pool] || frac < deduped[pool].remainingFraction) {
+        deduped[pool] = {
+          label: pool,
+          remainingFraction: frac,
+          resetTime: rtime,
+        }
+      }
+    }
+
+    var models = []
+    var keys = Object.keys(deduped)
+    for (var i = 0; i < keys.length; i++) {
+      var m = deduped[keys[i]]
+      m.sortKey = modelSortKey(m.label)
+      models.push(m)
+    }
+
+    models.sort(function (a, b) {
+      return a.sortKey < b.sortKey ? -1 : a.sortKey > b.sortKey ? 1 : 0
+    })
+
+    var lines = []
+    for (var i = 0; i < models.length; i++) {
+      lines.push(modelLine(ctx, models[i].label, models[i].remainingFraction, models[i].resetTime))
+    }
+    return lines
+  }
+
+  // --- Cloud Code API ---
+
+  function requestCloudCodeJson(ctx, path, token, userAgent, body) {
+    for (var i = 0; i < CLOUD_CODE_URLS.length; i++) {
+      try {
+        var resp = ctx.host.http.request({
+          method: "POST",
+          url: CLOUD_CODE_URLS[i] + path,
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + token,
+            "User-Agent": userAgent || "antigravity",
+          },
+          bodyText: JSON.stringify(body || {}),
+          timeoutMs: 15000,
+        })
+        if (!resp || typeof resp.status !== "number" || !Number.isFinite(resp.status)) {
+          ctx.host.log.warn("Cloud Code returned invalid response shape (" + CLOUD_CODE_URLS[i] + ")")
+          continue
+        }
+        if (ctx.util.isAuthStatus(resp.status)) return { _authFailed: true }
+        if (resp.status >= 200 && resp.status < 300) {
+          var json = ctx.util.tryParseJson(resp.bodyText)
+          if (!json || typeof json !== "object") {
+            ctx.host.log.warn("Cloud Code returned invalid JSON (" + CLOUD_CODE_URLS[i] + ")")
+            continue
+          }
+          return json
+        }
+      } catch (e) {
+        ctx.host.log.warn("Cloud Code request failed (" + CLOUD_CODE_URLS[i] + "): " + String(e))
+      }
+    }
+    return null
+  }
+
+  function probeCloudCode(ctx, token, userAgent) {
+    return requestCloudCodeJson(ctx, FETCH_MODELS_PATH, token, userAgent, {})
+  }
+
+  function parseCloudCodeModels(data) {
+    var modelsObj = data && data.models
+    if (!modelsObj || typeof modelsObj !== "object") return []
+    var keys = Object.keys(modelsObj)
+    var configs = []
+    for (var i = 0; i < keys.length; i++) {
+      var m = modelsObj[keys[i]]
+      if (!m || typeof m !== "object") continue
+      if (m.isInternal) continue
+      var modelId = m.model || keys[i]
+      if (CC_MODEL_BLACKLIST[modelId]) continue
+      var displayName =
+        (typeof m.displayName === "string" && m.displayName.trim()) ||
+        (typeof m.label === "string" && m.label.trim()) ||
+        ""
+      if (!displayName) continue
+      var qi = m.quotaInfo
+      var frac = (qi && typeof qi.remainingFraction === "number") ? qi.remainingFraction : 0
+      var rtime = (qi && qi.resetTime) || undefined
+      configs.push({
+        label: displayName,
+        quotaInfo: { remainingFraction: frac, resetTime: rtime },
+      })
+    }
+    return configs
+  }
+
+  function readAgyPlan(loadData) {
+    var paidTier = loadData && loadData.paidTier
+    if (paidTier && typeof paidTier.name === "string" && paidTier.name.trim()) {
+      return paidTier.name.trim()
+    }
+    var currentTier = loadData && loadData.currentTier
+    if (currentTier && typeof currentTier.name === "string" && currentTier.name.trim()) {
+      return currentTier.name.trim()
+    }
+    return null
+  }
+
+  function parseAgyQuotaBuckets(data) {
+    var buckets = data && data.buckets
+    if (!Array.isArray(buckets)) return []
+    var configs = []
+    for (var i = 0; i < buckets.length; i++) {
+      var bucket = buckets[i]
+      if (!bucket || typeof bucket !== "object") continue
+      var modelId = (typeof bucket.modelId === "string" && bucket.modelId.trim()) || ""
+      if (!modelId) continue
+      var frac = (typeof bucket.remainingFraction === "number") ? bucket.remainingFraction : 0
+      configs.push({
+        label: modelId,
+        quotaInfo: { remainingFraction: frac, resetTime: bucket.resetTime || undefined },
+      })
+    }
+    return configs
+  }
+
+  function probeAgyCloudCode(ctx, token) {
+    var loadData = requestCloudCodeJson(ctx, LOAD_CODE_ASSIST_PATH, token, "agy", {})
+    if (!loadData || loadData._authFailed) return loadData
+
+    var project =
+      typeof loadData.cloudaicompanionProject === "string" && loadData.cloudaicompanionProject.trim()
+        ? loadData.cloudaicompanionProject.trim()
+        : null
+    var quotaData = null
+    if (project) {
+      quotaData = requestCloudCodeJson(ctx, RETRIEVE_QUOTA_PATH, token, "agy", { project: project })
+    }
+    if (!quotaData || quotaData._authFailed) {
+      quotaData = requestCloudCodeJson(ctx, RETRIEVE_QUOTA_PATH, token, "agy", {})
+    }
+    if (!quotaData || quotaData._authFailed) return quotaData
+
+    var lines = buildModelLines(ctx, parseAgyQuotaBuckets(quotaData))
+    if (lines.length === 0) return null
+    return { plan: readAgyPlan(loadData), lines: lines }
+  }
+
+  // --- LS probe ---
+
+  function probeDiscovery(ctx, discovery) {
+    if (!discovery) return null
+
+    var found = findWorkingPort(ctx, discovery)
+    if (!found) return null
+
+    ctx.host.log.info("using LS at " + found.scheme + "://127.0.0.1:" + found.port)
+
+    var metadata = {
+      ideName: "antigravity",
+      extensionName: "antigravity",
+      ideVersion: "unknown",
+      locale: "en",
+    }
+
+    // Try GetUserStatus first, fall back to GetCommandModelConfigs
+    var data = null
+    try {
+      data = callLs(ctx, found.port, found.scheme, discovery.csrf, "GetUserStatus", { metadata: metadata })
+    } catch (e) {
+      ctx.host.log.warn("GetUserStatus threw: " + String(e))
+    }
+    var hasUserStatus = data && data.userStatus
+
+    if (!hasUserStatus) {
+      ctx.host.log.warn("GetUserStatus failed, trying GetCommandModelConfigs")
+      data = callLs(ctx, found.port, found.scheme, discovery.csrf, "GetCommandModelConfigs", { metadata: metadata })
+    }
+
+    // Parse model configs
+    var configs
+    if (hasUserStatus) {
+      configs = (data.userStatus.cascadeModelConfigData || {}).clientModelConfigs || []
+    } else if (data && data.clientModelConfigs) {
+      configs = data.clientModelConfigs
+    } else {
+      return null
+    }
+
+    var filtered = []
+    for (var j = 0; j < configs.length; j++) {
+      var mid = configs[j].modelOrAlias && configs[j].modelOrAlias.model
+      if (mid && CC_MODEL_BLACKLIST[mid]) continue
+      filtered.push(configs[j])
+    }
+
+    var lines = buildModelLines(ctx, filtered)
+    if (lines.length === 0) return null
+
+    var plan = null
+    if (hasUserStatus) {
+      // Prefer userTier.name (Google's own subscription system) over the legacy
+      // planInfo.planName field inherited from Windsurf/Codeium, which always
+      // returns "Pro" for all paid tiers including Google AI Ultra.
+      var ut = data.userStatus.userTier
+      var userTierName =
+        ut && typeof ut.name === "string" && ut.name.trim() ? ut.name.trim() : null
+      if (userTierName) {
+        plan = userTierName
+      } else {
+        var ps = data.userStatus.planStatus || {}
+        var pi = ps.planInfo || {}
+        plan =
+          typeof pi.planName === "string" && pi.planName.trim() ? pi.planName.trim() : null
+      }
+    }
+
+    return { plan: plan, lines: lines }
+  }
+
+  function probeLs(ctx) {
+    return probeDiscovery(ctx, discoverLs(ctx))
+  }
+
+  function probeAgyLs(ctx) {
+    return probeDiscovery(ctx, discoverAgyLs(ctx))
+  }
+
+  // --- Probe ---
+
+  function probe(ctx) {
+    var opts = providerSettings(ctx)
+    var explicitDb = !!(opts.userDataDir || opts.ideVariant)
+    if (explicitDb && opts.ideProcessId != null) throw {code: "failed", message: "Select an Antigravity database profile or a process ID, not both."}
+    if (!explicitDb) {
+      var lsResult = probeLs(ctx)
+      if (lsResult) return lsResult
+      if (opts.ideProcessId != null) throw LOGIN_MESSAGE
+    }
+    var dbTokenCandidates = loadOAuthTokenCandidates(ctx)
+    if (explicitDb && !dbTokenCandidates.length) throw LOGIN_MESSAGE
+    if (!dbTokenCandidates.length) {
+      var agyLsResult = probeAgyLs(ctx)
+      if (agyLsResult) return agyLsResult
+    }
+
+    var tokens = []
+    var nowSec = Math.floor(Date.now() / 1000)
+    for (var i = 0; i < dbTokenCandidates.length; i++) {
+      var dbTokens = dbTokenCandidates[i]
+      if (dbTokens.accessToken && (!dbTokens.expirySeconds || dbTokens.expirySeconds > nowSec)) {
+        if (tokens.indexOf(dbTokens.accessToken) === -1) tokens.push(dbTokens.accessToken)
+      }
+    }
+
+    var profileKey = dbTokenCandidates.length ? dbTokenCandidates[0].profileKey : null
+    var cached = loadCachedToken(ctx, profileKey)
+    if (cached && tokens.indexOf(cached) === -1) tokens.push(cached)
+
+    var ccData = null
+    var sawAuthFailure = false
+    for (var i = 0; i < tokens.length; i++) {
+      var nextData = probeCloudCode(ctx, tokens[i])
+      if (nextData && !nextData._authFailed) {
+        ccData = nextData
+        break
+      }
+      if (nextData && nextData._authFailed) sawAuthFailure = true
+    }
+
+    // Only refresh on evidence of an auth failure, or when there were no tokens to try.
+    // probeCloudCode returns null for transient failures (5xx/timeouts); without this
+    // guard a Cloud Code incident would trigger a Google OAuth refresh every probe cycle
+    // instead of ~once per token lifetime - risking refresh-token throttling or rotation.
+    if (!ccData && (sawAuthFailure || tokens.length === 0)) {
+      var refreshTokens = []
+      for (var j = 0; j < dbTokenCandidates.length; j++) {
+        var refreshToken = dbTokenCandidates[j].refreshToken
+        if (refreshToken && refreshTokens.indexOf(refreshToken) === -1) refreshTokens.push(refreshToken)
+      }
+      for (var k = 0; k < refreshTokens.length; k++) {
+        var refreshed = refreshAccessToken(ctx, refreshTokens[k], profileKey)
+        if (!refreshed) continue
+        var refreshedData = probeCloudCode(ctx, refreshed)
+        if (refreshedData && !refreshedData._authFailed) {
+          ccData = refreshedData
+          break
+        }
+        if (refreshedData && refreshedData._authFailed) ccData = refreshedData
+      }
+    }
+
+    if (!dbTokenCandidates.length && (!ccData || ccData._authFailed)) {
+      var agyToken = loadAgyKeychainToken(ctx)
+      if (agyToken) {
+        var agyResult = probeAgyCloudCode(ctx, agyToken)
+        if (agyResult && !agyResult._authFailed) return agyResult
+        if (agyResult && agyResult._authFailed) ccData = agyResult
+      }
+    }
+
+    if (ccData && !ccData._authFailed) {
+      var configs = parseCloudCodeModels(ccData)
+      var lines = buildModelLines(ctx, configs)
+      if (lines.length > 0) return { plan: null, lines: lines }
+    }
+
+    throw LOGIN_MESSAGE
+  }
+
+  globalThis.__openusage_plugin = { id: "antigravity", probe: probe }
+})()