supergravity-mcp 0.1.3 → 0.2.0

package/README.md

@@ -70,6 +70,38 @@ npm run build
   (see `AVAILABLE_MODELS` in `src/antigravity-client.ts`).
 - `timeoutMs` — optional, default 120000 (2 minutes).
 
+If the task generates files (images, documents, etc.), the result also
+includes a real filesystem path — Antigravity stores each conversation's
+files at `~/.gemini/antigravity/brain/<conversation-id>/` on disk, confirmed
+directly (not documented anywhere by Google). No need to fetch anything
+through Antigravity's local server; just read the file.
+
+### `delegate_to_antigravity_batch(tasks)`
+
+Runs several independent tasks at once, each in its own Antigravity window —
+genuinely concurrent, not queued. Confirmed with two simultaneous
+~200-word generations that both completed correctly in the same ~16s window.
+Opens extra windows automatically as needed (macOS's "New Window" menu
+command via System Events, with a fallback for when zero windows are open).
+
+Requires Accessibility permission for whatever process runs this (System
+Settings > Privacy & Security > Accessibility) — macOS only. Don't run this
+at the same time as a separate `delegate_to_antigravity` call; window
+allocation between the two isn't coordinated.
+
+```ts
+delegateToAntigravityBatch([
+  { task: "..." },
+  { task: "...", model: "Claude Sonnet 4.6 (Thinking)" },
+]);
+```
+
+### `list_antigravity_files(limit?)`
+
+Every file Antigravity has generated, across every conversation, most recent
+first — not scoped to a single delegate call. Useful for finding something
+generated earlier in this session or a past one.
+
 ### `get_antigravity_quota()`
 
 Reads Antigravity's Settings > Models panel and returns remaining quota —

package/dist/antigravity-client.js

