supergravity-mcp 0.1.3 → 0.1.5

package/dist/antigravity-client.js

@@ -32,34 +32,53 @@ 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;
-    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();
-    }
+    return withLock(async () => {
+        const { task, model, timeoutMs = 120_000 } = opts;
+        await ensureAntigravityReady();
+        const target = await getMainPageTarget();
+        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();
+        }
+    });
 }
 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();
-    }
+    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 +277,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 +416,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 +435,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supergravity-mcp",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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

@@ -6,9 +6,10 @@ description: Use when the user wants to delegate a task to Google's Antigravity
 # 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
-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 `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.
 
 ## When to trigger
 
@@ -18,6 +19,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 +60,22 @@ 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).
+
 ## Other failure modes
 
 - Antigravity not installed / not found: the error will say so — tell the