supergravity-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# supergravity-mcp
+
+An MCP server that lets Claude Code (or any MCP client) delegate tasks to the
+**Google Antigravity** desktop app — by driving its real, already-logged-in UI.
+No reverse engineering, no extracted credentials, no unofficial API calls.
+
+## Why this exists
+
+Antigravity ships a CLI (`agy`) for scripting it headlessly — but on older
+Intel Macs, that CLI isn't available even though the desktop **app** runs fine
+(confirmed working on a 2015 MacBook Pro, macOS Monterey, Intel). This project
+is the missing bridge for anyone in that situation: it automates the app the
+same way a human would use it, so it works anywhere the app itself works.
+
+## How it works
+
+1. Antigravity is relaunched with Chrome's remote-debugging flag
+   (`--remote-debugging-port`), the same mechanism browser test tools like
+   Playwright use to drive Electron apps.
+2. A script connects to that debug port and: types your task into the chat
+   box (via a simulated paste event — Antigravity's input is a rich-text
+   editor, not a plain textarea, so it needs a real paste, not just poking
+   text into the DOM), clicks send, and reads back the reply once it's done
+   streaming.
+3. Everything happens through your own existing login. This tool never
+   touches Antigravity's stored credentials, internal code, or private APIs.
+
+## Setup
+
+```bash
+npm install
+npm run build
+```
+
+Antigravity must be installed and already signed in. By default the tool
+looks for it at `/Applications/Antigravity.app` or `~/Desktop/Antigravity.app`;
+set `ANTIGRAVITY_APP_PATH` if it lives somewhere else.
+
+Register it with Claude Code:
+
+```bash
+claude mcp add supergravity -- node /absolute/path/to/dist/mcp-server.js
+```
+
+## The tools
+
+### `delegate_to_antigravity(task, model?, timeoutMs?)`
+
+- `task` — what to ask Antigravity to do.
+- `model` — optional. One of the models in Antigravity's own selector
+  (see `AVAILABLE_MODELS` in `src/antigravity-client.ts`).
+- `timeoutMs` — optional, default 120000 (2 minutes).
+
+### `get_antigravity_quota()`
+
+Reads Antigravity's Settings > Models panel and returns remaining quota —
+Gemini models and Claude+GPT models draw from **separate pools**, each with a
+weekly limit and a 5-hour limit. Useful to check before delegating, or to
+explain a `send button is disabled` error (usually means that pool is
+exhausted, not that the model is unavailable).
+
+### Picking a model
+
+Antigravity doesn't show per-message token cost, only pooled quota %. The
+`model` parameter's description carries a rough cost/capability cheat sheet
+(`MODEL_GUIDE` in `src/antigravity-client.ts`) built from third-party API
+list prices and public benchmarks, researched mid-2026 — newer than this
+tool's own training data, so treat it as a starting point, not gospel:
+
+| Model | ~Price (in/out per 1M tokens) | Known for |
+|---|---|---|
+| Gemini 3.5 Flash | $1.50 / $9 | Fastest, cheapest frontier-tier option; strong coding/agentic benchmarks |
+| Gemini 3.1 Pro | $2 / $12 | "Thinking" mode for harder reasoning (ARC-AGI-2 ~77%) |
+| Claude Sonnet 4.6 | $3 / $15 | Coding quality, computer-use, agent workflows (SWE-bench ~80%) |
+| Claude Opus 4.6 | $5 / $25 | Strongest complex/ambiguous reasoning; legal/financial/research-grade analysis |
+| GPT-OSS 120B | ~$0.03–0.09 / $0.10–0.40 | Open-weight, near-o4-mini reasoning, far cheaper than the rest |
+
+These are what the underlying models cost via their own APIs elsewhere —
+Antigravity itself doesn't bill you per token, it draws down the pooled
+quota above instead.
+
+## Known limitations
+
+- **A model's quota can run out.** If a non-default model (e.g. Claude Opus)
+  has hit its usage limit, Antigravity's send button stays disabled after
+  selecting it, even though it's still pickable in the dropdown. The tool
+  fails fast with a clear error in that case instead of hanging until
+  timeout — just retry later or pick a different model.
+- **UI automation, not an API.** If Google changes Antigravity's screen
+  layout, the CSS selectors this relies on (`data-testid="send-button"`, the
+  message input's `aria-label`, etc.) may need updating. That's the tradeoff
+  for staying entirely inside Antigravity's terms of use — see below.
+- **Reply extraction is a text heuristic**, not a structured read. It looks
+  for the "Thought for Ns" marker Antigravity renders before its answer and
+  takes what follows. Works reliably in testing but is the most likely thing
+  to break on a UI redesign.
+- **Single-window assumption.** Only tested with one Antigravity window open.
+
+## What this deliberately does NOT do
+
+No unpacking of Antigravity's `app.asar`, no reading of stored auth tokens,
+no calling of internal/undocumented endpoints. Everything here operates
+through the same interface a human uses, which is why it doesn't carry the
+legal risk that reverse-engineering approaches do.
+
+## License
+
+MIT

package/dist/antigravity-client.js

@@ -0,0 +1,404 @@
+import { execSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const CDP_PORT = Number(process.env.ANTIGRAVITY_CDP_PORT || 9222);
+// All of these are selectable in Antigravity's model dropdown. If a model's
+// quota is exhausted, the send button stays disabled after selecting it —
+// selectModel() / pasteAndSend() fail fast with a clear error in that case
+// rather than hanging until timeout. Retry later or pick a different model.
+export const AVAILABLE_MODELS = [
+    "Gemini 3.5 Flash (Low)",
+    "Gemini 3.5 Flash (Medium)",
+    "Gemini 3.5 Flash (High)",
+    "Gemini 3.1 Pro (Low)",
+    "Gemini 3.1 Pro (High)",
+    "Claude Sonnet 4.6 (Thinking)",
+    "Claude Opus 4.6 (Thinking)",
+    "GPT-OSS 120B (Medium)",
+];
+// Antigravity itself bills via a pooled weekly/5-hour quota, not per token —
+// see getAntigravityQuota(). These are third-party API list prices (per 1M
+// tokens, researched mid-2026, newer than this tool author's model training
+// data) included only as a relative cost/capability signal for routing
+// decisions, not what you're actually billed inside Antigravity. Verify
+// independently before using this for real budgeting.
+export const MODEL_GUIDE = `
+Gemini 3.5 Flash ($1.50/$9 per 1M in/out) — fastest and cheapest of the group; strong coding/agentic benchmarks. Good default for quick, well-scoped tasks.
+Gemini 3.1 Pro ($2/$12) — adds a "thinking" mode for harder reasoning (ARC-AGI-2 ~77%); costlier for long (>200K token) context.
+Claude Sonnet 4.6 ($3/$15) — best-regarded for coding quality, computer-use, and multi-step agent workflows (SWE-bench ~80%).
+Claude Opus 4.6 ($5/$25, higher in fast mode) — strongest at complex, ambiguous, multi-step reasoning; the pick for legal/financial/research-grade analysis.
+GPT-OSS 120B (~$0.03-0.09/$0.10-0.40 — far cheaper than the rest) — open-weight, near-o4-mini reasoning, solid coding/tool-use. Good for high-volume or low-stakes tasks.
+
+Gemini models and Claude+GPT models draw from SEPARATE Antigravity quota pools — call getAntigravityQuota() first if unsure which pool has room.
+`.trim();
+export async function delegateToAntigravity(opts) {
+    const { task, model, timeoutMs = 120_000 } = opts;
+    await ensureAntigravityReady();
+    const target = await getMainPageTarget();
+    const session = new CdpSession(target.webSocketDebuggerUrl);
+    try {
+        await startNewConversation(session);
+        if (model)
+            await selectModel(session, model);
+        await pasteAndSend(session, task);
+        return await waitForReply(session, task, timeoutMs);
+    }
+    finally {
+        session.close();
+    }
+}
+export async function getAntigravityQuota() {
+    await ensureAntigravityReady();
+    const target = await getMainPageTarget();
+    const session = new CdpSession(target.webSocketDebuggerUrl);
+    try {
+        const raw = await openSettingsModelsTab(session);
+        return parseQuotaText(raw);
+    }
+    finally {
+        await closeSettings(session);
+        session.close();
+    }
+}
+async function openSettingsModelsTab(session) {
+    await session.evaluate(`
+    (() => {
+      const b = Array.from(document.querySelectorAll('button')).find(x => x.innerText && x.innerText.trim() === 'Settings');
+      if (b) b.click();
+      return true;
+    })()
+  `);
+    await sleep(1000);
+    await session.evaluate(`
+    (() => {
+      const b = Array.from(document.querySelectorAll('button, [role="tab"]')).find(x => (x.innerText||'').trim() === 'Models');
+      if (b) b.click();
+      return true;
+    })()
+  `);
+    await sleep(800);
+    const raw = await session.evaluate(`
+    (() => {
+      const all = Array.from(document.querySelectorAll('*'));
+      const hit = all.find(el => el.innerText && el.innerText.includes('Model Quota') && el.innerText.includes('Weekly Limit'));
+      return hit ? hit.innerText : null;
+    })()
+  `);
+    if (!raw)
+        throw new Error("Could not find the Model Quota panel in Antigravity's Settings.");
+    return raw;
+}
+async function closeSettings(session) {
+    await session.evaluate(`
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', bubbles: true, cancelable: true }))
+  `);
+    await sleep(400);
+}
+function parseQuotaText(raw) {
+    const lines = raw
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    const planLine = lines.find((l) => l.startsWith("Your Plan:"));
+    const plan = planLine ? planLine.replace("Your Plan:", "").trim() : null;
+    const groups = [];
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] !== "Weekly Limit")
+            continue;
+        const group = lines[i - 1];
+        let j = i + 1;
+        const weeklyStatusText = lines[j] ?? null;
+        j++;
+        const weeklyMatch = (lines[j] ?? "").match(/^(\d+)%$/);
+        const weeklyPercentRemaining = weeklyMatch ? Number(weeklyMatch[1]) : null;
+        if (weeklyMatch)
+            j++;
+        let fiveHourStatusText = null;
+        let fiveHourPercentRemaining = null;
+        if (lines[j] === "Five Hour Limit") {
+            j++;
+            fiveHourStatusText = lines[j] ?? null;
+            j++;
+            const fiveHourMatch = (lines[j] ?? "").match(/^(\d+)%$/);
+            if (fiveHourMatch)
+                fiveHourPercentRemaining = Number(fiveHourMatch[1]);
+        }
+        groups.push({ group, weeklyPercentRemaining, weeklyStatusText, fiveHourPercentRemaining, fiveHourStatusText });
+    }
+    return { plan, groups, raw };
+}
+// ---------- App lifecycle ----------
+function resolveAppPath() {
+    const candidates = [
+        process.env.ANTIGRAVITY_APP_PATH,
+        "/Applications/Antigravity.app",
+        path.join(os.homedir(), "Desktop", "Antigravity.app"),
+    ].filter((p) => !!p);
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    throw new Error("Could not find Antigravity.app. Set the ANTIGRAVITY_APP_PATH environment variable to its full path.");
+}
+async function isCdpAvailable() {
+    try {
+        const res = await fetch(`http://localhost:${CDP_PORT}/json/version`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function isAppRunningWithoutDebugPort() {
+    try {
+        execSync('pgrep -f "Antigravity.app/Contents/MacOS/Antigravity"', { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function quitApp() {
+    try {
+        execSync('osascript -e \'quit app "Antigravity"\'');
+    }
+    catch {
+        /* app may not have been running via a scriptable process */
+    }
+    try {
+        execSync('pkill -f "Antigravity.app/Contents/MacOS/Antigravity"');
+    }
+    catch {
+        /* already gone */
+    }
+}
+function launchWithDebugPort(appPath) {
+    const child = spawn("open", ["-a", appPath, "--args", `--remote-debugging-port=${CDP_PORT}`], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+async function waitFor(condition, timeoutMs, intervalMs = 500) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await condition())
+            return;
+        await sleep(intervalMs);
+    }
+    throw new Error("Timed out waiting for Antigravity to become ready");
+}
+export async function ensureAntigravityReady() {
+    if (await isCdpAvailable())
+        return;
+    // Antigravity only opens the debug port if launched with the flag. If it's
+    // already running without it, we have to restart it to attach.
+    if (isAppRunningWithoutDebugPort()) {
+        quitApp();
+        await sleep(1500);
+    }
+    const appPath = resolveAppPath();
+    launchWithDebugPort(appPath);
+    await waitFor(isCdpAvailable, 30_000);
+}
+async function fetchTargets() {
+    const res = await fetch(`http://localhost:${CDP_PORT}/json`);
+    return (await res.json());
+}
+function isMainPage(t) {
+    // The loading splash is a data: URL; the real UI is served locally by
+    // Antigravity's own language-server process over https://127.0.0.1:<port>.
+    return t.type === "page" && t.url.startsWith("https://127.0.0.1:");
+}
+async function getMainPageTarget() {
+    await waitFor(async () => (await fetchTargets()).some(isMainPage), 20_000);
+    const targets = await fetchTargets();
+    const target = targets.find(isMainPage);
+    if (!target)
+        throw new Error("Antigravity's main window did not appear in time.");
+    return target;
+}
+class CdpSession {
+    ws;
+    nextId = 1;
+    pending = new Map();
+    ready;
+    constructor(wsUrl) {
+        this.ws = new WebSocket(wsUrl);
+        this.ready = new Promise((resolve, reject) => {
+            this.ws.addEventListener("open", () => resolve());
+            this.ws.addEventListener("error", () => reject(new Error("CDP WebSocket connection failed")));
+        });
+        this.ws.addEventListener("message", (event) => {
+            const msg = JSON.parse(event.data);
+            if (msg.id && this.pending.has(msg.id)) {
+                this.pending.get(msg.id)(msg.result);
+                this.pending.delete(msg.id);
+            }
+        });
+    }
+    async send(method, params = {}) {
+        await this.ready;
+        const id = this.nextId++;
+        return new Promise((resolve) => {
+            this.pending.set(id, resolve);
+            this.ws.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    async evaluate(expression) {
+        const result = await this.send("Runtime.evaluate", { expression, returnByValue: true });
+        if (result?.exceptionDetails) {
+            throw new Error(`Antigravity page script error: ${JSON.stringify(result.exceptionDetails)}`);
+        }
+        return result?.result?.value;
+    }
+    close() {
+        this.ws.close();
+    }
+}
+// ---------- UI actions (selectors verified against Antigravity 2.2.1) ----------
+async function startNewConversation(session) {
+    await session.evaluate(`
+    (() => {
+      const btns = Array.from(document.querySelectorAll('button'));
+      const b = btns.find(x => x.innerText && x.innerText.trim() === 'New Conversation');
+      if (b) b.click();
+      return true;
+    })()
+  `);
+    await sleep(1000);
+}
+async function selectModel(session, modelName) {
+    await session.evaluate(`
+    (() => {
+      const btns = Array.from(document.querySelectorAll('button'));
+      const b = btns.find(x => (x.getAttribute('aria-label')||'').startsWith('Select model'));
+      if (b) b.click();
+      return true;
+    })()
+  `);
+    await sleep(600);
+    const result = await session.evaluate(`
+    (() => {
+      const btns = Array.from(document.querySelectorAll('button'));
+      const target = btns.find(b => b.innerText && b.innerText.includes(${JSON.stringify(modelName)}) && b.className.includes('popover-item'));
+      if (!target) return { error: 'model option not found in dropdown' };
+      target.click();
+      return { clicked: target.innerText.slice(0, 60) };
+    })()
+  `);
+    if (result?.error) {
+        throw new Error(`Could not select model "${modelName}": ${result.error}`);
+    }
+    await sleep(500);
+}
+async function pasteAndSend(session, taskText) {
+    // Antigravity's message box is a Lexical rich-text editor, not a plain
+    // textarea. Setting its text directly doesn't update Lexical's internal
+    // state, so we simulate a real paste event instead — same as a human
+    // pasting text, which the editor is built to handle correctly.
+    //
+    // Paste inserts at the current selection rather than replacing the whole
+    // box, and "New Conversation" does NOT clear a pre-existing unsent draft
+    // (confirmed the hard way: a leftover draft silently glued itself onto a
+    // later task). So we explicitly select all existing content first —
+    // that makes the paste replace it instead of appending to it.
+    const pasteResult = await session.evaluate(`
+    (() => {
+      const editable = document.querySelector('[contenteditable="true"][aria-label="Message input"]');
+      if (!editable) return { error: 'message input not found' };
+      editable.focus();
+      const range = document.createRange();
+      range.selectNodeContents(editable);
+      const selection = window.getSelection();
+      selection.removeAllRanges();
+      selection.addRange(range);
+      const dt = new DataTransfer();
+      dt.setData('text/plain', ${JSON.stringify(taskText)});
+      const pasteEvent = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true });
+      editable.dispatchEvent(pasteEvent);
+      return { dispatched: true };
+    })()
+  `);
+    if (pasteResult?.error)
+        throw new Error(pasteResult.error);
+    await sleep(1000);
+    // Safety net for the exact bug above: if the box holds far more text than
+    // we just sent, something didn't get replaced. Refuse to send a message
+    // that isn't the one we were asked to send.
+    const landedLength = await session.evaluate(`
+    (() => {
+      const editable = document.querySelector('[contenteditable="true"][aria-label="Message input"]');
+      return editable ? editable.innerText.length : -1;
+    })()
+  `);
+    if (landedLength < 0)
+        throw new Error("message input disappeared before send");
+    if (landedLength > taskText.length + 1000) {
+        throw new Error(`Refusing to send: message box has ${landedLength} chars but the task was only ${taskText.length}. ` +
+            "The box likely still has leftover content that wasn't replaced.");
+    }
+    const clickResult = await session.evaluate(`
+    (() => {
+      const btn = document.querySelector('[data-testid="send-button"]');
+      if (!btn) return { error: 'send button not found' };
+      if (btn.disabled) return { error: 'send button is disabled' };
+      btn.click();
+      return { clicked: true };
+    })()
+  `);
+    if (clickResult?.error) {
+        // A disabled send button right after switching models usually means that
+        // model's quota is temporarily exhausted (observed with Claude Opus after
+        // heavy use — selectable in the dropdown, but send stays disabled until
+        // quota resets or you pick a different model).
+        throw new Error(`${clickResult.error}. If you just switched models, its quota may be temporarily exhausted — try again later or pick a different model.`);
+    }
+}
+async function waitForReply(session, taskText, timeoutMs) {
+    const needle = JSON.stringify(taskText.slice(0, 200));
+    const start = Date.now();
+    let lastText = "";
+    let stableCount = 0;
+    while (Date.now() - start < timeoutMs) {
+        await sleep(1200);
+        const threadText = await session.evaluate(`
+      (() => {
+        const all = Array.from(document.querySelectorAll('*'));
+        const hit = all.findLast(el => el.children.length === 0 && el.innerText && el.innerText.includes(${needle}));
+        if (!hit) return '';
+        let container = hit;
+        for (let i = 0; i < 14 && container.parentElement; i++) container = container.parentElement;
+        return container.innerText;
+      })()
+    `);
+        if (!threadText)
+            continue;
+        if (threadText === lastText) {
+            stableCount++;
+            // Require the "Thought for Ns" marker so we don't return early on the
+            // brief window right after sending, before Antigravity starts replying.
+            if (stableCount >= 2 && /Thought for/.test(threadText)) {
+                return extractReply(threadText, taskText);
+            }
+        }
+        else {
+            stableCount = 0;
+            lastText = threadText;
+        }
+    }
+    throw new Error(`Timed out after ${timeoutMs}ms waiting for Antigravity's reply.`);
+}
+function extractReply(threadText, taskText) {
+    const needle = taskText.slice(0, 200);
+    const idx = threadText.lastIndexOf(needle);
+    const after = idx >= 0 ? threadText.slice(idx) : threadText;
+    const thoughtMatch = after.match(/Thought for[^\n]*\n+/);
+    let rest = thoughtMatch ? after.slice(after.indexOf(thoughtMatch[0]) + thoughtMatch[0].length) : after;
+    rest = rest.replace(/\n+\d{1,2}:\d{2}\s*$/, "").trim();
+    return rest;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/mcp-server.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { AVAILABLE_MODELS, MODEL_GUIDE, delegateToAntigravity, getAntigravityQuota } from "./antigravity-client.js";
+const server = new McpServer({
+    name: "supergravity-mcp",
+    version: "0.1.0",
+});
+server.registerTool("delegate_to_antigravity", {
+    title: "Delegate to Antigravity",
+    description: "Send a task to the Google Antigravity desktop app and return its reply. " +
+        "Drives the real, already-logged-in app UI (types into its chat box and reads the response) — " +
+        "does not touch Antigravity's internals or credentials. Requires Antigravity.app to be installed " +
+        "and signed in on this machine.",
+    inputSchema: {
+        task: z.string().describe("The task, question, or instruction to send to Antigravity."),
+        model: z
+            .enum(AVAILABLE_MODELS)
+            .optional()
+            .describe("Which model Antigravity should use. If omitted, uses whatever model is currently selected in the app.\n\n" +
+            MODEL_GUIDE),
+        timeoutMs: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Max time to wait for a reply, in milliseconds. Default 120000 (2 minutes)."),
+    },
+}, async ({ task, model, timeoutMs }) => {
+    try {
+        const reply = await delegateToAntigravity({ task, model, timeoutMs });
+        return { content: [{ type: "text", text: reply }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Antigravity delegation failed: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("get_antigravity_quota", {
+    title: "Get Antigravity quota",
+    description: "Read Antigravity's remaining model quota from its Settings > Models panel. " +
+        "Gemini models and Claude+GPT models draw from separate pools, each with a weekly limit and a " +
+        "5-hour limit. Check this before delegating to Claude/GPT-OSS models if a prior call failed with " +
+        "a 'send button is disabled' error, or to decide which model family has room before delegating.",
+    inputSchema: {},
+}, async () => {
+    try {
+        const status = await getAntigravityQuota();
+        return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Could not read Antigravity quota: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "supergravity-mcp",
+  "version": "0.1.0",
+  "description": "MCP server that lets Claude (or any MCP client) delegate tasks to the Google Antigravity desktop app by driving its real UI — no CLI, no reverse engineering. Built for Intel Macs Antigravity's own CLI doesn't support.",
+  "type": "module",
+  "bin": {
+    "supergravity-mcp": "dist/mcp-server.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/mcp-server.js"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/presidentrice/supergravity-mcp.git"
+  },
+  "homepage": "https://github.com/presidentrice/supergravity-mcp",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}