@xkei/openclaude 0.30.0-antigravity

package/vendor/openclaude-antigravity-provider/src/server.ts

@@ -0,0 +1,367 @@
+/**
+ * server.ts
+ * OpenAI-compatible local proxy using Bun.serve().
+ * Endpoint: http://localhost:51122/v1/chat/completions
+ *
+ * Run:  bun run src/server.ts
+ */
+
+import {
+  PROXY_PORT,
+  AVAILABLE_MODELS,
+  getAntigravityUserAgent,
+  ACCOUNTS_FILE,
+  isClaudeModel,
+} from "./constants.ts";
+import {
+  getAvailableAccount,
+  getValidAccessToken,
+  markAccountRateLimited,
+  markAccountUsed,
+  getAccountCount,
+} from "./accounts.ts";
+import {
+  translateToGemini,
+  translateGeminiChunkToOpenAI,
+  translateGeminiResponseToOpenAI,
+  type OpenAIChatRequest,
+} from "./transform.ts";
+import { getGeminiCliProfile } from "./config.ts";
+import { handleGeminiCliFallback } from "./gemini-fallback.ts";
+
+const MAX_RETRIES = 3;
+
+// Stable session id for the Antigravity agent request wrapper (reused across
+// requests for the lifetime of the proxy process, mirroring the IDE behavior).
+const PROXY_SESSION_ID = crypto.randomUUID();
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+    },
+  });
+}
+
+function errorResponse(message: string, type: string, status: number): Response {
+  return jsonResponse({ error: { message, type } }, status);
+}
+
+function parseRetryAfterMs(
+  headers: Headers,
+  defaultMs = 60_000,
+): number {
+  const ms = headers.get("retry-after-ms");
+  if (ms) {
+    const v = parseInt(ms, 10);
+    if (!isNaN(v) && v > 0) return v;
+  }
+  const sec = headers.get("retry-after");
+  if (sec) {
+    const v = parseInt(sec, 10);
+    if (!isNaN(v) && v > 0) return v * 1000;
+  }
+  return defaultMs;
+}
+
+function randomId(): string {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+// ── /v1/models ────────────────────────────────────────────────────────────────
+
+function handleModels(): Response {
+  const now = Math.floor(Date.now() / 1000);
+  return jsonResponse({
+    object: "list",
+    data: AVAILABLE_MODELS.map((id) => ({
+      id,
+      object: "model",
+      created: now,
+      owned_by: "google-antigravity",
+    })),
+  });
+}
+
+// ── /health ───────────────────────────────────────────────────────────────────
+
+async function handleHealth(): Promise<Response> {
+  const geminiProfile = await getGeminiCliProfile();
+  return jsonResponse({
+    status: "ok",
+    accounts: await getAccountCount(),
+    geminiCliFallback: geminiProfile !== null,
+  });
+}
+
+// ── /v1/chat/completions ─────────────────────────────────────────────────────
+
+async function handleChatCompletions(req: Request): Promise<Response> {
+  // Parse request body
+  let body: OpenAIChatRequest;
+  try {
+    body = (await req.json()) as OpenAIChatRequest;
+  } catch {
+    return errorResponse("Invalid JSON body", "invalid_request_error", 400);
+  }
+
+  const count = await getAccountCount();
+  if (count === 0) {
+    return errorResponse(
+      "No Antigravity accounts configured. Run: bun run src/auth-cli.ts",
+      "authentication_error",
+      401,
+    );
+  }
+
+  const isStream = body.stream !== false;
+  const chunkId = `chatcmpl-${randomId()}`;
+
+  const { body: geminiBody, endpoints } = translateToGemini(body, PROXY_SESSION_ID);
+
+  let lastError = "";
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    // Select account
+    let accountInfo: Awaited<ReturnType<typeof getAvailableAccount>>;
+    try {
+      accountInfo = await getAvailableAccount();
+    } catch (err: unknown) {
+      // All Antigravity accounts are rate-limited.
+      // For Gemini models: transparently fall over to the Gemini-CLI provider.
+      // For Claude models: return 429 so OpenClaude can handle it normally.
+      if (!isClaudeModel(body.model)) {
+        const geminiProfile = await getGeminiCliProfile();
+        if (geminiProfile) {
+          return handleGeminiCliFallback(body, geminiProfile);
+        }
+      }
+      return errorResponse(
+        String(err instanceof Error ? err.message : err),
+        "rate_limit_error",
+        429,
+      );
+    }
+
+    if (!accountInfo) {
+      return errorResponse("No available accounts.", "authentication_error", 401);
+    }
+
+    const { account, index } = accountInfo;
+
+    // Get fresh access token
+    let accessToken: string;
+    try {
+      accessToken = await getValidAccessToken(account);
+    } catch (err: unknown) {
+      lastError = String(err instanceof Error ? err.message : err);
+      continue;
+    }
+
+    // Antigravity Manager-style headers: ONLY the User-Agent is sent on
+    // content requests — no X-Goog-Api-Client, no Client-Metadata, and no
+    // x-goog-user-project (the project rides in the request body). Anything
+    // more routes the request into the per-account free-tier quota.
+    const upstreamHeaders: Record<string, string> = {
+      "User-Agent": getAntigravityUserAgent(),
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      ...(isStream ? { Accept: "text/event-stream" } : {}),
+    };
+
+    // Try each endpoint in order (daily → autopush → prod).
+    // A network-level failure advances to the next endpoint; a 429 rotates accounts.
+    let upstream: Response | null = null;
+    let endpointError = "";
+    for (const endpoint of endpoints) {
+      try {
+        upstream = await fetch(endpoint, {
+          method: "POST",
+          headers: upstreamHeaders,
+          body: JSON.stringify(geminiBody),
+        });
+        // If the endpoint itself is down (5xx gateway), try the next one
+        if (upstream.status >= 502 && upstream.status <= 504) {
+          endpointError = `Endpoint ${endpoint} returned ${upstream.status}`;
+          upstream = null;
+          continue;
+        }
+        break; // got a real response (success or app-level error)
+      } catch (err: unknown) {
+        endpointError = `Network error on ${endpoint}: ${String(err instanceof Error ? err.message : err)}`;
+        upstream = null;
+      }
+    }
+
+    if (!upstream) {
+      lastError = endpointError;
+      continue;
+    }
+
+    // Handle rate limit — rotate to next account
+    if (upstream.status === 429) {
+      const retryAfterMs = parseRetryAfterMs(upstream.headers);
+      await markAccountRateLimited(index, retryAfterMs);
+      lastError = `Account ${account.email ?? index} rate-limited for ${Math.ceil(retryAfterMs / 1000)}s`;
+      continue;
+    }
+
+    // Handle other upstream errors
+    if (!upstream.ok) {
+      const errText = await upstream.text();
+      await markAccountUsed(index);
+      return errorResponse(
+        `Upstream error (${upstream.status}): ${errText}`,
+        "upstream_error",
+        upstream.status,
+      );
+    }
+
+    await markAccountUsed(index);
+
+    // ── Streaming ──────────────────────────────────────────────────────────
+    if (isStream) {
+      const upstreamBody = upstream.body;
+      if (!upstreamBody) {
+        return errorResponse("Empty upstream body", "upstream_error", 502);
+      }
+
+      const stream = new ReadableStream({
+        async start(controller) {
+          const reader = upstreamBody.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split("\n");
+              buffer = lines.pop() ?? "";
+
+              for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed) continue;
+                const translated = translateGeminiChunkToOpenAI(
+                  trimmed,
+                  body.model,
+                  chunkId,
+                );
+                if (translated) {
+                  controller.enqueue(new TextEncoder().encode(translated));
+                }
+              }
+            }
+          } catch {
+            // Stream ended or client disconnected
+          }
+
+          controller.enqueue(
+            new TextEncoder().encode("data: [DONE]\n\n"),
+          );
+          controller.close();
+        },
+      });
+
+      return new Response(stream, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    }
+
+    // ── Non-streaming ──────────────────────────────────────────────────────
+    let geminiResponseBody: unknown;
+    try {
+      geminiResponseBody = await upstream.json();
+    } catch {
+      return errorResponse(
+        "Upstream returned invalid JSON",
+        "upstream_error",
+        502,
+      );
+    }
+
+    return jsonResponse(
+      translateGeminiResponseToOpenAI(geminiResponseBody, body.model, chunkId),
+    );
+  }
+
+  // All retries exhausted — attempt Gemini-CLI fallback for Gemini models.
+  if (!isClaudeModel(body.model)) {
+    const geminiProfile = await getGeminiCliProfile();
+    if (geminiProfile) {
+      return handleGeminiCliFallback(body, geminiProfile);
+    }
+  }
+
+  return errorResponse(
+    `All retries failed. Last error: ${lastError}`,
+    "service_unavailable",
+    503,
+  );
+}
+
+// ── Bun.serve router ──────────────────────────────────────────────────────────
+
+const server = Bun.serve({
+  port: PROXY_PORT,
+  hostname: "127.0.0.1",
+
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    // CORS preflight
+    if (req.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        },
+      });
+    }
+
+    if (url.pathname === "/health" || url.pathname === "/v1/health") {
+      return handleHealth();
+    }
+
+    if (url.pathname === "/v1/models" && req.method === "GET") {
+      return handleModels();
+    }
+
+    if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+      return handleChatCompletions(req);
+    }
+
+    return errorResponse("Not found", "not_found", 404);
+  },
+
+  error(err) {
+    console.error("[antigravity-provider] Server error:", err.message);
+    return errorResponse("Internal server error", "internal_error", 500);
+  },
+});
+
+console.log(
+  `[antigravity-provider] Proxy running → http://${server.hostname}:${server.port}/v1`,
+);
+console.log(`[antigravity-provider] Accounts file  → ${ACCOUNTS_FILE}`);
+console.log(
+  `[antigravity-provider] Health check  → http://localhost:${server.port}/health`,
+);

