supergravity-mcp 0.1.5 → 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";
@@ -44,26 +44,160 @@ function withLock(fn) {
 }
 export async function delegateToAntigravity(opts) {
     return withLock(async () => {
-        const { task, model, timeoutMs = 120_000 } = opts;
         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 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);
+        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();
+    }
+}
+function openNewAntigravityWindow() {
+    try {
+        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;
+    }
+    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 {
-            // 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);
         }
         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 () => {

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.5",
+  "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,15 +1,14 @@
 ---
 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 server's `delegate_to_antigravity` /
-`get_antigravity_quota` 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.
+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.
 
 ## When to trigger
 
@@ -76,6 +75,38 @@ 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