opencode-antigravity-img 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# opencode-antigravity-img
+
+OpenCode plugin for generating images using Gemini 3 Pro Image model via Google's Antigravity/CloudCode API.
+
+## Requirements
+
+- [OpenCode](https://github.com/sst/opencode) installed
+- Google One AI Premium subscription
+- Authentication via [opencode-antigravity-auth](https://www.npmjs.com/package/opencode-antigravity-auth) plugin
+
+## Installation
+
+1. First, install and configure the authentication plugin:
+
+```bash
+# Add to your opencode.json
+"plugin": [
+  "opencode-antigravity-auth",
+  "opencode-antigravity-img"
+]
+```
+
+2. Run the auth plugin to authenticate with your Google account:
+
+```bash
+opencode
+# Use the authenticate command from antigravity-auth
+```
+
+This creates `~/.config/opencode/antigravity-accounts.json` with your credentials.
+
+## Tools
+
+### generate_image
+
+Generate an image from a text prompt.
+
+**Arguments:**
+- `prompt` (required): Text description of the image to generate
+- `filename` (optional): Output filename (default: `generated_<timestamp>.png`)
+- `output_dir` (optional): Output directory (default: current working directory)
+
+**Example:**
+```
+Generate an image of a sunset over mountains with a lake in the foreground
+```
+
+**Output:**
+- Image file saved to specified path
+- Returns path, size, format, and remaining quota
+
+### image_quota
+
+Check the remaining quota for the Gemini 3 Pro Image model.
+
+**Arguments:** None
+
+**Output:**
+- Visual progress bar showing remaining quota percentage
+- Time until quota resets
+
+## Image Details
+
+- **Model**: Gemini 3 Pro Image
+- **Resolution**: 1408x768 pixels
+- **Format**: JPEG (typically 600KB - 1MB)
+- **Generation time**: 10-30 seconds
+
+## Quota
+
+Image generation uses a separate quota from text models. The quota typically resets daily. Use the `image_quota` tool to check your remaining quota before generating images.
+
+## Troubleshooting
+
+### "No Antigravity account found"
+
+Make sure you've:
+1. Installed `opencode-antigravity-auth`
+2. Authenticated with your Google account
+3. The credentials file exists at `~/.config/opencode/antigravity-accounts.json`
+
+### "Rate limited" or generation fails
+
+- Wait a few seconds and try again
+- Check your quota with `image_quota`
+- The plugin automatically tries multiple endpoints
+
+### Slow generation
+
+Image generation typically takes 10-30 seconds. This is normal due to the complexity of image synthesis.
+
+## API Endpoints
+
+The plugin uses Google's CloudCode API with fallback endpoints:
+1. `https://daily-cloudcode-pa.googleapis.com` (primary)
+2. `https://daily-cloudcode-pa.sandbox.googleapis.com` (fallback)
+3. `https://cloudcode-pa.googleapis.com` (production)
+
+## Related Plugins
+
+- [opencode-antigravity-auth](https://www.npmjs.com/package/opencode-antigravity-auth) - Authentication (required)
+- [opencode-antigravity-quota](https://www.npmjs.com/package/opencode-antigravity-quota) - Text model quota checking
+
+## License
+
+MIT

package/bun.lock

@@ -0,0 +1,73 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "opencode-antigravity-img",
+      "dependencies": {
+        "@opencode-ai/plugin": "^1.1.15",
+        "opencode-antigravity-auth": "^1.2.8",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "@types/node": "^22.0.0",
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@openauthjs/openauth": ["@openauthjs/openauth@0.4.3", "", { "dependencies": { "@standard-schema/spec": "1.0.0-beta.3", "aws4fetch": "1.0.20", "jose": "5.9.6" }, "peerDependencies": { "arctic": "^2.2.2", "hono": "^4.0.0" } }, "sha512-RlnjqvHzqcbFVymEwhlUEuac4utA5h4nhSK/i2szZuQmxTIqbGUxZ+nM+avM+VV4Ing+/ZaNLKILoXS3yrkOOw=="],
+
+    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.1.21", "", { "dependencies": { "@opencode-ai/sdk": "1.1.21", "zod": "4.1.8" } }, "sha512-oAWVlKG7LACGFYawfdHGMN6e+6lyN6F+zPVncFUB99BrTl/TjELE5gTZwU7MalGpjwfU77yslBOZm4BXVAYGvw=="],
+
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.1.21", "", {}, "sha512-4M6lBjRPlPz99Rb5rS5ZqKrb0UDDxOT9VTG06JpNxvA7ynTd8C50ckc2NGzWtvjarmxfaAk1VeuBYN/cq2pIKQ=="],
+
+    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],
+
+    "@oslojs/binary": ["@oslojs/binary@1.0.0", "", {}, "sha512-9RCU6OwXU6p67H4NODbuxv2S3eenuQ4/WFLrsq+K/k682xrznH5EVWA7N4VFk9VYVcbFtKqur5YQQZc0ySGhsQ=="],
+
+    "@oslojs/crypto": ["@oslojs/crypto@1.0.1", "", { "dependencies": { "@oslojs/asn1": "1.0.0", "@oslojs/binary": "1.0.0" } }, "sha512-7n08G8nWjAr/Yu3vu9zzrd0L9XnrJfpMioQcvCMxBIiF5orECHe5/3J0jmXRVvgfqMm/+4oxlQ+Sq39COYLcNQ=="],
+
+    "@oslojs/encoding": ["@oslojs/encoding@1.1.0", "", {}, "sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ=="],
+
+    "@oslojs/jwt": ["@oslojs/jwt@0.2.0", "", { "dependencies": { "@oslojs/encoding": "0.4.1" } }, "sha512-bLE7BtHrURedCn4Mco3ma9L4Y1GR2SMBuIvjWr7rmQ4/W/4Jy70TIAgZ+0nIlk0xHz1vNP8x8DCns45Sb2XRbg=="],
+
+    "@standard-schema/spec": ["@standard-schema/spec@1.0.0-beta.3", "", {}, "sha512-0ifF3BjA1E8SY9C+nUew8RefNOIq0cDlYALPty4rhUm8Rrl6tCM8hBT4bhGhx7I7iXD0uAgt50lgo8dD73ACMw=="],
+
+    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
+
+    "@types/node": ["@types/node@22.19.7", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-MciR4AKGHWl7xwxkBa6xUGxQJ4VBOmPTF7sL+iGzuahOFaO0jHCsuEfS80pan1ef4gWId1oWOweIhrDEYLuaOw=="],
+
+    "arctic": ["arctic@2.3.4", "", { "dependencies": { "@oslojs/crypto": "1.0.1", "@oslojs/encoding": "1.1.0", "@oslojs/jwt": "0.2.0" } }, "sha512-+p30BOWsctZp+CVYCt7oAean/hWGW42sH5LAcRQX56ttEkFJWbzXBhmSpibbzwSJkRrotmsA+oAoJoVsU0f5xA=="],
+
+    "aws4fetch": ["aws4fetch@1.0.20", "", {}, "sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g=="],
+
+    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "hono": ["hono@4.11.4", "", {}, "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA=="],
+
+    "jose": ["jose@5.9.6", "", {}, "sha512-AMlnetc9+CV9asI19zHmrgS/WYsWUwCn2R7RzlbJWD7F9eWYUTGyBmU9o6PxngtLGOiDGPRu+Uc4fhKzbpteZQ=="],
+
+    "opencode-antigravity-auth": ["opencode-antigravity-auth@1.2.8", "", { "dependencies": { "@openauthjs/openauth": "^0.4.3", "proper-lockfile": "^4.1.2", "xdg-basedir": "^5.1.0", "zod": "^3.24.0" }, "peerDependencies": { "typescript": "^5" } }, "sha512-ZLcZdUL3IBUM96WSsclu/4vR0uZLfDBF77b2XKEZcyt5dhOMbJouEkPnp8BEtV1Pu9oFl4eiVcfML7e2JMmrNg=="],
+
+    "proper-lockfile": ["proper-lockfile@4.1.2", "", { "dependencies": { "graceful-fs": "^4.2.4", "retry": "^0.12.0", "signal-exit": "^3.0.2" } }, "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA=="],
+
+    "retry": ["retry@0.12.0", "", {}, "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow=="],
+
+    "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "xdg-basedir": ["xdg-basedir@5.1.0", "", {}, "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="],
+
+    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
+
+    "@oslojs/jwt/@oslojs/encoding": ["@oslojs/encoding@0.4.1", "", {}, "sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q=="],
+
+    "opencode-antigravity-auth/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+  }
+}

package/index.ts

@@ -0,0 +1 @@
+export { plugin, default } from "./src/index";

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "opencode-antigravity-img",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for Gemini image generation via Antigravity/CloudCode API",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "antigravity",
+    "gemini",
+    "image",
+    "generation",
+    "google-cloud"
+  ],
+  "author": "Lorenzo Becchi (ominiverdi)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ominiverdi/opencode-antigravity-img.git"
+  },
+  "homepage": "https://github.com/ominiverdi/opencode-antigravity-img#readme",
+  "private": false,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.1.15",
+    "opencode-antigravity-auth": "^1.2.8"
+  }
+}

