antigravity-auth 1.6.0

package/dist/plugin/image-saver.js

@@ -0,0 +1,78 @@
+/**
+ * Image Saving Utility
+ *
+ * Handles saving generated images to disk and returning file paths.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Default directory for saving generated images.
+ * Uses ~/.opencode/generated-images/
+ */
+function getImageOutputDir() {
+    const homeDir = os.homedir();
+    const outputDir = path.join(homeDir, '.opencode', 'generated-images');
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    return outputDir;
+}
+/**
+ * Generate a unique filename for the image.
+ */
+function generateImageFilename(mimeType) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const random = Math.random().toString(36).substring(2, 8);
+    let ext = 'png';
+    if (mimeType.includes('jpeg') || mimeType.includes('jpg')) {
+        ext = 'jpg';
+    }
+    else if (mimeType.includes('gif')) {
+        ext = 'gif';
+    }
+    else if (mimeType.includes('webp')) {
+        ext = 'webp';
+    }
+    return `image-${timestamp}-${random}.${ext}`;
+}
+/**
+ * Save base64 image data to disk and return the file path.
+ *
+ * @param base64Data - The base64-encoded image data
+ * @param mimeType - The MIME type of the image (e.g., "image/jpeg")
+ * @returns The absolute path to the saved image file
+ */
+export function saveImageToDisk(base64Data, mimeType) {
+    try {
+        const outputDir = getImageOutputDir();
+        const filename = generateImageFilename(mimeType);
+        const filePath = path.join(outputDir, filename);
+        const buffer = Buffer.from(base64Data, 'base64');
+        fs.writeFileSync(filePath, buffer);
+        return filePath;
+    }
+    catch (error) {
+        console.error('[image-saver] Failed to save image:', error);
+        return '';
+    }
+}
+/**
+ * Process inlineData and return either a file path or base64 data URL.
+ * Attempts to save to disk first, falls back to base64 if saving fails.
+ *
+ * @param inlineData - Object containing mimeType and base64 data
+ * @returns Markdown image string with either file path or data URL
+ */
+export function processImageData(inlineData) {
+    const mimeType = inlineData.mimeType || 'image/png';
+    const data = inlineData.data;
+    if (!data) {
+        return null;
+    }
+    const filePath = saveImageToDisk(data, mimeType);
+    if (filePath) {
+        return `![Generated Image](${filePath})\n\nImage saved to: \`${filePath}\`\n\nTo view: \`open "${filePath}"\``;
+    }
+    return `![Generated Image](data:${mimeType};base64,${data})`;
+}

package/dist/plugin/logger.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Structured Logger for Antigravity Plugin
+ *
+ * Logging behavior:
+ * - debug controls file logs only (via debug.ts)
+ * - debug_tui controls TUI log panel only
+ * - either sink can be enabled independently
+ * - OPENCODE_ANTIGRAVITY_CONSOLE_LOG=1 → console output (independent of debug flags)
+ */
+import type { PluginClient } from "./types";
+export interface Logger {
+    debug(message: string, extra?: Record<string, unknown>): void;
+    info(message: string, extra?: Record<string, unknown>): void;
+    warn(message: string, extra?: Record<string, unknown>): void;
+    error(message: string, extra?: Record<string, unknown>): void;
+}
+/**
+ * Initialize the logger with the plugin client.
+ * Must be called during plugin initialization to enable TUI logging.
+ */
+export declare function initLogger(client: PluginClient): void;
+/**
+ * Create a logger instance for a specific module.
+ *
+ * @param module - The module name (e.g., "refresh-queue", "transform.claude")
+ * @returns Logger instance with debug, info, warn, error methods
+ *
+ * @example
+ * ```typescript
+ * const log = createLogger("refresh-queue");
+ * log.debug("Checking tokens", { count: 5 });
+ * log.warn("Token expired", { accountIndex: 0 });
+ * ```
+ */
+export declare function createLogger(module: string): Logger;

package/dist/plugin/logger.js