package/vendor/openclaude-antigravity-provider/src/storage.ts

@@ -0,0 +1,56 @@
+/**
+ * storage.ts
+ * Reads/writes account data using Bun.file() and Bun.write().
+ * Storage path: ~/.openclaude/antigravity-accounts.json
+ */
+
+import { mkdirSync, existsSync } from "node:fs";
+import { OPENCLAUDE_CONFIG_DIR, ACCOUNTS_FILE } from "./constants.ts";
+
+export interface StoredAccount {
+  email?: string;
+  refreshToken: string;
+  projectId?: string;
+  managedProjectId?: string;
+  addedAt: number;
+  lastUsed: number;
+  enabled: boolean;
+  rateLimitedUntil?: number;
+  cachedQuotaUpdatedAt?: number;
+}
+
+export interface AccountsFile {
+  version: number;
+  accounts: StoredAccount[];
+  activeIndex: number;
+}
+
+function ensureConfigDir(): void {
+  if (!existsSync(OPENCLAUDE_CONFIG_DIR)) {
+    mkdirSync(OPENCLAUDE_CONFIG_DIR, { recursive: true });
+  }
+}
+
+export async function loadAccounts(): Promise<AccountsFile | null> {
+  ensureConfigDir();
+  const file = Bun.file(ACCOUNTS_FILE);
+  const exists = await file.exists();
+  if (!exists) return null;
+  try {
+    return await file.json() as AccountsFile;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveAccounts(data: AccountsFile): Promise<void> {
+  ensureConfigDir();
+  await Bun.write(ACCOUNTS_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function clearAccounts(): Promise<void> {
+  const file = Bun.file(ACCOUNTS_FILE);
+  if (await file.exists()) {
+    await Bun.write(ACCOUNTS_FILE, "");
+  }
+}

package/vendor/openclaude-antigravity-provider/src/transform.ts

@@ -0,0 +1,241 @@
+/**
+ * transform.ts
+ * Translates OpenAI Chat Completions requests → Gemini GenerateContent format.
+ * Translates Gemini SSE chunks → OpenAI SSE chunks.
+ */
+
+import {
+  resolveAntigravityModel,
+  generateSyntheticProjectId,
+  ANTIGRAVITY_ENDPOINT_FALLBACKS,
+} from "./constants.ts";
+
+// ── OpenAI input types ────────────────────────────────────────────────────────
+
+export interface OpenAIMessage {
+  role: "system" | "user" | "assistant";
+  content: string | OpenAIContentPart[];
+}
+
+export interface OpenAIContentPart {
+  type: "text" | "image_url";
+  text?: string;
+  image_url?: { url: string };
+}
+
+export interface OpenAIChatRequest {
+  model: string;
+  messages: OpenAIMessage[];
+  stream?: boolean;
+  temperature?: number;
+  max_tokens?: number;
+  top_p?: number;
+}
+
+// ── Gemini internal types ─────────────────────────────────────────────────────
+
+interface GeminiPart {
+  text?: string;
+}
+
+interface GeminiContent {
+  role: "user" | "model";
+  parts: GeminiPart[];
+}
+
+interface GeminiRequest {
+  project: string;
+  model: string;
+  requestType: "agent";
+  userAgent: "antigravity";
+  requestId: string;
+  request: {
+    contents: GeminiContent[];
+    sessionId: string;
+    systemInstruction?: { role: "user"; parts: GeminiPart[] };
+    generationConfig?: {
+      temperature?: number;
+      maxOutputTokens?: number;
+      topP?: number;
+    };
+  };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function contentToText(content: OpenAIMessage["content"]): string {
+  if (typeof content === "string") return content;
+  return content
+    .filter((p) => p.type === "text")
+    .map((p) => p.text ?? "")
+    .join("\n");
+}
+
+function toGeminiRole(role: OpenAIMessage["role"]): "user" | "model" {
+  return role === "assistant" ? "model" : "user";
+}
+
+// ── Main translation: OpenAI → Gemini ────────────────────────────────────────
+
+export interface TranslatedRequest {
+  body: GeminiRequest;
+  /** Ordered list of endpoints to try (daily → autopush → prod). */
+  endpoints: readonly string[];
+}
+
+export function translateToGemini(
+  req: OpenAIChatRequest,
+  sessionId: string,
+): TranslatedRequest {
+  // Daily sandbox serves bare names with tier/thinking suffixes (see
+  // ANTIGRAVITY_MODEL_MAP notes) — NOT the -preview generativelanguage names.
+  const geminiModel = resolveAntigravityModel(req.model);
+
+  // Pull out system message
+  let systemInstruction: { role: "user"; parts: GeminiPart[] } | undefined;
+  const turns = req.messages.filter((m) => {
+    if (m.role === "system") {
+      systemInstruction = { role: "user", parts: [{ text: contentToText(m.content) }] };
+      return false;
+    }
+    return true;
+  });
+
+  // Build contents, merging consecutive same-role turns (Gemini requires alternating)
+  const contents: GeminiContent[] = [];
+  for (const msg of turns) {
+    const role = toGeminiRole(msg.role);
+    const text = contentToText(msg.content);
+    const last = contents[contents.length - 1];
+    if (last && last.role === role) {
+      last.parts.push({ text });
+    } else {
+      contents.push({ role, parts: [{ text }] });
+    }
+  }
+
+  // Gemini requires the first turn to be "user"
+  if (contents.length === 0 || contents[0]?.role !== "user") {
+    contents.unshift({ role: "user", parts: [{ text: "" }] });
+  }
+
+  // Antigravity Manager-style wrapped body. The synthetic project +
+  // requestType "agent" route the request into the Antigravity agent quota
+  // pool on the daily sandbox (unlimited), instead of the per-account
+  // free tier that the prod endpoint enforces.
+  const body: GeminiRequest = {
+    project: generateSyntheticProjectId(),
+    model: geminiModel,
+    requestType: "agent",
+    userAgent: "antigravity",
+    requestId: `agent-${crypto.randomUUID()}`,
+    request: {
+      contents,
+      sessionId,
+      ...(systemInstruction ? { systemInstruction } : {}),
+      generationConfig: {
+        ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        ...(req.max_tokens !== undefined ? { maxOutputTokens: req.max_tokens } : {}),
+        ...(req.top_p !== undefined ? { topP: req.top_p } : {}),
+      },
+    },
+  };
+
+  const endpoints = ANTIGRAVITY_ENDPOINT_FALLBACKS.map(
+    (base) => `${base}/v1internal:streamGenerateContent?alt=sse`,
+  );
+  return { body, endpoints };
+}
+
+// ── Gemini SSE chunk → OpenAI SSE chunk ──────────────────────────────────────
+
+interface GeminiCandidate {
+  content?: { parts?: Array<{ text?: string }> };
+  finishReason?: string;
+}
+
+interface GeminiChunk {
+  response?: { candidates?: GeminiCandidate[] };
+  candidates?: GeminiCandidate[];
+}
+
+export function translateGeminiChunkToOpenAI(
+  rawLine: string,
+  model: string,
+  chunkId: string,
+): string | null {
+  if (!rawLine.startsWith("data:")) return null;
+  const payload = rawLine.slice(5).trim();
+  if (!payload || payload === "[DONE]") return null;
+
+  let parsed: GeminiChunk;
+  try {
+    parsed = JSON.parse(payload) as GeminiChunk;
+  } catch {
+    return null;
+  }
+
+  // Daily sandbox SSE chunks nest the payload under "response";
+  // some endpoints emit it flat — support both.
+  const candidates = parsed.response?.candidates ?? parsed.candidates;
+  if (!candidates || candidates.length === 0) return null;
+
+  const candidate = candidates[0]!;
+  const text =
+    candidate.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+  const finishReason =
+    candidate.finishReason === "STOP"
+      ? "stop"
+      : candidate.finishReason === "MAX_TOKENS"
+        ? "length"
+        : null;
+
+  const chunk = {
+    id: chunkId,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta: text ? { role: "assistant", content: text } : {},
+        finish_reason: finishReason,
+      },
+    ],
+  };
+
+  return `data: ${JSON.stringify(chunk)}\n\n`;
+}
+
+// ── Full non-streaming response translation ───────────────────────────────────
+
+export function translateGeminiResponseToOpenAI(
+  geminiBody: unknown,
+  model: string,
+  chunkId: string,
+): Record<string, unknown> {
+  // Unwrap the "response" envelope when present (daily sandbox shape)
+  const unwrapped = (
+    (geminiBody as { response?: unknown }).response ?? geminiBody
+  ) as { candidates?: GeminiCandidate[] };
+  const candidates = unwrapped.candidates ?? [];
+  const text =
+    candidates[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+  const finishReason =
+    candidates[0]?.finishReason === "STOP" ? "stop" : "length";
+
+  return {
+    id: chunkId,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content: text },
+        finish_reason: finishReason,
+      },
+    ],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}

package/vendor/openclaude-antigravity-provider/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}