@benjamolina/pi-antigravity-guard 0.1.0

package/dist/oauth.js

@@ -0,0 +1,175 @@
+import { createHash, randomBytes } from "node:crypto";
+import { ANTIGRAVITY_OAUTH_CLIENT, buildAuthorizationUrl } from "@benjamolina/antigravity-guard-core";
+import { exchangeAuthorizationCode, refreshCredentials } from "./auth-http.js";
+import { openLoopbackReceiver, validateLoopbackCallback } from "./loopback.js";
+import { defaultProjectId, resolveLoginProject } from "./project.js";
+const ATTEMPT_TIMEOUT_MS = 5 * 60_000;
+const PI_OAUTH_CLIENT = {
+    ...ANTIGRAVITY_OAUTH_CLIENT,
+    scopes: [...ANTIGRAVITY_OAUTH_CLIENT.scopes, "https://www.googleapis.com/auth/aicode"],
+};
+const trustedErrors = new WeakSet();
+export function createPiOAuthLifecycle(dependencies) {
+    const bytes = dependencies.randomBytes ?? randomBytes;
+    const exchange = dependencies.exchange ?? exchangeAuthorizationCode;
+    const refresh = dependencies.refresh ?? refreshCredentials;
+    const project = dependencies.project ?? resolveLoginProject;
+    const openLoopback = dependencies.openLoopback ?? openLoopbackReceiver;
+    let active = false;
+    return {
+        async login(callbacks) {
+            if (active)
+                throw new Error("An Antigravity login is already in progress.");
+            active = true;
+            let receiver;
+            let signal;
+            try {
+                const deadline = dependencies.now() + ATTEMPT_TIMEOUT_MS;
+                signal = composedSignal(callbacks.signal, ATTEMPT_TIMEOUT_MS);
+                const state = base64Url(bytes(32));
+                const verifier = base64Url(bytes(32));
+                const challenge = base64Url(createHash("sha256").update(verifier).digest());
+                const authorizationUrl = buildAuthorizationUrl(PI_OAUTH_CLIENT, { challenge, state });
+                const method = await abortable(() => callbacks.onSelect({
+                    message: "Choose how to complete Antigravity login.",
+                    options: [
+                        { id: "browser", label: "Open browser and wait for callback" },
+                        { id: "manual", label: "Paste the full callback URL" },
+                    ],
+                }), signal);
+                if (!method)
+                    throw cancelled();
+                if (method === "browser") {
+                    const opened = await untrusted(() => openLoopback({ state, signal, totalDeadlineMs: deadline - dependencies.now() }), "Antigravity login failed.");
+                    receiver = opened;
+                    await abortable(() => untrusted(() => opened.ready, "Antigravity login failed."), signal);
+                }
+                else if (method !== "manual") {
+                    throw cancelled();
+                }
+                callbacks.onAuth({ url: authorizationUrl });
+                const code = receiver ? await codeFromLoopback(receiver, callbacks, signal, state) : await codeFromPrompt(callbacks, signal, state);
+                const credentials = await abortable(() => untrusted(() => exchange({
+                    code, verifier, fetch: dependencies.fetch, now: dependencies.now, signal, deadlineMs: deadline,
+                }), "Antigravity token exchange failed after authorization."), signal);
+                const discovery = await abortable(() => Promise.resolve(project({ accessToken: credentials.access, fetch: dependencies.fetch, now: dependencies.now, platform: process.platform, signal, deadlineMs: deadline })).catch(() => ({})), signal);
+                return piCredentials(credentials, discovery);
+            }
+            catch (error) {
+                if (trusted(error))
+                    throw error;
+                if (signal?.aborted)
+                    throw cancelled();
+                throw new OAuthLifecycleError("Antigravity login failed.");
+            }
+            finally {
+                try {
+                    void Promise.resolve(receiver?.cancel()).catch(() => undefined);
+                }
+                catch { }
+                active = false;
+            }
+        },
+        async refreshToken(credentials, signal) {
+            try {
+                const refreshed = await abortable(() => untrusted(() => refresh({ credentials: credentialsFrom(credentials), fetch: dependencies.fetch, now: dependencies.now, signal }), "Antigravity credential refresh failed."), signal);
+                return piCredentials(refreshed, credentialProject(credentials));
+            }
+            catch (error) {
+                if (trusted(error))
+                    throw error;
+                if (signal.aborted)
+                    throw cancelled();
+                throw new OAuthLifecycleError("Antigravity credential refresh failed.");
+            }
+        },
+        getApiKey(credentials) {
+            const project = credentialProject(credentials);
+            return JSON.stringify({ token: credentials.access, projectId: project.projectId ?? defaultProjectId(project.email ?? "antigravity-default") });
+        },
+    };
+}
+async function codeFromLoopback(receiver, callbacks, signal, state) {
+    const result = await abortable(() => untrusted(() => receiver.result, "Antigravity login failed."), signal);
+    if (result.kind === "callback")
+        return result.code;
+    if (result.kind === "manual")
+        return codeFromPrompt(callbacks, signal, state);
+    if (result.kind === "denied")
+        throw new OAuthLifecycleError("Antigravity authorization was denied.");
+    throw cancelled();
+}
+async function codeFromPrompt(callbacks, signal, state) {
+    let input;
+    try {
+        input = await abortable(() => callbacks.onPrompt({ message: "Paste the full callback URL." }), signal);
+    }
+    catch {
+        throw cancelled();
+    }
+    if (!input.trim())
+        throw cancelled();
+    return codeFromManualCallback(input, state);
+}
+function codeFromManualCallback(input, state) {
+    let result;
+    try {
+        const url = new URL(input);
+        if (url.origin !== "http://localhost:51121" || url.pathname !== "/oauth-callback" || url.username || url.password || url.hash)
+            throw new Error();
+        result = validateLoopbackCallback({ method: "GET", host: "localhost:51121", remoteAddress: "127.0.0.1", url: `${url.pathname}${url.search}` }, state);
+    }
+    catch {
+        throw new OAuthLifecycleError("Paste the full callback URL from Antigravity login.");
+    }
+    if (result.kind === "callback")
+        return result.code;
+    if (result.kind === "denied")
+        throw new OAuthLifecycleError("Antigravity authorization was denied.");
+    throw new OAuthLifecycleError("Paste the full callback URL from Antigravity login.");
+}
+function credentialsFrom(credentials) {
+    return credentials;
+}
+function credentialProject(credentials) {
+    const values = credentials;
+    return {
+        ...(nonempty(values.projectId) ? { projectId: values.projectId } : {}),
+        ...(nonempty(values.email) ? { email: values.email } : {}),
+    };
+}
+function piCredentials(credentials, discovered = {}) {
+    const email = nonempty(discovered.email) ? discovered.email : undefined;
+    const projectId = nonempty(discovered.projectId) ? discovered.projectId : defaultProjectId(email ?? "antigravity-default");
+    return { refresh: credentials.refresh, access: credentials.access, expires: credentials.expires, projectId, ...(email ? { email } : {}) };
+}
+function untrusted(operation, message) {
+    return Promise.resolve().then(operation).catch(() => { throw new OAuthLifecycleError(message); });
+}
+function composedSignal(signal, timeoutMs) {
+    return signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+}
+function abortable(operation, signal) {
+    if (signal.aborted)
+        return Promise.reject(cancelled());
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(cancelled());
+        signal.addEventListener("abort", abort, { once: true });
+        operation().then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    });
+}
+function base64Url(value) {
+    return Buffer.from(value).toString("base64url");
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function cancelled() {
+    return new OAuthLifecycleError("Antigravity login was cancelled.");
+}
+function trusted(error) {
+    return error instanceof OAuthLifecycleError && trustedErrors.delete(error);
+}
+class OAuthLifecycleError extends Error {
+    constructor(message) { super(message); trustedErrors.add(this); }
+}

package/dist/project.d.ts

@@ -0,0 +1,14 @@
+export interface LoginProjectOptions {
+    accessToken: string;
+    fetch: typeof globalThis.fetch;
+    now: () => number;
+    platform: string;
+    signal?: AbortSignal;
+    deadlineMs?: number;
+}
+export interface LoginProject {
+    email?: string;
+    projectId?: string;
+}
+export declare function resolveLoginProject(options: LoginProjectOptions): Promise<LoginProject>;
+export declare function defaultProjectId(seed: string): string;

package/dist/project.js

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+const USER_INFO_ENDPOINT = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json";
+const PROJECT_ENDPOINTS = [
+    "https://daily-cloudcode-pa.googleapis.com",
+    "https://daily-cloudcode-pa.sandbox.googleapis.com",
+    "https://cloudcode-pa.googleapis.com",
+];
+const MAX_BODY_BYTES = 64 * 1024;
+const REQUEST_TIMEOUT_MS = 10_000;
+const ANTIGRAVITY_USER_AGENT = "antigravity/cli/1.1.23 (aidev_client; os_type=linux; arch=amd64; cl=974125021; auth_method=consumer)";
+export async function resolveLoginProject(options) {
+    const email = await userEmail(options);
+    const projectId = await discoveredProject(options);
+    return { ...(email ? { email } : {}), ...(projectId ? { projectId } : {}) };
+}
+export function defaultProjectId(seed) {
+    const bytes = createHash("sha1").update(`antigravity:${seed}`).digest().subarray(0, 16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+async function userEmail(options) {
+    const { payload } = await bestEffort(options, USER_INFO_ENDPOINT, {
+        method: "GET",
+        redirect: "error",
+        headers: { Authorization: `Bearer ${options.accessToken}` },
+    });
+    return isRecord(payload) && nonempty(payload.email) ? payload.email : undefined;
+}
+async function discoveredProject(options) {
+    const request = {
+        method: "POST",
+        redirect: "error",
+        headers: {
+            Authorization: `Bearer ${options.accessToken}`,
+            "Content-Type": "application/json",
+            "User-Agent": ANTIGRAVITY_USER_AGENT,
+        },
+        body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } }),
+    };
+    for (const origin of PROJECT_ENDPOINTS) {
+        const response = await bestEffort(options, `${origin}/v1internal:loadCodeAssist`, request);
+        if (!response.ok)
+            continue;
+        const projectId = projectFrom(response.payload);
+        return projectId ?? listProject(options, request);
+    }
+    return undefined;
+}
+async function listProject(options, request) {
+    const listRequest = { ...request, body: "{}" };
+    for (const origin of PROJECT_ENDPOINTS) {
+        const { payload } = await bestEffort(options, `${origin}/v1internal:listCloudAICompanionProjects`, listRequest);
+        const projectId = projectFrom(payload);
+        if (projectId)
+            return projectId;
+    }
+    return undefined;
+}
+async function bestEffort(options, endpoint, request) {
+    const timeout = options.deadlineMs === undefined
+        ? REQUEST_TIMEOUT_MS
+        : Math.min(REQUEST_TIMEOUT_MS, options.deadlineMs - options.now());
+    if (timeout <= 0 || options.signal?.aborted)
+        return { ok: false };
+    const signal = options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(timeout)]) : AbortSignal.timeout(timeout);
+    let response;
+    try {
+        response = await options.fetch(endpoint, { ...request, signal });
+    }
+    catch {
+        return { ok: false };
+    }
+    if (!response?.ok)
+        return { ok: false };
+    try {
+        const body = await boundedBody(response.body, signal);
+        return body === undefined ? { ok: true } : { ok: true, payload: JSON.parse(body) };
+    }
+    catch {
+        return { ok: true };
+    }
+}
+async function boundedBody(body, signal) {
+    if (!body)
+        return undefined;
+    const reader = body.getReader();
+    const chunks = [];
+    let size = 0;
+    let complete = false;
+    try {
+        while (true) {
+            const next = await abortable(reader.read(), signal);
+            if (next.done) {
+                complete = true;
+                const output = new Uint8Array(size);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    output.set(chunk, offset);
+                    offset += chunk.byteLength;
+                }
+                return new TextDecoder().decode(output);
+            }
+            size += next.value.byteLength;
+            if (size > MAX_BODY_BYTES)
+                return undefined;
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        if (!complete)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+function abortable(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(new Error("aborted"));
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(new Error("aborted"));
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    });
+}
+function projectFrom(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const projectId = projectFrom(entry);
+            if (projectId)
+                return projectId;
+        }
+        return undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    const project = value.cloudaicompanionProject;
+    if (nonempty(project))
+        return project;
+    if (isRecord(project) && nonempty(project.id))
+        return project.id;
+    for (const entry of Object.values(value)) {
+        const projectId = projectFrom(entry);
+        if (projectId)
+            return projectId;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/provider.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare function registerAntigravityProvider(pi: Pick<ExtensionAPI, "registerProvider">): void;
+export declare function parseProviderApiKey(value: string): {
+    token: string;
+    projectId: string;
+};

package/dist/provider.js

@@ -0,0 +1,83 @@
+import { ANTIGRAVITY_ENDPOINTS } from "@benjamolina/antigravity-guard-core";
+import { createPiOAuthLifecycle } from "./oauth.js";
+import { createPiLifecycleStream, executeStreamTransport } from "./stream.js";
+const PROVIDER = "antigravity-guard";
+const API = "antigravity-guard-sse";
+const MODEL = "antigravity-gemini-3.8-flash";
+const INVALID_CREDENTIALS = "Antigravity credentials are invalid. Run /login antigravity-guard.";
+export function registerAntigravityProvider(pi) {
+    const oauth = createPiOAuthLifecycle({ fetch: globalThis.fetch, now: Date.now });
+    pi.registerProvider(PROVIDER, {
+        name: "Antigravity Guard",
+        baseUrl: ANTIGRAVITY_ENDPOINTS.daily,
+        api: API,
+        models: [{
+                id: MODEL,
+                name: "Gemini 3.8 Flash (Antigravity, text only)",
+                reasoning: false,
+                input: ["text"],
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                contextWindow: 1_048_576,
+                maxTokens: 65_536,
+            }],
+        oauth: {
+            name: "Antigravity Guard",
+            isSubscription: true,
+            login: oauth.login,
+            refreshToken: oauth.refreshToken,
+            getApiKey: oauth.getApiKey,
+        },
+        streamSimple(model, context, options) {
+            return streamText(model, context, options);
+        },
+    });
+}
+export function parseProviderApiKey(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(INVALID_CREDENTIALS);
+    }
+    if (!isRecord(parsed) || Object.keys(parsed).length !== 2 || !nonempty(parsed.token) || !nonempty(parsed.projectId)) {
+        throw new Error(INVALID_CREDENTIALS);
+    }
+    return { token: parsed.token, projectId: parsed.projectId };
+}
+function streamText(model, context, options) {
+    return createPiLifecycleStream({
+        model,
+        now: Date.now,
+        signal: options?.signal,
+        runTransport: ({ onSemantic, signal }) => {
+            const credentials = parseProviderApiKey(options?.apiKey ?? "");
+            return executeStreamTransport({
+                accessToken: credentials.token,
+                projectId: credentials.projectId,
+                context,
+                fetch: options?.fetch ?? globalThis.fetch,
+                generationOptions: options,
+                headers: safeHeaders(options?.headers),
+                model,
+                now: Date.now,
+                onSemantic,
+                platform: process.platform,
+                requestId: `agent-${crypto.randomUUID()}`,
+                signal,
+                timeoutMs: options?.timeoutMs,
+            });
+        },
+    });
+}
+function safeHeaders(headers) {
+    if (!headers)
+        return undefined;
+    return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/response.d.ts

@@ -0,0 +1,30 @@
+export type ResponseSemantic = TextSemantic | FinishSemantic | UsageSemantic;
+export interface TextSemantic {
+    type: "text";
+    text: string;
+}
+export interface FinishSemantic {
+    type: "finish";
+    reason: "stop" | "length";
+}
+export interface UsageSemantic {
+    type: "usage";
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: 0;
+    total: number;
+}
+export declare class ResponseSemanticError extends Error {
+}
+export declare class ResponseSemantics {
+    private finished;
+    private text;
+    private done;
+    private usage;
+    push(record: string): ResponseSemantic[];
+    finish(): void;
+    addText(text: string): void;
+    addFinish(): void;
+    private updateUsage;
+}

package/dist/response.js

@@ -0,0 +1,113 @@
+export class ResponseSemanticError extends Error {
+}
+export class ResponseSemantics {
+    finished = false;
+    text = false;
+    done = false;
+    usage = { prompt: 0, cacheRead: 0, output: 0 };
+    push(record) {
+        if (this.done)
+            throw new ResponseSemanticError("Response data arrived after [DONE].");
+        if (record === "[DONE]") {
+            if (!this.finished)
+                throw new ResponseSemanticError("[DONE] arrived before a finish reason.");
+            this.done = true;
+            return [];
+        }
+        if (this.finished)
+            throw new ResponseSemanticError("Response data arrived after a finish reason.");
+        const value = parse(record);
+        if (hasError(value))
+            throw new ResponseSemanticError("Antigravity returned an error response.");
+        const response = field(value, "response");
+        if (hasError(response) || field(response, "promptFeedback") !== undefined)
+            throw new ResponseSemanticError("Antigravity returned an invalid response.");
+        validateMetadata(response);
+        const events = [];
+        const candidates = field(response, "candidates");
+        if (candidates !== undefined)
+            candidate(candidates, events, this);
+        const usage = field(response, "usageMetadata");
+        if (usage !== undefined)
+            events.push(this.updateUsage(usage));
+        return events;
+    }
+    finish() {
+        if (!this.finished)
+            throw new ResponseSemanticError("Response ended without a finish reason.");
+        if (!this.text)
+            throw new ResponseSemanticError("Response ended without text.");
+    }
+    addText(text) { this.text = this.text || text.length > 0; }
+    addFinish() { this.finished = true; }
+    updateUsage(value) {
+        const prompt = count(value, "promptTokenCount", this.usage.prompt);
+        const cacheRead = count(value, "cachedContentTokenCount", this.usage.cacheRead);
+        const output = count(value, "candidatesTokenCount", this.usage.output) + count(value, "thoughtsTokenCount", 0);
+        const reported = field(value, "totalTokenCount");
+        if (cacheRead > prompt || (reported !== undefined && reported !== prompt + output))
+            throw new ResponseSemanticError("Antigravity returned invalid usage.");
+        this.usage = { prompt, cacheRead, output };
+        return { type: "usage", input: prompt - cacheRead, output, cacheRead, cacheWrite: 0, total: prompt + output };
+    }
+}
+function candidate(value, events, semantics) {
+    if (!Array.isArray(value) || value.length !== 1)
+        throw new ResponseSemanticError("Antigravity returned invalid candidates.");
+    const candidate = value[0];
+    if (candidate === undefined)
+        return;
+    const index = field(candidate, "index");
+    if (index !== undefined && index !== 0)
+        throw new ResponseSemanticError("Antigravity returned invalid candidates.");
+    const content = field(candidate, "content");
+    if (content !== undefined) {
+        const parts = field(content, "parts");
+        if (!Array.isArray(parts))
+            throw new ResponseSemanticError("Antigravity returned invalid content.");
+        for (const part of parts) {
+            const text = field(part, "text");
+            if (typeof text !== "string" || Object.keys(part).some((name) => name !== "text" && name !== "thoughtSignature"))
+                throw new ResponseSemanticError("Antigravity returned unsupported content.");
+            semantics.addText(text);
+            events.push({ type: "text", text });
+        }
+    }
+    const finishReason = field(candidate, "finishReason");
+    if (finishReason !== undefined) {
+        if (finishReason !== "STOP" && finishReason !== "MAX_TOKENS")
+            throw new ResponseSemanticError("Antigravity returned an unsupported finish reason.");
+        semantics.addFinish();
+        events.push({ type: "finish", reason: finishReason === "STOP" ? "stop" : "length" });
+    }
+}
+function validateMetadata(value) {
+    for (const name of ["responseId", "modelVersion"]) {
+        const metadata = field(value, name);
+        if (metadata !== undefined && (typeof metadata !== "string" || !metadata))
+            throw new ResponseSemanticError("Antigravity returned invalid metadata.");
+    }
+}
+function count(value, name, fallback) {
+    const valueAtName = field(value, name);
+    if (valueAtName === undefined)
+        return fallback;
+    if (typeof valueAtName !== "number" || !Number.isSafeInteger(valueAtName) || valueAtName < 0)
+        throw new ResponseSemanticError("Antigravity returned invalid usage.");
+    return valueAtName;
+}
+function parse(record) {
+    try {
+        return JSON.parse(record);
+    }
+    catch {
+        throw new ResponseSemanticError("Antigravity returned invalid JSON.");
+    }
+}
+function hasError(value) { return field(value, "error") !== undefined; }
+function field(value, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new ResponseSemanticError("Antigravity returned an invalid response.");
+    const descriptor = Object.getOwnPropertyDescriptor(value, name);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}

package/dist/sse.d.ts

@@ -0,0 +1,16 @@
+export declare class SseFrameError extends Error {
+}
+export declare class SseFramer {
+    private decoder;
+    private data;
+    private line;
+    private recordBytes;
+    private carriageReturn;
+    private bom;
+    push(bytes: Uint8Array): string[];
+    finish(): string[];
+    private append;
+    private flush;
+    private count;
+    private endLine;
+}