@@ -1,4 +1,4 @@
-import { execSync, spawn } from "node:child_process";
+import { execFileSync, execSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -32,34 +32,187 @@ GPT-OSS 120B (~$0.03-0.09/$0.10-0.40 — far cheaper than the rest) — open-wei
 
 Gemini models and Claude+GPT models draw from SEPARATE Antigravity quota pools — call getAntigravityQuota() first if unsure which pool has room.
 `.trim();
+// Antigravity is a single window shared by every call. Two delegations
+// running at once would type into and read from the same conversation,
+// corrupting both. Every entry point below is serialized through this lock
+// so calls queue up instead of racing each other.
+let lock = Promise.resolve();
+function withLock(fn) {
+    const run = lock.then(fn, fn);
+    lock = run.then(() => undefined, () => undefined);
+    return run;
+}
 export async function delegateToAntigravity(opts) {
-    const { task, model, timeoutMs = 120_000 } = opts;
+    return withLock(async () => {
+        await ensureAntigravityReady();
+        const target = await getMainPageTarget();
+        return runOnTarget(target, opts);
+    });
+}
+/**
+ * Run several tasks at once, each in its own Antigravity window - confirmed
+ * these genuinely run concurrently (not just dispatched together then
+ * queued), verified with two simultaneous ~200-word generations that both
+ * completed correctly in the same ~16s window.
+ *
+ * macOS only: opening additional windows uses the "New Window" menu command
+ * via System Events, which requires Accessibility permission (System
+ * Settings > Privacy & Security > Accessibility) for whatever process is
+ * running this. Don't mix this with a concurrent single delegateToAntigravity
+ * call - window allocation between the two isn't coordinated, so they could
+ * both grab the same window.
+ */
+export async function delegateToAntigravityBatch(tasks) {
+    if (tasks.length === 0)
+        return [];
     await ensureAntigravityReady();
-    const target = await getMainPageTarget();
+    const targets = await ensureWindowCount(tasks.length);
+    return Promise.all(tasks.map((opts, i) => runOnTarget(targets[i], opts)));
+}
+async function runOnTarget(target, opts) {
+    const { task, model, timeoutMs = 120_000 } = opts;
     const session = new CdpSession(target.webSocketDebuggerUrl);
     try {
+        // The CDP debug port opens before Antigravity's own UI finishes mounting
+        // (its window loads content from a local server that itself needs a
+        // moment to boot). On a cold start this can leave the chat input
+        // missing for several seconds after we've already connected.
+        await waitForChatReady(session);
         await startNewConversation(session);
         if (model)
             await selectModel(session, model);
         await pasteAndSend(session, task);
-        return await waitForReply(session, task, timeoutMs);
+        const reply = await waitForReply(session, task, timeoutMs);
+        const conversationId = await getConversationId(session);
+        const localFilesDir = conversationId ? resolveBrainDir(conversationId) : null;
+        return { reply, conversationId, localFilesDir };
     }
     finally {
         session.close();
     }
 }
-export async function getAntigravityQuota() {
-    await ensureAntigravityReady();
-    const target = await getMainPageTarget();
-    const session = new CdpSession(target.webSocketDebuggerUrl);
+function openNewAntigravityWindow() {
     try {
-        const raw = await openSettingsModelsTab(session);
-        return parseQuotaText(raw);
+        execFileSync("osascript", [
+            "-e",
+            'tell application "System Events" to tell process "Antigravity" to click menu item "New Window" of menu "File" of menu bar 1',
+        ]);
+        return;
     }
-    finally {
-        await closeSettings(session);
-        session.close();
+    catch (err) {
+        // With zero windows open, System Events can't find "Antigravity" as an
+        // addressable process at all (confirmed directly - error -600, "app is
+        // not open" - even though the underlying process is genuinely running).
+        // macOS's normal app-reopen convention handles this: relaunching an
+        // already-running, windowless app creates a fresh window instead of
+        // just focusing an existing one.
+        try {
+            execFileSync("open", ["-a", resolveAppPath()]);
+            return;
+        }
+        catch {
+            throw new Error(`Could not open a new Antigravity window (needed to run tasks in parallel): ${err.message}. ` +
+                "If Antigravity has at least one window open, this needs Accessibility permission - grant it in " +
+                "System Settings > Privacy & Security > Accessibility for whatever is running this process. macOS only.");
+        }
+    }
+}
+async function ensureWindowCount(n) {
+    // No initial wait-for-a-window here: unlike getMainPageTarget() (used right
+    // after launching the app, where a window is guaranteed to appear on its
+    // own), this can run against an already-running app with zero windows open
+    // (user closed them all) - nothing creates that first window except us.
+    let pageTargets = (await fetchTargets()).filter(isMainPage);
+    while (pageTargets.length < n) {
+        const beforeCount = pageTargets.length;
+        openNewAntigravityWindow();
+        // wait for a genuinely new target to register, not a fixed guess at timing
+        await waitFor(async () => (await fetchTargets()).filter(isMainPage).length > beforeCount, 15_000);
+        pageTargets = (await fetchTargets()).filter(isMainPage);
+    }
+    const targets = pageTargets.slice(0, n);
+    // A freshly opened window can take longer to mount its chat UI than any
+    // fixed delay reliably covers (this is exactly what broke on the first
+    // real test - the 3rd window still wasn't ready 45s in). Confirm every
+    // window individually before handing any of them out.
+    await Promise.all(targets.map(async (target) => {
+        const session = new CdpSession(target.webSocketDebuggerUrl);
+        try {
+            await waitForChatReady(session);
+        }
+        finally {
+            session.close();
+        }
+    }));
+    return targets;
+}
+async function getConversationId(session) {
+    const href = await session.evaluate("location.href");
+    const match = href.match(/\/c\/([a-f0-9-]{36})/i);
+    return match ? match[1] : null;
+}
+// Antigravity (built on the Gemini CLI/Windsurf lineage) stores every
+// conversation's generated files under ~/.gemini/antigravity/brain/<id>/ on
+// disk - confirmed directly, not documented anywhere. This is real
+// filesystem storage, separate from the local HTTPS server that serves it to
+// the UI, so it's readable without going through that server at all.
+// os.homedir() resolves per-user at runtime - not specific to any one machine.
+export function getAntigravityBrainDir() {
+    return path.join(os.homedir(), ".gemini", "antigravity", "brain");
+}
+function resolveBrainDir(conversationId) {
+    const dir = path.join(getAntigravityBrainDir(), conversationId);
+    return fs.existsSync(dir) ? dir : null;
+}
+/**
+ * Every file Antigravity has ever generated, across every conversation, most
+ * recent first - not scoped to any single delegate_to_antigravity call.
+ */
+export function listAntigravityFiles(limit = 20) {
+    const brainDir = getAntigravityBrainDir();
+    if (!fs.existsSync(brainDir))
+        return [];
+    const results = [];
+    for (const conversationId of fs.readdirSync(brainDir)) {
+        const convDir = path.join(brainDir, conversationId);
+        let entries;
+        try {
+            entries = fs.readdirSync(convDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // skip Antigravity's own internal bookkeeping (.system_generated, etc.)
+            if (entry.name.startsWith(".") || !entry.isFile())
+                continue;
+            const filePath = path.join(convDir, entry.name);
+            const mtimeMs = fs.statSync(filePath).mtimeMs;
+            results.push({
+                path: filePath,
+                conversationId,
+                filename: entry.name,
+                modifiedAt: new Date(mtimeMs).toISOString(),
+            });
+        }
     }
+    results.sort((a, b) => new Date(b.modifiedAt).getTime() - new Date(a.modifiedAt).getTime());
+    return results.slice(0, limit);
+}
+export async function getAntigravityQuota() {
+    return withLock(async () => {
+        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(`
@@ -258,6 +411,26 @@ class CdpSession {
     }
 }
 // ---------- UI actions (selectors verified against Antigravity 2.2.1) ----------