@@ -0,0 +1,67 @@
+/**
+ * Structured Logger for Antigravity Plugin
+ *
+ * Logging behavior:
+ * - debug controls file logs only (via debug.ts)
+ * - debug_tui controls TUI log panel only
+ * - either sink can be enabled independently
+ * - OPENCODE_ANTIGRAVITY_CONSOLE_LOG=1 → console output (independent of debug flags)
+ */
+import { isDebugTuiEnabled } from "./debug";
+import { isTruthyFlag, writeConsoleLog, } from "./logging-utils";
+const ENV_CONSOLE_LOG = "OPENCODE_ANTIGRAVITY_CONSOLE_LOG";
+let _client = null;
+/**
+ * Check if console logging is enabled via environment variable.
+ */
+function isConsoleLogEnabled() {
+    return isTruthyFlag(process.env[ENV_CONSOLE_LOG]);
+}
+/**
+ * Initialize the logger with the plugin client.
+ * Must be called during plugin initialization to enable TUI logging.
+ */
+export function initLogger(client) {
+    _client = client;
+}
+/**
+ * Create a logger instance for a specific module.
+ *
+ * @param module - The module name (e.g., "refresh-queue", "transform.claude")
+ * @returns Logger instance with debug, info, warn, error methods
+ *
+ * @example
+ * ```typescript
+ * const log = createLogger("refresh-queue");
+ * log.debug("Checking tokens", { count: 5 });
+ * log.warn("Token expired", { accountIndex: 0 });
+ * ```
+ */
+export function createLogger(module) {
+    const service = `antigravity.${module}`;
+    const log = (level, message, extra) => {
+        // TUI logging: controlled only by debug_tui policy
+        if (isDebugTuiEnabled()) {
+            const app = _client?.app;
+            if (app && typeof app.log === "function") {
+                app
+                    .log({
+                    body: { service, level, message, extra },
+                })
+                    .catch(() => {
+                });
+            }
+        }
+        if (isConsoleLogEnabled()) {
+            const prefix = `[${service}]`;
+            const args = extra ? [prefix, message, extra] : [prefix, message];
+            writeConsoleLog(level, ...args);
+        }
+    };
+    return {
+        debug: (message, extra) => log("debug", message, extra),
+        info: (message, extra) => log("info", message, extra),
+        warn: (message, extra) => log("warn", message, extra),
+        error: (message, extra) => log("error", message, extra),
+    };
+}

package/dist/plugin/logging-utils.d.ts

@@ -0,0 +1,22 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface DebugPolicyInput {
+    configDebug: boolean;
+    configDebugTui: boolean;
+    envDebugFlag?: string;
+    envDebugTuiFlag?: string;
+}
+export interface DebugPolicy {
+    debugLevel: number;
+    debugEnabled: boolean;
+    debugTuiEnabled: boolean;
+    verboseEnabled: boolean;
+}
+export declare function isTruthyFlag(flag?: string): boolean;
+export declare function parseDebugLevel(flag: string): number;
+export declare function deriveDebugPolicy(input: DebugPolicyInput): DebugPolicy;
+export declare function formatAccountLabel(email: string | undefined, accountIndex: number): string;
+export declare function formatAccountContextLabel(email: string | undefined, accountIndex: number): string;
+export declare function formatErrorForLog(error: unknown): string;
+export declare function truncateTextForLog(text: string, maxChars: number): string;
+export declare function formatBodyPreviewForLog(body: BodyInit | null | undefined, maxChars: number): string | undefined;
+export declare function writeConsoleLog(level: LogLevel, ...args: unknown[]): void;

package/dist/plugin/logging-utils.js

