antigravity-mobile-proxy 0.1.6 → 0.1.7

package/.next/standalone/lib/scraper/ide-artifacts.ts

@@ -0,0 +1,212 @@
+/**
+ * Scrapes the artifact list directly from the Antigravity IDE's conversation panel.
+ *
+ * The IDE maintains a "tooltip-artifacts" toggle button in the input toolbar.
+ * Clicking it reveals a section headed "Artifacts (N Files for Conversation)"
+ * with rows showing artifact names and last-updated timestamps.
+ *
+ * By scraping this section we get the EXACT artifacts for the current
+ * conversation — no more cross-conversation mixing.
+ */
+
+import type { ProxyContext } from '../types';
+import { logger } from '../logger';
+
+export interface IdeArtifact {
+  /** Display name, e.g. "task.md" or "Pricing Blue Cards" */
+  name: string;
+  /** Raw timestamp text from the IDE, e.g. "Mar 10 11:21 PM" */
+  lastUpdated: string | null;
+  /** Whether this looks like a file (has an extension) */
+  isFile: boolean;
+}
+
+export interface IdeArtifactResult {
+  /** Total count stated in the section header */
+  totalCount: number;
+  /** Scraped artifact entries */
+  artifacts: IdeArtifact[];
+  /** The conversation title at the time of scraping */
+  conversationTitle: string | null;
+}
+
+/**
+ * Get the list of artifacts from the IDE's conversation panel.
+ *
+ * Strategy:
+ *  1. Check whether the artifact section is already visible.
+ *  2. If not, click `[data-tooltip-id="tooltip-artifacts"]` to toggle it open.
+ *  3. Parse the rows to extract artifact names and timestamps.
+ *  4. Close the section again (toggle) to leave the IDE clean.
+ */
+export async function getIdeArtifacts(ctx: ProxyContext): Promise<IdeArtifactResult> {
+  if (!ctx.workbenchPage) {
+    logger.info('[IdeArtifacts] No active workbench page.');
+    return { totalCount: 0, artifacts: [], conversationTitle: null };
+  }
+
+  try {
+    const result = await ctx.workbenchPage.evaluate(async () => {
+      const panel = document.querySelector('.antigravity-agent-side-panel');
+      if (!panel) return { error: 'No agent panel found' };
+
+      // Get current conversation title
+      const titleEl = panel.querySelector('span.font-semibold.text-ide-text-color');
+      const conversationTitle = titleEl?.textContent?.trim() || null;
+
+      // Check whether the artifact section is already open
+      const findArtifactHeader = (): Element | null => {
+        for (const el of panel.querySelectorAll('*')) {
+          const t = (el.textContent || '').trim();
+          if (
+            t.startsWith('Artifacts (') &&
+            t.includes('Files') &&
+            el.children.length <= 3
+          ) {
+            return el;
+          }
+        }
+        return null;
+      };
+
+      let header = findArtifactHeader();
+      let didOpen = false;
+
+      if (!header) {
+        // Click the artifact button to open the section
+        const btn = panel.querySelector('[data-tooltip-id="tooltip-artifacts"]');
+        if (!btn) return { error: 'No artifact button (tooltip-artifacts) found' };
+
+        (btn as HTMLElement).click();
+        await new Promise(r => setTimeout(r, 1500));
+        header = findArtifactHeader();
+        didOpen = true;
+      }
+
+      if (!header) {
+        return { error: 'Artifact section did not appear after clicking' };
+      }
+
+      // Parse total count from header like "Artifacts (15 Files for Conversation)"
+      const headerText = header.textContent?.trim() || '';
+      const countMatch = headerText.match(/Artifacts\s*\((\d+)\s*Files?/);
+      const totalCount = countMatch ? parseInt(countMatch[1], 10) : 0;
+
+      // Find the section container — walk up until we find the container
+      // that holds the header AND the file rows
+      let section = header as HTMLElement;
+      for (let i = 0; i < 8; i++) {
+        if (!section.parentElement) break;
+        section = section.parentElement;
+        const text = section.textContent || '';
+        if (text.includes('Artifact Name') && text.includes('Last Updated')) {
+          break;
+        }
+      }
+
+      // Extract artifact rows — each row has a name and a date
+      // Strategy: find all visible row-like flex containers within the section
+      const rows = section.querySelectorAll(
+        '.flex.w-full.flex-row.items-center.justify-between'
+      );
+
+      const artifacts: Array<{ name: string; lastUpdated: string | null }> = [];
+
+      for (const row of rows) {
+        const cells = row.children;
+        if (cells.length < 2) continue;
+
+        const nameText = (cells[0].textContent || '').trim();
+        const dateText = (cells[1].textContent || '').trim();
+
+        // Skip the header row itself
+        if (nameText === 'Artifact Name' || !nameText) continue;
+
+        artifacts.push({ name: nameText, lastUpdated: dateText || null });
+      }
+
+      // Fallback: if no rows found via flex layout, try extracting from text nodes
+      if (artifacts.length === 0) {
+        // Use TreeWalker to find file-name and date text nodes
+        const walker = document.createTreeWalker(section, NodeFilter.SHOW_TEXT);
+        const allTexts: string[] = [];
+        while (walker.nextNode()) {
+          const t = walker.currentNode.textContent?.trim();
+          if (t && t.length > 0) allTexts.push(t);
+        }
+
+        // Parse pairs: artifact name followed by date
+        for (let i = 0; i < allTexts.length; i++) {
+          const text = allTexts[i];
+          // Skip header/control texts
+          if (
+            text === 'Artifact Name' ||
+            text === 'Last Updated' ||
+            text.startsWith('Artifacts (') ||
+            text === 'Review Changes'
+          ) {
+            continue;
+          }
+
+          // Check if this has a date pattern like "Mar 10 11:21 PM"
+          const dateMatch = text.match(
+            /\(([A-Z][a-z]{2}\s+\d{1,2}\s+\d{1,2}:\d{2}\s*(?:AM|PM)?)\)$/
+          );
+          if (dateMatch) {
+            const name = text.replace(dateMatch[0], '').trim();
+            artifacts.push({ name, lastUpdated: dateMatch[1] });
+          } else if (
+            text.match(
+              /\.(md|json|txt|ts|tsx|js|jsx|css|html|yaml|yml|py|sh)$/
+            )
+          ) {
+            // It's a file name — check if next text is a date
+            const nextText = allTexts[i + 1] || '';
+            const nextDate = nextText.match(
+              /^[A-Z][a-z]{2}\s+\d{1,2}\s+\d{1,2}:\d{2}/
+            );
+            artifacts.push({
+              name: text,
+              lastUpdated: nextDate ? nextText : null,
+            });
+            if (nextDate) i++; // Skip the date we already consumed
+          }
+        }
+      }
+
+      // Close the section if we opened it (toggle back)
+      if (didOpen) {
+        const btn = panel.querySelector('[data-tooltip-id="tooltip-artifacts"]');
+        if (btn) (btn as HTMLElement).click();
+      }
+
+      return { conversationTitle, totalCount, artifacts };
+    });
+
+    if (result && 'error' in result) {
+      logger.error(`[IdeArtifacts] ${result.error}`);
+      return { totalCount: 0, artifacts: [], conversationTitle: null };
+    }
+
+    const artifacts: IdeArtifact[] = (result?.artifacts || []).map(
+      (a: { name: string; lastUpdated: string | null }) => ({
+        name: a.name,
+        lastUpdated: a.lastUpdated,
+        isFile: /\.\w{1,5}$/.test(a.name),
+      })
+    );
+
+    logger.info(
+      `[IdeArtifacts] Scraped ${artifacts.length}/${result?.totalCount || 0} artifacts for "${result?.conversationTitle}"`
+    );
+
+    return {
+      totalCount: result?.totalCount || 0,
+      artifacts,
+      conversationTitle: result?.conversationTitle || null,
+    };
+  } catch (err: any) {
+    logger.error(`[IdeArtifacts] Error scraping: ${err.message}`);
+    return { totalCount: 0, artifacts: [], conversationTitle: null };
+  }
+}

package/.next/standalone/lib/scraper/ide-changes.ts

@@ -0,0 +1,172 @@
+/**
+ * IDE Changes Overview Scraper
+ *
+ * Scrapes the "Changes Overview" section from the IDE's agent panel.
+ * This section lists files that have been modified/created/deleted 
+ * during the current conversation, with +additions/-deletions counts.
+ *
+ * DOM structure (when open):
+ *   .flex.grow.flex-col.justify-start.gap-8
+ *     └ div.relative.flex.flex-col.mb-2
+ *       └ div.px-2 (header bar)
+ *         └ div (the outline container)
+ *           ├ span "N Files With Changes"
+ *           ├ "Reject all" / "Accept all"
+ *           └ div.pointer-events-none.absolute.bottom-full (dropdown)
+ *             └ div.flex.flex-col (rows container)
+ *               └ each row: [+][N][-][M] [filename] [filepath]
+ */
+
+import type { ProxyContext } from '../types';
+
+export interface ChangeFile {
+  filename: string;
+  filepath: string;
+  additions: number;
+  deletions: number;
+}
+
+export interface IdeChangesResult {
+  changes: ChangeFile[];
+  totalCount: number;
+}
+
+export async function getIdeChanges(ctx: ProxyContext): Promise<IdeChangesResult> {
+  const page = ctx.workbenchPage;
+  if (!page) return { changes: [], totalCount: 0 };
+
+  try {
+    const result = await page.evaluate(async () => {
+      const panel = document.querySelector('.antigravity-agent-side-panel');
+      if (!panel) return { changes: [] as any[], totalCount: 0, error: 'no panel' };
+
+      // Find the gap-8 container that holds the changes section
+      const gapContainer = panel.querySelector('.flex.grow.flex-col.justify-start.gap-8');
+      if (!gapContainer) return { changes: [] as any[], totalCount: 0, error: 'no gap container' };
+
+      // Check if the changes section is already visible
+      let section = Array.from(gapContainer.children).find(c =>
+        (c.textContent || '').includes('Files With Changes')
+      ) as HTMLElement | undefined;
+
+      let didOpen = false;
+
+      if (!section) {
+        // Toggle the changesOverview button to open it
+        const btn = panel.querySelector('[data-tooltip-id="tooltip-changesOverview"]') as HTMLElement;
+        if (!btn) return { changes: [] as any[], totalCount: 0, error: 'no changesOverview button' };
+
+        btn.click();
+        // Wait for the section to appear
+        for (let i = 0; i < 10; i++) {
+          await new Promise(r => setTimeout(r, 300));
+          section = Array.from(gapContainer.children).find(c =>
+            (c.textContent || '').includes('Files With Changes')
+          ) as HTMLElement | undefined;
+          if (section) break;
+        }
+        didOpen = true;
+      }
+
+      if (!section) {
+        // Close if we opened but nothing appeared
+        if (didOpen) {
+          const btn = panel.querySelector('[data-tooltip-id="tooltip-changesOverview"]') as HTMLElement;
+          if (btn) btn.click();
+        }
+        return { changes: [] as any[], totalCount: 0 };
+      }
+
+      // Find the dropdown containing file rows
+      const dropdown = section.querySelector(
+        '.pointer-events-none.absolute.bottom-full .flex.flex-col'
+      );
+
+      const changes: any[] = [];
+
+      if (dropdown) {
+        const rows = Array.from(dropdown.children);
+        for (const row of rows) {
+          const walker = document.createTreeWalker(row, NodeFilter.SHOW_TEXT);
+          const texts: string[] = [];
+          while (walker.nextNode()) {
+            const t = (walker.currentNode.textContent || '').trim();
+            if (t) texts.push(t);
+          }
+
+          // Parse: ["+"] ["N"] ["-"] ["M"] ["filename.ext"] ["path/to/filename.ext"]
+          // The + and number may be separate text nodes
+          let additions = 0, deletions = 0;
+          let filename = '', filepath = '';
+
+          let plusSeen = false, minusSeen = false;
+          for (let i = 0; i < texts.length; i++) {
+            const t = texts[i];
+
+            // Handle "+N" as single token
+            const addSingle = t.match(/^\+(\d+)$/);
+            if (addSingle) { additions = parseInt(addSingle[1]); continue; }
+
+            // Handle "-N" as single token
+            const delSingle = t.match(/^-(\d+)$/);
+            if (delSingle) { deletions = parseInt(delSingle[1]); continue; }
+
+            // Handle "+" and number as separate tokens
+            if (t === '+') { plusSeen = true; continue; }
+            if (t === '-') { minusSeen = true; continue; }
+
+            // Number after +/-
+            if (plusSeen && t.match(/^\d+$/)) {
+              additions = parseInt(t);
+              plusSeen = false;
+              continue;
+            }
+            if (minusSeen && t.match(/^\d+$/)) {
+              deletions = parseInt(t);
+              minusSeen = false;
+              continue;
+            }
+
+            // File name (has extension)
+            if (!filename && t.match(/\.\w{1,5}$/) && t.length < 100) {
+              filename = t;
+              continue;
+            }
+
+            // File path (contains /)
+            if (filename && !filepath && t.includes('/')) {
+              filepath = t;
+            }
+          }
+
+          if (filename) {
+            changes.push({ filename, filepath: filepath || filename, additions, deletions });
+          }
+        }
+      }
+
+      // Get total count from header
+      const headerSpan = section.querySelector('span');
+      const headerText = headerSpan ? (headerSpan.textContent || '').trim() : '';
+      const totalMatch = headerText.match(/^(\d+)/);
+      const totalCount = totalMatch ? parseInt(totalMatch[1]) : changes.length;
+
+      // Close the section if we opened it
+      if (didOpen) {
+        const btn = panel.querySelector('[data-tooltip-id="tooltip-changesOverview"]') as HTMLElement;
+        if (btn) btn.click();
+      }
+
+      return { changes, totalCount };
+    });
+
+    if (result.changes.length > 0) {
+      console.log(`[INFO] [IdeChanges] Scraped ${result.changes.length}/${result.totalCount} file changes`);
+    }
+
+    return result;
+  } catch (err: any) {
+    console.error(`[ERROR] [IdeChanges] ${err.message}`);
+    return { changes: [], totalCount: 0 };
+  }
+}

package/.next/standalone/lib/types.ts

@@ -132,6 +132,17 @@ export interface ArtifactFile {
   name: string;
   size: number;
   mtime: string;
+  /** Whether this is a file with an extension (can be opened/viewed) or a named IDE artifact */
+  isFile?: boolean;
+  /** Where this artifact was detected from */
+  source?: 'ide' | 'brain' | 'none';
+}
+
+export interface ChangeFile {
+  filename: string;
+  filepath: string;
+  additions: number;
+  deletions: number;
 }
 
 export interface ChatMessage {

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "antigravity-mobile-proxy",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "antigravity-mobile-proxy",
-      "version": "0.1.6",
+      "version": "0.1.7",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-mobile-proxy",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "A web chat proxy for Antigravity IDE with ngrok OAuth tunnel support",
   "keywords": [
     "antigravity",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "dev": "next dev -p 5555",
-    "build": "next build",
+    "build": "NODE_ENV=production next build",
     "postbuild": "node scripts/patch-next.js",
     "start": "next start -p 5555",
     "tunnel": "node bin/cli.js",

package/.next/standalone/scripts/check-send-button.js

@@ -0,0 +1,126 @@
+/**
+ * Diagnostic: Check the send/stop button state in both idle and running states.
+ * Run: node scripts/check-send-button.js
+ */
+const puppeteer = require('puppeteer-core');
+const CDP_PORT = process.env.CDP_PORT || '9223';
+
+async function run() {
+  const browser = await puppeteer.connect({ browserURL: `http://127.0.0.1:${CDP_PORT}` });
+  const pages = await browser.pages();
+  const page = pages.find(p => p.url().includes('workbench.html'));
+
+  if (!page) {
+    console.log('No workbench page found.');
+    process.exit(1);
+  }
+
+  const result = await page.evaluate(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) return { error: 'No panel' };
+
+    const inputArea = document.querySelector('#antigravity\\.agentSidePanelInputBox') ||
+                      panel.querySelector('[id*="InputBox"]');
+    if (!inputArea) return { error: 'No input box' };
+
+    const wrapper = inputArea.closest('.flex') || inputArea.parentElement?.parentElement || inputArea.parentElement;
+    if (!wrapper) return { error: 'No wrapper' };
+
+    const inputBtns = wrapper.querySelectorAll('button');
+    const buttons = [];
+
+    for (const btn of inputBtns) {
+      const html = btn.innerHTML || '';
+      const ariaLabel = (btn.getAttribute('aria-label') || '');
+      const text = (btn.textContent || '').trim();
+      const tooltipId = (btn.getAttribute('data-tooltip-id') || '');
+      const cls = (btn.className || '');
+      
+      // Check what icons are present
+      const svgClasses = [...btn.querySelectorAll('svg')].map(s => s.getAttribute('class') || '');
+      
+      buttons.push({
+        text,
+        ariaLabel,
+        tooltipId,
+        cls: cls.substring(0, 200),
+        svgClasses,
+        htmlSnippet: html.substring(0, 300),
+      });
+    }
+
+    // Also check the spinner state
+    const spinners = panel.querySelectorAll('.animate-spin');
+    let visibleSpinners = 0;
+    for (const s of spinners) {
+      let el = s, hidden = false;
+      while (el) {
+        const c = (el.getAttribute && el.getAttribute('class')) || '';
+        if (c.includes('invisible') || c.includes('opacity-0')) { hidden = true; break; }
+        el = el.parentElement;
+      }
+      if (!hidden) visibleSpinners++;
+    }
+
+    return {
+      totalButtons: inputBtns.length,
+      buttons,
+      visibleSpinners,
+      wrapperTag: wrapper.tagName,
+      wrapperCls: (wrapper.className || '').substring(0, 200),
+    };
+  });
+
+  console.log(JSON.stringify(result, null, 2));
+
+  // Analyze
+  if (result.buttons) {
+    console.log('\n--- ANALYSIS ---');
+    let hasStop = false, hasSend = false;
+    for (const btn of result.buttons) {
+      const tooltipLower = btn.tooltipId.toLowerCase();
+      const ariaLower = btn.ariaLabel.toLowerCase();
+      const textLower = btn.text.toLowerCase();
+      const html = btn.htmlSnippet.toLowerCase();
+
+      const isStopIcon = html.match(/lucide-square(?:[^a-z0-9-]|$)/i) ||
+                         html.includes('lucide-circle-stop') ||
+                         html.includes('lucide-octagon');
+      
+      const isStop = isStopIcon ||
+                     ariaLower.includes('stop') ||
+                     ariaLower.includes('cancel') ||
+                     textLower === 'stop' ||
+                     tooltipLower.includes('stop');
+
+      const isSend = html.includes('lucide-send') ||
+                     html.includes('lucide-arrow-up') ||
+                     html.includes('lucide-arrow-right') ||
+                     html.includes('codicon-send') ||
+                     html.includes('lucide-corner-down-left') ||
+                     ariaLower.includes('send') ||
+                     ariaLower.includes('submit') ||
+                     textLower === 'send' ||
+                     tooltipLower.includes('send');
+
+      if (isStop) hasStop = true;
+      if (isSend) hasSend = true;
+      
+      console.log(`  Button "${btn.text || btn.ariaLabel || btn.tooltipId}": stop=${isStop}, send=${isSend}`);
+    }
+    
+    console.log(`\n  hasStop=${hasStop}, hasSend=${hasSend}`);
+    if (hasStop) {
+      console.log('  => isRunning = TRUE (stop found)');
+    } else if (hasSend) {
+      console.log('  => isRunning = FALSE (send found, no stop)');
+    } else {
+      console.log('  => isRunning = TRUE (no send or stop — send button removed from DOM)');
+    }
+    console.log(`  Visible spinners: ${result.visibleSpinners}`);
+  }
+
+  await browser.disconnect();
+}
+
+run().catch(e => { console.error('Error:', e.message); process.exit(1); });

package/.next/standalone/scripts/find-send-btn.js

@@ -0,0 +1,65 @@
+/**
+ * Find exactly where the send button lives relative to the input box.
+ */
+const puppeteer = require('puppeteer-core');
+
+async function run() {
+  const browser = await puppeteer.connect({ browserURL: 'http://127.0.0.1:9223' });
+  const pages = await browser.pages();
+  const page = pages.find(p => p.url().includes('workbench.html'));
+  if (!page) { console.log('No workbench'); process.exit(1); }
+
+  const result = await page.evaluate(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) return { error: 'No panel' };
+
+    // Find the send/cancel button by tooltip
+    const sendBtn = panel.querySelector('[data-tooltip-id*="send"]') ||
+                    panel.querySelector('[data-tooltip-id*="cancel"]');
+    
+    // Find all buttons with send-like tooltips
+    const sendBtns = [...panel.querySelectorAll('[data-tooltip-id]')]
+      .filter(el => {
+        const tip = el.getAttribute('data-tooltip-id') || '';
+        return tip.includes('send') || tip.includes('cancel');
+      })
+      .map(el => ({
+        tag: el.tagName,
+        tooltipId: el.getAttribute('data-tooltip-id'),
+        innerHTML: el.innerHTML?.substring(0, 300) || '',
+        cls: (el.className || '').substring(0, 200),
+      }));
+
+    // The input box
+    const inputBox = document.querySelector('#antigravity\\.agentSidePanelInputBox');
+    if (!inputBox) return { error: 'No input box', sendBtns };
+
+    // Current wrapper that `.closest('.flex')` finds
+    const currentWrapper = inputBox.closest('.flex');
+    
+    // Walk up and list all ancestors with their button counts
+    const ancestors = [];
+    let el = inputBox;
+    for (let i = 0; i < 10 && el; i++) {
+      const btns = el.querySelectorAll('button');
+      const sendInside = el.querySelector('[data-tooltip-id*="send"]');
+      ancestors.push({
+        level: i,
+        tag: el.tagName,
+        id: el.id || '',
+        cls: (el.className || '').substring(0, 150),
+        buttonCount: btns.length,
+        hasSendBtn: !!sendInside,
+        isCurrentWrapper: el === currentWrapper,
+      });
+      el = el.parentElement;
+    }
+
+    return { sendBtns, ancestors };
+  });
+
+  console.log(JSON.stringify(result, null, 2));
+  await browser.disconnect();
+}
+
+run().catch(e => { console.error(e.message); process.exit(1); });