antigravity-auth 1.6.0 → 1.7.0

package/dist/claude/menu-helpers.js

@@ -1,281 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

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