package/src/api.ts

@@ -0,0 +1,303 @@
+import {
+  ANTIGRAVITY_CLIENT_ID,
+  ANTIGRAVITY_CLIENT_SECRET,
+  GOOGLE_TOKEN_URL,
+  CLOUDCODE_BASE_URL,
+  CLOUDCODE_FALLBACK_URLS,
+  CLOUDCODE_METADATA,
+  IMAGE_MODEL,
+  IMAGE_GENERATION_TIMEOUT_MS,
+} from "./constants";
+import type {
+  Account,
+  TokenResponse,
+  LoadCodeAssistResponse,
+  CloudCodeQuotaResponse,
+  GenerateContentResponse,
+  ImageGenerationResult,
+  QuotaInfo,
+} from "./types";
+
+/**
+ * Refresh an access token using the refresh token
+ */
+export async function refreshAccessToken(refreshToken: string): Promise<string> {
+  const params = new URLSearchParams({
+    client_id: ANTIGRAVITY_CLIENT_ID,
+    client_secret: ANTIGRAVITY_CLIENT_SECRET,
+    refresh_token: refreshToken,
+    grant_type: "refresh_token",
+  });
+
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: params.toString(),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Token refresh failed (${response.status})`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  return data.access_token;
+}
+
+/**
+ * Load code assist info to get project ID
+ */
+export async function loadCodeAssist(accessToken: string): Promise<LoadCodeAssistResponse> {
+  const response = await fetch(`${CLOUDCODE_BASE_URL}/v1internal:loadCodeAssist`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": "antigravity",
+    },
+    body: JSON.stringify({ metadata: CLOUDCODE_METADATA }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`loadCodeAssist failed (${response.status})`);
+  }
+
+  return (await response.json()) as LoadCodeAssistResponse;
+}
+
+/**
+ * Extract project ID from cloudaicompanionProject field
+ */
+export function extractProjectId(project: string | { id?: string } | undefined): string | undefined {
+  if (!project) return undefined;
+  if (typeof project === "string") return project;
+  return project.id;
+}
+
+/**
+ * Fetch available models with quota info
+ */
+export async function fetchAvailableModels(
+  accessToken: string,
+  projectId?: string
+): Promise<CloudCodeQuotaResponse> {
+  const payload = projectId ? { project: projectId } : {};
+
+  const response = await fetch(`${CLOUDCODE_BASE_URL}/v1internal:fetchAvailableModels`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": "antigravity",
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new Error(`fetchAvailableModels failed (${response.status})`);
+  }
+
+  return (await response.json()) as CloudCodeQuotaResponse;
+}
+
+/**
+ * Get quota info for the image model
+ */
+export async function getImageModelQuota(account: Account): Promise<QuotaInfo | null> {
+  try {
+    const accessToken = await refreshAccessToken(account.refreshToken);
+    let projectId = account.projectId || account.managedProjectId;
+
+    if (!projectId) {
+      const codeAssist = await loadCodeAssist(accessToken);
+      projectId = extractProjectId(codeAssist.cloudaicompanionProject);
+    }
+
+    const models = await fetchAvailableModels(accessToken, projectId);
+    const imageModel = models.models?.[IMAGE_MODEL];
+
+    if (!imageModel?.quotaInfo) {
+      return null;
+    }
+
+    const quota = imageModel.quotaInfo;
+    const remainingPercent = (quota.remainingFraction ?? 0) * 100;
+    const resetTime = quota.resetTime || "";
+
+    // Calculate reset in human readable
+    let resetIn = "N/A";
+    if (resetTime) {
+      const resetDate = new Date(resetTime);
+      const now = Date.now();
+      const diffMs = resetDate.getTime() - now;
+      if (diffMs > 0) {
+        const hours = Math.floor(diffMs / 3600000);
+        const mins = Math.floor((diffMs % 3600000) / 60000);
+        resetIn = `${hours}h ${mins}m`;
+      } else {
+        resetIn = "now";
+      }
+    }
+
+    return {
+      modelName: imageModel.displayName || IMAGE_MODEL,
+      remainingPercent,
+      resetTime,
+      resetIn,
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Generate an image using the Gemini 3 Pro Image model
+ */
+export async function generateImage(
+  account: Account,
+  prompt: string
+): Promise<ImageGenerationResult> {
+  try {
+    // Get access token
+    const accessToken = await refreshAccessToken(account.refreshToken);
+
+    // Get project ID
+    let projectId = account.projectId || account.managedProjectId;
+    if (!projectId) {
+      const codeAssist = await loadCodeAssist(accessToken);
+      projectId = extractProjectId(codeAssist.cloudaicompanionProject);
+    }
+
+    if (!projectId) {
+      return { success: false, error: "Could not determine project ID" };
+    }
+
+    // Build request
+    const requestBody = {
+      project: projectId,
+      requestId: `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      model: IMAGE_MODEL,
+      userAgent: "antigravity",
+      requestType: "agent",
+      request: {
+        contents: [{ role: "user", parts: [{ text: prompt }] }],
+        session_id: `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        generationConfig: {
+          responseModalities: ["TEXT", "IMAGE"],
+        },
+      },
+    };
+
+    // Try each endpoint
+    for (const baseUrl of CLOUDCODE_FALLBACK_URLS) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), IMAGE_GENERATION_TIMEOUT_MS);
+
+        const response = await fetch(
+          `${baseUrl}/v1internal:streamGenerateContent?alt=sse`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "Content-Type": "application/json",
+              "User-Agent": "antigravity",
+            },
+            body: JSON.stringify(requestBody),
+            signal: controller.signal,
+          }
+        );
+
+        clearTimeout(timeout);
+
+        if (!response.ok) {
+          if (response.status === 429) {
+            // Rate limited, try next endpoint
+            continue;
+          }
+          const errorText = await response.text();
+          return { success: false, error: `HTTP ${response.status}: ${errorText.slice(0, 200)}` };
+        }
+
+        // Parse SSE response
+        const text = await response.text();
+        const result = parseSSEResponse(text);
+
+        if (result.success && result.imageData) {
+          // Get updated quota info
+          const quota = await getImageModelQuota(account);
+
+          return {
+            ...result,
+            quota: quota
+              ? {
+                  remainingPercent: quota.remainingPercent,
+                  resetTime: quota.resetTime,
+                }
+              : undefined,
+          };
+        }
+
+        return result;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          continue; // Timeout, try next endpoint
+        }
+        // Network error, try next endpoint
+        continue;
+      }
+    }
+
+    return { success: false, error: "All endpoints failed" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Parse SSE response and extract image data
+ */
+function parseSSEResponse(text: string): ImageGenerationResult {
+  const lines = text.split("\n");
+
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) continue;
+
+    const jsonStr = line.slice(6);
+    if (jsonStr === "[DONE]") continue;
+
+    try {
+      const data = JSON.parse(jsonStr) as GenerateContentResponse;
+
+      // Check for error
+      if (data.error) {
+        return {
+          success: false,
+          error: `${data.error.code}: ${data.error.message}`,
+        };
+      }
+
+      // Look for image in response
+      const candidates = data.response?.candidates || [];
+      for (const candidate of candidates) {
+        const parts = candidate.content?.parts || [];
+        for (const part of parts) {
+          if (part.inlineData?.data && part.inlineData.mimeType?.startsWith("image/")) {
+            return {
+              success: true,
+              imageData: part.inlineData.data,
+              mimeType: part.inlineData.mimeType,
+              sizeBytes: Math.round((part.inlineData.data.length * 3) / 4), // Approximate decoded size
+            };
+          }
+        }
+      }
+    } catch {
+      // Skip unparseable lines
+    }
+  }
+
+  return { success: false, error: "No image in response" };
+}

package/src/constants.ts

@@ -0,0 +1,42 @@
+import { homedir } from "os";
+import { join } from "path";
+
+// OAuth credentials (same as antigravity-auth plugin)
+export const ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export const ANTIGRAVITY_CLIENT_SECRET = "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";
+export const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+
+// CloudCode API
+export const CLOUDCODE_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
+export const CLOUDCODE_FALLBACK_URLS = [
+  "https://daily-cloudcode-pa.googleapis.com",
+  "https://daily-cloudcode-pa.sandbox.googleapis.com",
+  "https://cloudcode-pa.googleapis.com",
+];
+
+export const CLOUDCODE_METADATA = {
+  ideType: "ANTIGRAVITY",
+  platform: "PLATFORM_UNSPECIFIED",
+  pluginType: "GEMINI",
+};
+
+// Image generation
+export const IMAGE_MODEL = "gemini-3-pro-image";
+export const IMAGE_GENERATION_TIMEOUT_MS = 120_000;
+
+// Config file paths
+export const CONFIG_PATHS = [
+  join(homedir(), ".config", "opencode", "antigravity-accounts.json"),
+  join(homedir(), ".opencode", "antigravity-accounts.json"),
+];
+
+// Command file for opencode discovery
+export const COMMAND_DIR = join(homedir(), ".config", "opencode", "commands");
+export const COMMAND_FILE = join(COMMAND_DIR, "generate-image.md");
+export const COMMAND_CONTENT = `# Generate Image
+
+Generate an image using Gemini 3 Pro Image model.
+
+Prompt: $PROMPT
+Output filename (optional): $FILENAME
+`;

package/src/index.ts

@@ -0,0 +1,211 @@
+import { type Plugin, tool } from "@opencode-ai/plugin";
+import * as fs from "fs/promises";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { CONFIG_PATHS, COMMAND_DIR, COMMAND_FILE, COMMAND_CONTENT, IMAGE_MODEL } from "./constants";
+import type { AccountsConfig, Account } from "./types";
+import { generateImage, getImageModelQuota } from "./api";
+
+// Create command file for opencode discovery
+try {
+  if (!existsSync(COMMAND_DIR)) {
+    mkdirSync(COMMAND_DIR, { recursive: true });
+  }
+  if (!existsSync(COMMAND_FILE)) {
+    writeFileSync(COMMAND_FILE, COMMAND_CONTENT, "utf-8");
+  }
+} catch {
+  // Non-fatal if command file creation fails
+}
+
+/**
+ * Load accounts from config file
+ */
+async function loadAccounts(): Promise<AccountsConfig | null> {
+  for (const configPath of CONFIG_PATHS) {
+    if (existsSync(configPath)) {
+      try {
+        const content = await fs.readFile(configPath, "utf-8");
+        return JSON.parse(content) as AccountsConfig;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the first available account
+ */
+async function getAccount(): Promise<Account | null> {
+  const config = await loadAccounts();
+  if (!config?.accounts?.length) return null;
+  return config.accounts[0] || null;
+}
+
+/**
+ * Format file size for display
+ */
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Format quota for display
+ */
+function formatQuota(percent: number): string {
+  if (percent <= 10) return `${percent.toFixed(0)}% (low)`;
+  if (percent <= 30) return `${percent.toFixed(0)}% (medium)`;
+  return `${percent.toFixed(0)}%`;
+}
+
+export const plugin: Plugin = async (ctx) => {
+  return {
+    tool: {
+      /**
+       * Generate an image using Gemini 3 Pro Image
+       */
+      generate_image: tool({
+        description:
+          "Generate an image using Gemini 3 Pro Image model. " +
+          "Provide a text prompt describing the image you want. " +
+          "Returns the path to the generated image file.",
+        args: {
+          prompt: tool.schema.string().describe("Text description of the image to generate"),
+          filename: tool.schema
+            .string()
+            .optional()
+            .describe("Output filename (default: generated_<timestamp>.png)"),
+          output_dir: tool.schema
+            .string()
+            .optional()
+            .describe("Output directory (default: current working directory)"),
+        },
+        async execute(args, context) {
+          const { prompt, filename, output_dir } = args;
+
+          if (!prompt?.trim()) {
+            return "Error: Please provide a prompt describing the image to generate.";
+          }
+
+          // Get account
+          const account = await getAccount();
+          if (!account) {
+            return (
+              "Error: No Antigravity account found.\n\n" +
+              "Please install and configure opencode-antigravity-auth first:\n" +
+              "  1. Add 'opencode-antigravity-auth' to your opencode plugins\n" +
+              "  2. Authenticate with your Google account\n\n" +
+              `Checked paths:\n${CONFIG_PATHS.map((p) => `  - ${p}`).join("\n")}`
+            );
+          }
+
+          context.metadata({ title: "Generating image..." });
+
+          // Generate image
+          const result = await generateImage(account, prompt);
+
+          if (!result.success || !result.imageData) {
+            return `Error generating image: ${result.error || "Unknown error"}`;
+          }
+
+          // Determine output path
+          const dir = output_dir || ctx.directory;
+          const ext = result.mimeType === "image/png" ? "png" : "jpg";
+          const name = filename || `generated_${Date.now()}.${ext}`;
+          const outputPath = join(dir, name);
+
+          // Ensure directory exists
+          const dirPath = dirname(outputPath);
+          if (!existsSync(dirPath)) {
+            await fs.mkdir(dirPath, { recursive: true });
+          }
+
+          // Decode and save image
+          const imageBuffer = Buffer.from(result.imageData, "base64");
+          await fs.writeFile(outputPath, imageBuffer);
+
+          const sizeStr = formatSize(imageBuffer.length);
+
+          context.metadata({
+            title: "Image generated",
+            metadata: {
+              path: outputPath,
+              size: sizeStr,
+              format: result.mimeType,
+            },
+          });
+
+          // Build response
+          let response = `Image generated successfully!\n\n`;
+          response += `Path: ${outputPath}\n`;
+          response += `Size: ${sizeStr}\n`;
+          response += `Format: ${result.mimeType}\n`;
+
+          if (result.quota) {
+            response += `\nQuota: ${formatQuota(result.quota.remainingPercent)} remaining`;
+          }
+
+          return response;
+        },
+      }),
+
+      /**
+       * Check quota for image generation model
+       */
+      image_quota: tool({
+        description:
+          "Check the remaining quota for the Gemini 3 Pro Image model. " +
+          "Shows percentage remaining and time until reset.",
+        args: {},
+        async execute(args, context) {
+          const account = await getAccount();
+          if (!account) {
+            return (
+              "Error: No Antigravity account found.\n" +
+              "Please configure opencode-antigravity-auth first."
+            );
+          }
+
+          context.metadata({ title: "Checking quota..." });
+
+          const quota = await getImageModelQuota(account);
+
+          if (!quota) {
+            return "Error: Could not fetch quota information.";
+          }
+
+          context.metadata({
+            title: "Quota",
+            metadata: {
+              remaining: `${quota.remainingPercent.toFixed(0)}%`,
+              resetIn: quota.resetIn,
+            },
+          });
+
+          // Visual progress bar
+          const barWidth = 20;
+          const filled = Math.round((quota.remainingPercent / 100) * barWidth);
+          const empty = barWidth - filled;
+          const bar = "#".repeat(filled) + ".".repeat(empty);
+
+          let response = `${quota.modelName}\n\n`;
+          response += `[${bar}] ${quota.remainingPercent.toFixed(0)}% remaining\n`;
+          response += `Resets in: ${quota.resetIn}`;
+
+          if (quota.resetTime) {
+            const resetDate = new Date(quota.resetTime);
+            response += ` (at ${resetDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })})`;
+          }
+
+          return response;
+        },
+      }),
+    },
+  };
+};
+
+export default plugin;

package/src/types.ts

@@ -0,0 +1,105 @@
+// Account configuration (from antigravity-accounts.json)
+export interface Account {
+  email: string;
+  refreshToken: string;
+  accessToken?: string;
+  projectId?: string;
+  managedProjectId?: string;
+}
+
+export interface AccountsConfig {
+  accounts: Account[];
+}
+
+// API responses
+export interface TokenResponse {
+  access_token: string;
+  expires_in: number;
+  token_type: string;
+}
+
+export interface LoadCodeAssistResponse {
+  cloudaicompanionProject?: string | { id?: string };
+  currentTier?: { id?: string; name?: string };
+  paidTier?: { id?: string; name?: string };
+}
+
+export interface CloudCodeQuotaResponse {
+  models?: Record<string, ModelInfo>;
+}
+
+export interface ModelInfo {
+  displayName?: string;
+  model?: string;
+  quotaInfo?: {
+    remainingFraction?: number;
+    resetTime?: string;
+  };
+}
+
+// Image generation
+export interface GenerateContentRequest {
+  project: string;
+  requestId: string;
+  model: string;
+  userAgent: string;
+  requestType: string;
+  request: {
+    contents: Array<{
+      role: string;
+      parts: Array<{ text: string }>;
+    }>;
+    session_id: string;
+    generationConfig: {
+      responseModalities: string[];
+    };
+  };
+}
+
+export interface GenerateContentResponse {
+  response?: {
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+          thought?: boolean;
+          inlineData?: {
+            mimeType: string;
+            data: string;
+          };
+        }>;
+      };
+      finishReason?: string;
+    }>;
+    usageMetadata?: {
+      promptTokenCount?: number;
+      candidatesTokenCount?: number;
+      totalTokenCount?: number;
+    };
+  };
+  error?: {
+    code: number;
+    message: string;
+    status: string;
+  };
+}
+
+export interface ImageGenerationResult {
+  success: boolean;
+  imagePath?: string;
+  imageData?: string;  // base64
+  mimeType?: string;
+  sizeBytes?: number;
+  error?: string;
+  quota?: {
+    remainingPercent: number;
+    resetTime: string;
+  };
+}
+
+export interface QuotaInfo {
+  modelName: string;
+  remainingPercent: number;
+  resetTime: string;
+  resetIn: string;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "."
+  },
+  "include": ["src/**/*", "index.ts"],
+  "exclude": ["node_modules", "dist"]
+}