antigravity-auth 1.6.0

package/dist/claude/menu-helpers.js

@@ -0,0 +1,281 @@
+import { getAntigravityHeaders, ANTIGRAVITY_ENDPOINT_PROD, ANTIGRAVITY_DEFAULT_PROJECT_ID } from "../src/constants";
+import { parseRefreshParts, formatRefreshParts } from "../src/plugin/auth";
+import { refreshAccessToken, AntigravityTokenRefreshError } from "../src/plugin/token";
+// --- Inlined helpers (from opencode-antigravity-auth/src/plugin.ts, not in core submodule) ---
+function decodeEscapedText(input) {
+    return input
+        .replace(/&/g, "&")
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+function normalizeGoogleVerificationUrl(rawUrl) {
+    const normalized = decodeEscapedText(rawUrl).trim();
+    if (!normalized)
+        return undefined;
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.hostname !== "accounts.google.com")
+            return undefined;
+        return parsed.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function selectBestVerificationUrl(urls) {
+    const unique = Array.from(new Set(urls.map((url) => normalizeGoogleVerificationUrl(url)).filter(Boolean)));
+    if (unique.length === 0)
+        return undefined;
+    unique.sort((a, b) => {
+        const score = (value) => {
+            let total = 0;
+            if (value.includes("plt="))
+                total += 4;
+            if (value.includes("/signin/continue"))
+                total += 3;
+            if (value.includes("continue="))
+                total += 2;
+            if (value.includes("service=cloudcode"))
+                total += 1;
+            return total;
+        };
+        return score(b) - score(a);
+    });
+    return unique[0];
+}
+function extractVerificationErrorDetails(bodyText) {
+    const decodedBody = decodeEscapedText(bodyText);
+    const lowerBody = decodedBody.toLowerCase();
+    let validationRequired = lowerBody.includes("validation_required");
+    let message;
+    const verificationUrls = new Set();
+    const collectUrlsFromText = (text) => {
+        for (const match of text.matchAll(/https:\/\/accounts\.google\.com\/[^\s"'<>]+/gi)) {
+            if (match[0])
+                verificationUrls.add(match[0]);
+        }
+    };
+    collectUrlsFromText(decodedBody);
+    const payloads = [];
+    const trimmed = decodedBody.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            payloads.push(JSON.parse(trimmed));
+        }
+        catch { }
+    }
+    for (const rawLine of decodedBody.split("\n")) {
+        const line = rawLine.trim();
+        if (!line.startsWith("data:"))
+            continue;
+        const payloadText = line.slice(5).trim();
+        if (!payloadText || payloadText === "[DONE]")
+            continue;
+        try {
+            payloads.push(JSON.parse(payloadText));
+        }
+        catch {
+            collectUrlsFromText(payloadText);
+        }
+    }
+    const visited = new Set();
+    const walk = (value, key) => {
+        if (typeof value === "string") {
+            const normalizedValue = decodeEscapedText(value);
+            const lowerValue = normalizedValue.toLowerCase();
+            const lowerKey = key?.toLowerCase() ?? "";
+            if (lowerValue.includes("validation_required"))
+                validationRequired = true;
+            if (!message && (lowerKey.includes("message") || lowerKey.includes("detail") || lowerKey.includes("description"))) {
+                message = normalizedValue;
+            }
+            if (lowerKey.includes("validation_url") || lowerKey.includes("verify_url") || lowerKey.includes("verification_url") || lowerKey === "url") {
+                verificationUrls.add(normalizedValue);
+            }
+            collectUrlsFromText(normalizedValue);
+            return;
+        }
+        if (!value || typeof value !== "object" || visited.has(value))
+            return;
+        visited.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item);
+            return;
+        }
+        for (const [childKey, childValue] of Object.entries(value)) {
+            walk(childValue, childKey);
+        }
+    };
+    for (const payload of payloads)
+        walk(payload);
+    if (!validationRequired) {
+        validationRequired =
+            lowerBody.includes("verification required") ||
+                lowerBody.includes("verify your account") ||
+                lowerBody.includes("account verification");
+    }
+    if (!message) {
+        const fallback = decodedBody
+            .split("\n")
+            .map((line) => line.trim())
+            .find((line) => line && !line.startsWith("data:") && /(verify|validation|required)/i.test(line));
+        if (fallback)
+            message = fallback;
+    }
+    return {
+        validationRequired,
+        message,
+        verifyUrl: selectBestVerificationUrl([...verificationUrls]),
+    };
+}
+export async function verifyAccountAccess(account, client, providerId) {
+    const parsed = parseRefreshParts(account.refreshToken);
+    if (!parsed.refreshToken) {
+        return { status: "error", message: "Missing refresh token for selected account." };
+    }
+    const auth = {
+        type: "oauth",
+        refresh: formatRefreshParts({
+            refreshToken: parsed.refreshToken,
+            projectId: parsed.projectId ?? account.projectId,
+            managedProjectId: parsed.managedProjectId ?? account.managedProjectId,
+        }),
+        access: "",
+        expires: 0,
+    };
+    let refreshedAuth;
+    try {
+        refreshedAuth = await refreshAccessToken(auth, client, providerId);
+    }
+    catch (error) {
+        if (error instanceof AntigravityTokenRefreshError) {
+            return { status: "error", message: error.message };
+        }
+        return { status: "error", message: `Token refresh failed: ${String(error)}` };
+    }
+    if (!refreshedAuth?.access) {
+        return { status: "error", message: "Could not refresh access token for this account." };
+    }
+    const projectId = parsed.managedProjectId ??
+        parsed.projectId ??
+        account.managedProjectId ??
+        account.projectId ??
+        ANTIGRAVITY_DEFAULT_PROJECT_ID;
+    const headers = {
+        ...getAntigravityHeaders(),
+        Authorization: `Bearer ${refreshedAuth.access}`,
+        "Content-Type": "application/json",
+    };
+    if (projectId) {
+        headers["x-goog-user-project"] = projectId;
+    }
+    const requestBody = {
+        model: "gemini-3-flash",
+        request: {
+            model: "gemini-3-flash",
+            contents: [{ role: "user", parts: [{ text: "ping" }] }],
+            generationConfig: { maxOutputTokens: 1, temperature: 0 },
+        },
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 20000);
+    let response;
+    try {
+        response = await fetch(`${ANTIGRAVITY_ENDPOINT_PROD}/v1internal:streamGenerateContent?alt=sse`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(requestBody),
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return { status: "error", message: "Verification check timed out." };
+        }
+        return { status: "error", message: `Verification check failed: ${String(error)}` };
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+    let responseBody = "";
+    try {
+        responseBody = await response.text();
+    }
+    catch {
+        responseBody = "";
+    }
+    if (response.ok) {
+        return { status: "ok", message: "Account verification check passed." };
+    }
+    const extracted = extractVerificationErrorDetails(responseBody);
+    if (response.status === 403 && extracted.validationRequired) {
+        return {
+            status: "blocked",
+            message: extracted.message ?? "Google requires additional account verification.",
+            verifyUrl: extracted.verifyUrl,
+        };
+    }
+    const fallbackMessage = extracted.message ?? `Request failed (${response.status} ${response.statusText}).`;
+    return {
+        status: "error",
+        message: fallbackMessage,
+    };
+}
+export async function promptAccountIndexForVerification(accounts) {
+    const { createInterface } = await import("node:readline/promises");
+    const { stdin, stdout } = await import("node:process");
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        console.log("\nSelect an account to verify:");
+        for (const account of accounts) {
+            const label = account.email || `Account ${account.index + 1}`;
+            console.log(`  ${account.index + 1}. ${label}`);
+        }
+        console.log("");
+        while (true) {
+            const answer = (await rl.question("Account number (leave blank to cancel): ")).trim();
+            if (!answer) {
+                return undefined;
+            }
+            const parsedIndex = Number(answer);
+            if (!Number.isInteger(parsedIndex)) {
+                console.log("Please enter a valid account number.");
+                continue;
+            }
+            const normalizedIndex = parsedIndex - 1;
+            const selected = accounts.find((account) => account.index === normalizedIndex);
+            if (!selected) {
+                console.log("Please enter a number from the list above.");
+                continue;
+            }
+            return selected.index;
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export function markStoredAccountVerificationRequired(account, message, verifyUrl) {
+    if (account.verificationRequired && account.verificationMessage === message && account.verificationUrl === verifyUrl) {
+        return false;
+    }
+    account.verificationRequired = true;
+    account.verificationMessage = message;
+    account.verificationUrl = verifyUrl;
+    return true;
+}
+export function clearStoredAccountVerificationRequired(account, reEnable = false) {
+    const wasVerificationRequired = !!account.verificationRequired;
+    let changed = false;
+    if (account.verificationRequired) {
+        delete account.verificationRequired;
+        delete account.verificationMessage;
+        delete account.verificationUrl;
+        changed = true;
+    }
+    if (reEnable && account.enabled === false && wasVerificationRequired) {
+        delete account.enabled;
+        changed = true;
+    }
+    return { changed, wasVerificationRequired };
+}

package/dist/claude/proxy-manager.d.ts

@@ -0,0 +1,11 @@
+export interface ProxyInfo {
+    url: string;
+    provider: string;
+    weight: number;
+    latency?: number;
+    failures: number;
+    lastTested?: number;
+}
+export declare function loadHotPool(): ProxyInfo[];
+export declare function saveHotPool(pool: ProxyInfo[]): void;
+export declare function runDaemon(): Promise<void>;

package/dist/claude/proxy-manager.js

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadProxyConfig } from '../src/plugin/proxy-config';
+const HOT_POOL_FILE = path.join(os.homedir(), '.claude', 'cache', 'proxy-hot-pool.json');
+const TARGET_POOL_SIZE = 10;
+const TEST_URL = 'https://google.com';
+export function loadHotPool() {
+    try {
+        if (fs.existsSync(HOT_POOL_FILE)) {
+            return JSON.parse(fs.readFileSync(HOT_POOL_FILE, 'utf8'));
+        }
+    }
+    catch (e) {
+        console.error('Failed to load hot pool', e);
+    }
+    return [];
+}
+export function saveHotPool(pool) {
+    const dir = path.dirname(HOT_POOL_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(HOT_POOL_FILE, JSON.stringify(pool, null, 2));
+}
+async function checkHealth(proxyUrl) {
+    const start = Date.now();
+    try {
+        const res = await fetch(TEST_URL, {
+            method: 'HEAD',
+            // @ts-ignore - bun specific extension
+            proxy: proxyUrl,
+            signal: AbortSignal.timeout(5000)
+        });
+        if (res.ok || res.status < 400) {
+            return Date.now() - start;
+        }
+    }
+    catch (e) {
+    }
+    return null;
+}
+async function fetchProxyScrape(config) {
+    if (!config.enabled)
+        return [];
+    try {
+        const res = await fetch('https://api.proxyscrape.com/v2/?request=displayproxies&protocol=http&timeout=5000&country=all&ssl=all&anonymity=all');
+        const text = await res.text();
+        return text.split('\n').map(p => p.trim()).filter(p => p).map(p => ({
+            url: `http://${p}`, provider: 'proxyscrape', weight: config.weight || 1, failures: 0
+        }));
+    }
+    catch (e) {
+        return [];
+    }
+}
+async function fetchWebshare(config) { return []; }
+async function fetchBrightData(config) { return []; }
+async function fetchOxylabs(config) { return []; }
+async function fetchProxifly(config) { return []; }
+async function fetchGeonix(config) { return []; }
+async function fetchLitport(config) { return []; }
+async function fetchIPLocate(config) { return []; }
+export async function runDaemon() {
+    console.log('Starting Antigravity Proxy Manager Daemon...');
+    setInterval(async () => {
+        const config = loadProxyConfig();
+        if (config.strategy !== 'automatic')
+            return;
+        let pool = loadHotPool();
+        // 1. Prune dead proxies (failures > 3)
+        pool = pool.filter(p => p.failures < 3);
+        // 2. Health check existing
+        for (const proxy of pool) {
+            const latency = await checkHealth(proxy.url);
+            proxy.lastTested = Date.now();
+            if (latency === null) {
+                proxy.failures++;
+            }
+            else {
+                proxy.latency = latency;
+                proxy.failures = 0; // reset
+            }
+        }
+        pool = pool.filter(p => p.failures < 3);
+        // 3. Replenish if needed
+        if (pool.length < TARGET_POOL_SIZE) {
+            let newProxies = [];
+            if (config.providers.webshare?.enabled)
+                newProxies.push(...await fetchWebshare(config.providers.webshare));
+            if (config.providers.proxyscrape?.enabled)
+                newProxies.push(...await fetchProxyScrape(config.providers.proxyscrape));
+            if (config.providers.brightdata?.enabled)
+                newProxies.push(...await fetchBrightData(config.providers.brightdata));
+            if (config.providers.oxylabs?.enabled)
+                newProxies.push(...await fetchOxylabs(config.providers.oxylabs));
+            if (config.providers.proxifly?.enabled)
+                newProxies.push(...await fetchProxifly(config.providers.proxifly));
+            if (config.providers.geonix?.enabled)
+                newProxies.push(...await fetchGeonix(config.providers.geonix));
+            if (config.providers.litport?.enabled)
+                newProxies.push(...await fetchLitport(config.providers.litport));
+            if (config.providers.iplocate?.enabled)
+                newProxies.push(...await fetchIPLocate(config.providers.iplocate));
+            newProxies = newProxies.sort(() => Math.random() - 0.5);
+            for (const np of newProxies) {
+                if (pool.length >= TARGET_POOL_SIZE)
+                    break;
+                if (!pool.find(p => p.url === np.url)) {
+                    const latency = await checkHealth(np.url);
+                    if (latency !== null) {
+                        np.latency = latency;
+                        np.lastTested = Date.now();
+                        pool.push(np);
+                    }
+                }
+            }
+        }
+        // 4. Sort pool by latency relative to provider weight (lower is better)
+        pool.sort((a, b) => {
+            const scoreA = (a.latency || 9999) / a.weight;
+            const scoreB = (b.latency || 9999) / b.weight;
+            return scoreA - scoreB;
+        });
+        saveHotPool(pool);
+    }, 60000);
+}
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1].endsWith('proxy-manager.ts')) {
+    runDaemon();
+}

package/dist/claude/proxy.d.ts

@@ -0,0 +1 @@
+export {};