+async function waitForChatReady(session, timeoutMs = 45_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const state = await session.evaluate(`
+      (() => {
+        if (document.querySelector('[contenteditable="true"][aria-label="Message input"]')) return 'ready';
+        const text = document.body.innerText || '';
+        if (text.includes('Continue with Google') || text.includes('Welcome to Antigravity')) return 'needs-signin';
+        return 'loading';
+      })()
+    `);
+        if (state === "ready")
+            return;
+        if (state === "needs-signin") {
+            throw new Error("Antigravity needs you to sign in. Open the app and click \"Continue with Google\", then try again — this can't be automated (it's your Google login).");
+        }
+        await sleep(500);
+    }
+    throw new Error(`Antigravity's chat UI didn't finish loading within ${timeoutMs}ms of launch. It may still be starting up — try again in a few seconds.`);
+}
 async function startNewConversation(session) {
     await session.evaluate(`
     (() => {
@@ -377,10 +550,15 @@ async function waitForReply(session, taskText, timeoutMs) {
             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);
+            // Two consecutive stable reads plus actual reply content (not just our
+            // own sent message sitting there) means it's done. "Thought for Ns" is
+            // NOT a reliable signal — Antigravity skips it entirely for fast/simple
+            // answers, so requiring it caused real replies to be missed until
+            // timeout even though the answer was already on screen.
+            if (stableCount >= 2) {
+                const candidate = extractReply(threadText, taskText);
+                if (candidate)
+                    return candidate;
             }
         }
         else {
@@ -391,13 +569,26 @@ async function waitForReply(session, taskText, timeoutMs) {
     throw new Error(`Timed out after ${timeoutMs}ms waiting for Antigravity's reply.`);
 }
 function extractReply(threadText, taskText) {
+    // We only search on the first 200 chars (waitForReply's DOM lookup does the
+    // same, to keep every poll's evaluate() call cheap on huge tasks) - but
+    // slicing by that same truncated length left a tail of our own message
+    // behind for anything longer than 200 chars. Instead, find where OUR
+    // message actually ends by locating the timestamp Antigravity renders
+    // immediately after it, which appears regardless of message length.
     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;
+    const searchFrom = idx >= 0 ? idx + needle.length : 0;
+    const closingTimestamp = threadText.slice(searchFrom).match(/\d{1,2}:\d{2}/);
+    let after = closingTimestamp
+        ? threadText.slice(searchFrom + closingTimestamp.index + closingTimestamp[0].length)
+        : threadText.slice(searchFrom);
+    // strip the "Thought for Ns" line when present - not always there
+    const thoughtMatch = after.match(/^\n*Thought for[^\n]*\n+/);
+    if (thoughtMatch)
+        after = after.slice(thoughtMatch[0].length);
+    // strip the trailing timestamp under the reply itself
+    after = after.replace(/\n+\d{1,2}:\d{2}\s*$/, "");
+    return after.trim();
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/mcp-server.js

@@ -2,7 +2,7 @@
 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";
+import { AVAILABLE_MODELS, MODEL_GUIDE, delegateToAntigravity, delegateToAntigravityBatch, getAntigravityQuota, listAntigravityFiles, } from "./antigravity-client.js";
 const server = new McpServer({
     name: "supergravity-mcp",
     version: "0.1.0",
@@ -12,7 +12,9 @@ server.registerTool("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.",
+        "and signed in on this machine. If the task produces files (generated images, edited code, etc.), " +
+        "the response includes a local filesystem path where they actually live — check that path directly " +
+        "instead of trying to fetch anything through Antigravity's UI or local server.",
     inputSchema: {
         task: z.string().describe("The task, question, or instruction to send to Antigravity."),
         model: z
@@ -29,8 +31,11 @@ server.registerTool("delegate_to_antigravity", {
     },
 }, async ({ task, model, timeoutMs }) => {
     try {
-        const reply = await delegateToAntigravity({ task, model, timeoutMs });
-        return { content: [{ type: "text", text: reply }] };
+        const result = await delegateToAntigravity({ task, model, timeoutMs });
+        const text = result.localFilesDir
+            ? `${result.reply}\n\n(Any files this produced are on disk at: ${result.localFilesDir})`
+            : result.reply;
+        return { content: [{ type: "text", text }] };
     }
     catch (err) {
         return {
@@ -39,6 +44,46 @@ server.registerTool("delegate_to_antigravity", {
         };
     }
 });
+server.registerTool("delegate_to_antigravity_batch", {
+    title: "Delegate multiple tasks to Antigravity in parallel",
+    description: "Run several tasks at once, each in its own Antigravity window - genuinely concurrent, not queued " +
+        "one after another (verified: two simultaneous ~200-word generations both completed correctly in the " +
+        "same ~16s window). Use this instead of multiple delegate_to_antigravity calls when tasks are " +
+        "independent of each other (e.g. separate branches, unrelated questions). macOS only: opening extra " +
+        "windows needs Accessibility permission (System Settings > Privacy & Security > Accessibility) for " +
+        "whatever is running this. Don't call this at the same time as a separate delegate_to_antigravity call - " +
+        "window allocation between them isn't coordinated.",
+    inputSchema: {
+        tasks: z
+            .array(z.object({
+            task: z.string().describe("The task, question, or instruction to send to Antigravity."),
+            model: z
+                .enum(AVAILABLE_MODELS)
+                .optional()
+                .describe("Which model this specific task should use. If omitted, uses whatever is currently selected."),
+            timeoutMs: z.number().int().positive().optional().describe("Max time to wait for this task's reply."),
+        }))
+            .min(1)
+            .describe("One entry per task, each running in its own window at the same time."),
+    },
+}, async ({ tasks }) => {
+    try {
+        const results = await delegateToAntigravityBatch(tasks);
+        const text = results
+            .map((r, i) => {
+            const files = r.localFilesDir ? `\n(Files on disk at: ${r.localFilesDir})` : "";
+            return `--- Task ${i + 1} ---\n${r.reply}${files}`;
+        })
+            .join("\n\n");
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Batch 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. " +
@@ -58,5 +103,25 @@ server.registerTool("get_antigravity_quota", {
         };
     }
 });
+server.registerTool("list_antigravity_files", {
+    title: "List Antigravity-generated files",
+    description: "List files Antigravity has generated (images, documents, etc.), most recent first, across ALL " +
+        "conversations - not just the most recent delegate_to_antigravity call. Use this to find something " +
+        "generated earlier in this session or in a past one. Returns real filesystem paths, readable directly.",
+    inputSchema: {
+        limit: z.number().int().positive().optional().describe("Max number of files to return. Default 20."),
+    },
+}, async ({ limit }) => {
+    try {
+        const files = listAntigravityFiles(limit);
+        return { content: [{ type: "text", text: JSON.stringify(files, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Could not list Antigravity files: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supergravity-mcp",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "🚀 MCP server that lets Claude (or any MCP client) delegate tasks to Google's Antigravity desktop app 🌌. Built for Intel Macs 💻 that Antigravity's own CLI doesn't support.",
   "type": "module",
   "bin": {

package/skills/delegate/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: delegate
-description: Use when the user wants to delegate a task to Google's Antigravity desktop app — phrases like "use gemini", "ask antigravity", "have claude in antigravity do this", "offload this", or "check antigravity's quota". Explains which model to pick and how to handle a disabled-send-button error. Requires the supergravity MCP server (delegate_to_antigravity, get_antigravity_quota tools) to be connected.
+description: Use when the user wants to delegate a task to Google's Antigravity desktop app — phrases like "use gemini", "ask antigravity", "have claude in antigravity do this", "offload this", "run N agents/tasks in parallel", or "check antigravity's quota". Explains which model to pick, when to use the batch/parallel tool, and how to handle a disabled-send-button error. Requires the supergravity MCP server (delegate_to_antigravity, delegate_to_antigravity_batch, get_antigravity_quota, list_antigravity_files tools) to be connected.
 ---
 
 # delegate
 
 Antigravity is a separate AI desktop app (Google's). This skill runs tasks
-through it via the `supergravity-mcp` MCP server, instead of answering
+through it via the `supergravity` MCP server's tools, instead of answering
 yourself — useful when the user explicitly asks to use it, wants a second
 opinion from a different model family, or wants to offload work.
 
@@ -18,6 +18,21 @@ Any explicit ask to use Antigravity or one of the models it hosts:
 generic requests that don't name Antigravity or one of its models — just
 answer normally.
 
+Load this skill *before* calling either tool the first time in a
+conversation, not after something already went wrong — the model-picking and
+quota-pool guidance below changes which tool call you should even make.
+
+## You don't need to check if Antigravity is running
+
+`delegate_to_antigravity` launches Antigravity itself if it isn't already
+open, and waits for its chat UI to finish loading before typing anything —
+you don't need to check first or tell the user to open it. Just call the
+tool. The only implication: the very first call in a session can take
+15-30+ seconds longer than normal (cold app launch) before anything visible
+happens. If a call fails specifically because the app couldn't be found at
+all, the error names the exact env var (`ANTIGRAVITY_APP_PATH`) to fix it —
+that's a real install problem, not something to retry.
+
 ## Picking a model
 
 If the user names a specific model ("use claude opus", "use gemini flash"),
@@ -44,6 +59,54 @@ until it refreshes — don't retry the same model. Instead:
 3. Otherwise, tell the user which pool is out and when it refreshes — don't
    silently fall back without saying so if they asked for a specific model.
 
+## Code-editing tasks: verify with the filesystem, not the reply text
+
+If the task involves editing code, Antigravity works inside a real project
+folder on disk (its "Projects" sidebar is literal directories, same
+filesystem you already have access to) — it actually writes the files, it
+doesn't just describe changes in chat. Its reply text is a narrative summary
+written by the model, not the deliverable, and can be vague or incomplete
+("Updated the function as requested").
+
+So after a code-editing delegation, don't parse the reply for specifics —
+go check the real files yourself: `git diff`, `git status`, or just read the
+file. You have direct filesystem access on this machine; use it instead of
+trusting prose. Only fall back to the reply text for context Antigravity
+wouldn't have written to disk (its reasoning, or a plain Q&A task with no
+files involved).
+
+## Generated files (images, artifacts) - same idea
+
+If the reply mentions it made an image or other file, the response also
+includes a real filesystem path (`~/.gemini/antigravity/brain/<conversation
+id>/`) — read the file directly from there rather than trying to fetch it
+through Antigravity's UI or local server. That directory can occasionally
+hold files from an earlier conversation too (Antigravity sometimes reuses a
+conversation ID) — if more than one file is present, each filename ends in
+a millisecond timestamp, so sort by that (or file mtime) to find the one
+this task actually produced.
+
+## Running multiple tasks at once
+
+If the user wants several independent things done at the same time ("spin up
+3 agents to work on different branches", "ask it these 5 questions"), use
+`delegate_to_antigravity_batch` with one entry per task instead of calling
+`delegate_to_antigravity` several times. This genuinely runs them
+concurrently, each in its own Antigravity window - confirmed with real
+simultaneous multi-paragraph generations that both completed correctly in
+the same ~16s window, not queued one after another.
+
+Only use batch when the tasks are actually independent of each other (they
+can't see or depend on each other's output, since they're separate
+conversations). For a multi-step task where step 2 needs step 1's result,
+use sequential `delegate_to_antigravity` calls instead.
+
+macOS only - opening extra windows needs Accessibility permission for
+whatever process is running this (System Settings > Privacy & Security >
+Accessibility). If that's missing, the error says so directly. Don't run a
+batch call and a single `delegate_to_antigravity` call at the same time -
+they don't coordinate which window they're using.
+
 ## Other failure modes
 
 - Antigravity not installed / not found: the error will say so — tell the