@@ -0,0 +1,91 @@
+export function isTruthyFlag(flag) {
+    return flag === "1" || flag?.toLowerCase() === "true";
+}
+export function parseDebugLevel(flag) {
+    const trimmed = flag.trim();
+    if (trimmed === "2" || trimmed === "verbose")
+        return 2;
+    if (trimmed === "1" || trimmed === "true")
+        return 1;
+    return 0;
+}
+export function deriveDebugPolicy(input) {
+    const envDebugFlag = input.envDebugFlag ?? "";
+    const debugLevel = input.configDebug
+        ? envDebugFlag === "2" || envDebugFlag === "verbose"
+            ? 2
+            : 1
+        : parseDebugLevel(envDebugFlag);
+    const debugEnabled = debugLevel >= 1;
+    const verboseEnabled = debugLevel >= 2;
+    const debugTuiEnabled = debugEnabled && (input.configDebugTui || isTruthyFlag(input.envDebugTuiFlag));
+    return {
+        debugLevel,
+        debugEnabled,
+        debugTuiEnabled,
+        verboseEnabled,
+    };
+}
+export function formatAccountLabel(email, accountIndex) {
+    return email || `Account ${accountIndex + 1}`;
+}
+export function formatAccountContextLabel(email, accountIndex) {
+    if (email) {
+        return email;
+    }
+    if (accountIndex >= 0) {
+        return `Account ${accountIndex + 1}`;
+    }
+    return "All accounts";
+}
+export function formatErrorForLog(error) {
+    if (error instanceof Error) {
+        return error.stack ?? error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+export function truncateTextForLog(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, maxChars)}... (truncated ${text.length - maxChars} chars)`;
+}
+export function formatBodyPreviewForLog(body, maxChars) {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body === "string") {
+        return truncateTextForLog(body, maxChars);
+    }
+    if (body instanceof URLSearchParams) {
+        return truncateTextForLog(body.toString(), maxChars);
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return `[Blob size=${body.size}]`;
+    }
+    if (typeof FormData !== "undefined" && body instanceof FormData) {
+        return "[FormData payload omitted]";
+    }
+    return `[${body.constructor?.name ?? typeof body} payload omitted]`;
+}
+export function writeConsoleLog(level, ...args) {
+    switch (level) {
+        case "debug":
+            console.debug(...args);
+            break;
+        case "info":
+            console.info(...args);
+            break;
+        case "warn":
+            console.warn(...args);
+            break;
+        case "error":
+            console.error(...args);
+            break;
+    }
+}

package/dist/plugin/project.d.ts

@@ -0,0 +1,32 @@
+import type { OAuthAuthDetails, ProjectContextResult } from "./types";
+interface AntigravityUserTier {
+    id?: string;
+    isDefault?: boolean;
+    userDefinedCloudaicompanionProject?: boolean;
+}
+interface LoadCodeAssistPayload {
+    cloudaicompanionProject?: string | {
+        id?: string;
+    };
+    currentTier?: {
+        id?: string;
+    };
+    allowedTiers?: AntigravityUserTier[];
+}
+/**
+ * Clears cached project context results and pending promises, globally or for a refresh key.
+ */
+export declare function invalidateProjectContextCache(refresh?: string): void;
+/**
+ * Loads managed project information for the given access token and optional project.
+ */
+export declare function loadManagedProject(accessToken: string, projectId?: string): Promise<LoadCodeAssistPayload | null>;
+/**
+ * Onboards a managed project for the user, optionally retrying until completion.
+ */
+export declare function onboardManagedProject(accessToken: string, tierId: string, projectId?: string, attempts?: number, delayMs?: number): Promise<string | undefined>;
+/**
+ * Resolves an effective project ID for the current auth state, caching results per refresh token.
+ */
+export declare function ensureProjectContext(auth: OAuthAuthDetails): Promise<ProjectContextResult>;
+export {};

package/dist/plugin/project.js

@@ -0,0 +1,229 @@
+import { getAntigravityHeaders, ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_LOAD_ENDPOINTS, ANTIGRAVITY_DEFAULT_PROJECT_ID, } from "../constants";
+import { formatRefreshParts, parseRefreshParts } from "./auth";
+import { createLogger } from "./logger";
+const log = createLogger("project");
+const projectContextResultCache = new Map();
+const projectContextPendingCache = new Map();
+const CODE_ASSIST_METADATA = {
+    ideType: "ANTIGRAVITY",
+    platform: process.platform === "win32" ? "WINDOWS" : "MACOS",
+    pluginType: "GEMINI",
+};
+function buildMetadata(projectId) {
+    const metadata = {
+        ideType: CODE_ASSIST_METADATA.ideType,
+        platform: CODE_ASSIST_METADATA.platform,
+        pluginType: CODE_ASSIST_METADATA.pluginType,
+    };
+    if (projectId) {
+        metadata.duetProject = projectId;
+    }
+    return metadata;
+}
+/**
+ * Selects the default tier ID from the allowed tiers list.
+ */
+function getDefaultTierId(allowedTiers) {
+    if (!allowedTiers || allowedTiers.length === 0) {
+        return undefined;
+    }
+    for (const tier of allowedTiers) {
+        if (tier?.isDefault) {
+            return tier.id;
+        }
+    }
+    return allowedTiers[0]?.id;
+}
+/**
+ * Promise-based delay utility.
+ */
+function wait(ms) {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Extracts the cloudaicompanion project id from loadCodeAssist responses.
+ */
+function extractManagedProjectId(payload) {
+    if (!payload) {
+        return undefined;
+    }
+    if (typeof payload.cloudaicompanionProject === "string") {
+        return payload.cloudaicompanionProject;
+    }
+    if (payload.cloudaicompanionProject && typeof payload.cloudaicompanionProject.id === "string") {
+        return payload.cloudaicompanionProject.id;
+    }
+    return undefined;
+}
+/**
+ * Generates a cache key for project context based on refresh token.
+ */
+function getCacheKey(auth) {
+    const refresh = auth.refresh?.trim();
+    return refresh ? refresh : undefined;
+}
+/**
+ * Clears cached project context results and pending promises, globally or for a refresh key.
+ */
+export function invalidateProjectContextCache(refresh) {
+    if (!refresh) {
+        projectContextPendingCache.clear();
+        projectContextResultCache.clear();
+        return;
+    }
+    projectContextPendingCache.delete(refresh);
+    projectContextResultCache.delete(refresh);
+}
+/**
+ * Loads managed project information for the given access token and optional project.
+ */
+export async function loadManagedProject(accessToken, projectId) {
+    const metadata = buildMetadata(projectId);
+    const requestBody = { metadata };
+    const loadHeaders = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "User-Agent": "google-api-nodejs-client/9.15.1",
+        "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+        "Client-Metadata": getAntigravityHeaders()["Client-Metadata"],
+    };
+    const loadEndpoints = Array.from(new Set([...ANTIGRAVITY_LOAD_ENDPOINTS, ...ANTIGRAVITY_ENDPOINT_FALLBACKS]));
+    for (const baseEndpoint of loadEndpoints) {
+        try {
+            const response = await fetch(`${baseEndpoint}/v1internal:loadCodeAssist`, {
+                method: "POST",
+                headers: loadHeaders,
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                continue;
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            log.debug("Failed to load managed project", { endpoint: baseEndpoint, error: String(error) });
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Onboards a managed project for the user, optionally retrying until completion.
+ */
+export async function onboardManagedProject(accessToken, tierId, projectId, attempts = 10, delayMs = 5000) {
+    const metadata = buildMetadata(projectId);
+    const requestBody = {
+        tierId,
+        metadata,
+    };
+    for (const baseEndpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            try {
+                const response = await fetch(`${baseEndpoint}/v1internal:onboardUser`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${accessToken}`,
+                        ...getAntigravityHeaders(),
+                    },
+                    body: JSON.stringify(requestBody),
+                });
+                if (!response.ok) {
+                    break;
+                }
+                const payload = (await response.json());
+                const managedProjectId = payload.response?.cloudaicompanionProject?.id;
+                if (payload.done && managedProjectId) {
+                    return managedProjectId;
+                }
+                if (payload.done && projectId) {
+                    return projectId;
+                }
+            }
+            catch (error) {
+                log.debug("Failed to onboard managed project", { endpoint: baseEndpoint, error: String(error) });
+                break;
+            }
+            await wait(delayMs);
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolves an effective project ID for the current auth state, caching results per refresh token.
+ */
+export async function ensureProjectContext(auth) {
+    const accessToken = auth.access;
+    if (!accessToken) {
+        return { auth, effectiveProjectId: "" };
+    }
+    const cacheKey = getCacheKey(auth);
+    if (cacheKey) {
+        const cached = projectContextResultCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const pending = projectContextPendingCache.get(cacheKey);
+        if (pending) {
+            return pending;
+        }
+    }
+    const resolveContext = async () => {
+        const parts = parseRefreshParts(auth.refresh);
+        if (parts.managedProjectId) {
+            return { auth, effectiveProjectId: parts.managedProjectId };
+        }
+        const fallbackProjectId = ANTIGRAVITY_DEFAULT_PROJECT_ID;
+        const persistManagedProject = async (managedProjectId) => {
+            const updatedAuth = {
+                ...auth,
+                refresh: formatRefreshParts({
+                    refreshToken: parts.refreshToken,
+                    projectId: parts.projectId,
+                    managedProjectId,
+                }),
+            };
+            return { auth: updatedAuth, effectiveProjectId: managedProjectId };
+        };
+        const loadPayload = await loadManagedProject(accessToken, parts.projectId ?? fallbackProjectId);
+        const resolvedManagedProjectId = extractManagedProjectId(loadPayload);
+        if (resolvedManagedProjectId) {
+            return persistManagedProject(resolvedManagedProjectId);
+        }
+        const tierId = getDefaultTierId(loadPayload?.allowedTiers) ?? "FREE";
+        log.debug("Auto-provisioning managed project", { tierId, projectId: parts.projectId });
+        const provisionedProjectId = await onboardManagedProject(accessToken, tierId, parts.projectId);
+        if (provisionedProjectId) {
+            log.debug("Successfully provisioned managed project", { provisionedProjectId });
+            return persistManagedProject(provisionedProjectId);
+        }
+        log.warn("Failed to provision managed project - account may not work correctly", {
+            hasProjectId: !!parts.projectId,
+        });
+        if (parts.projectId) {
+            return { auth, effectiveProjectId: parts.projectId };
+        }
+        return { auth, effectiveProjectId: fallbackProjectId };
+    };
+    if (!cacheKey) {
+        return resolveContext();
+    }
+    const promise = resolveContext()
+        .then((result) => {
+        const nextKey = getCacheKey(result.auth) ?? cacheKey;
+        projectContextPendingCache.delete(cacheKey);
+        projectContextResultCache.set(nextKey, result);
+        if (nextKey !== cacheKey) {
+            projectContextResultCache.delete(cacheKey);
+        }
+        return result;
+    })
+        .catch((error) => {
+        projectContextPendingCache.delete(cacheKey);
+        throw error;
+    });
+    projectContextPendingCache.set(cacheKey, promise);
+    return promise;
+}

package/dist/plugin/quota.d.ts

@@ -0,0 +1,34 @@
+import type { PluginClient } from "./types";
+import type { AccountMetadataV3 } from "./storage";
+export type QuotaGroup = "claude" | "gemini-pro" | "gemini-flash";
+export interface QuotaGroupSummary {
+    remainingFraction?: number;
+    resetTime?: string;
+    modelCount: number;
+}
+export interface QuotaSummary {
+    groups: Partial<Record<QuotaGroup, QuotaGroupSummary>>;
+    modelCount: number;
+    error?: string;
+}
+export interface GeminiCliQuotaModel {
+    modelId: string;
+    remainingFraction: number;
+    resetTime?: string;
+}
+export interface GeminiCliQuotaSummary {
+    models: GeminiCliQuotaModel[];
+    error?: string;
+}
+export type AccountQuotaStatus = "ok" | "disabled" | "error";
+export interface AccountQuotaResult {
+    index: number;
+    email?: string;
+    status: AccountQuotaStatus;
+    error?: string;
+    disabled?: boolean;
+    quota?: QuotaSummary;
+    geminiCliQuota?: GeminiCliQuotaSummary;
+    updatedAccount?: AccountMetadataV3;
+}
+export declare function checkAccountsQuota(accounts: AccountMetadataV3[], client: PluginClient, providerId?: string): Promise<AccountQuotaResult[]>;