antigravity-mobile-proxy 0.1.6 → 0.1.7

package/.next/standalone/lib/scraper/agent-state.ts

@@ -80,68 +80,103 @@ export async function getFullAgentState(ctx: ProxyContext): Promise<AgentState>
       const wrapper = inputArea.closest('.flex') || inputArea.parentElement?.parentElement || inputArea.parentElement;
       if (wrapper) {
         (window as any).__proxyInputBoxHTML = wrapper.outerHTML;
-        const inputBtns = wrapper.querySelectorAll('button');
         
-        let hasStop = false;
-        let hasSend = false;
+        // ── Priority check: look for the send/cancel element by data-tooltip-id.
+        // In current Antigravity versions, the send/cancel control is a <div>,
+        // NOT a <button>, with tooltip like "input-send-button-cancel-tooltip"
+        // or "input-send-button-tooltip".
+        const sendCancelEl = wrapper.querySelector('[data-tooltip-id*="send"]') ||
+                             wrapper.querySelector('[data-tooltip-id*="cancel"]');
         
-        for (const btn of inputBtns) {
-          const html = btn.innerHTML || '';
-          const ariaLabel = (btn.getAttribute('aria-label') || '').toLowerCase();
-          const text = (btn.textContent || '').trim().toLowerCase();
-          const tooltipId = (btn.getAttribute('data-tooltip-id') || '').toLowerCase();
+        if (sendCancelEl) {
+          const tooltipId = (sendCancelEl.getAttribute('data-tooltip-id') || '').toLowerCase();
+          const innerHtml = sendCancelEl.innerHTML || '';
           
-          // The send/stop button changes its tooltip and contents.
-          // We must be careful not to match 'lucide-square-slash' or other derived 
-          // square icons by ensuring 'lucide-square' is followed by a non-word character.
-          const isStopIcon = 
-            html.match(/lucide-square(?:[^a-z0-9-]|$)/i) || 
-            html.includes('lucide-circle-stop') || 
-            html.includes('lucide-octagon');
+          // When running: tooltip contains "cancel", inner HTML has a red/colored
+          // square (stop icon) like <div class="bg-red-500 ...rounded-xs">
+          const isCancelMode = tooltipId.includes('cancel') ||
+                               innerHtml.includes('bg-red') ||
+                               innerHtml.includes('rounded-xs') ||
+                               innerHtml.match(/lucide-square(?:[^a-z0-9-]|$)/i);
+          
+          // When idle: tooltip is just "send" without "cancel", inner HTML has
+          // an arrow-up or send icon  
+          const isSendMode = !isCancelMode && (
+            tooltipId.includes('send') ||
+            innerHtml.includes('lucide-arrow-up') ||
+            innerHtml.includes('lucide-send')
+          );
+          
+          if (isCancelMode) {
+            isRunning = true;
+            buttonStateDefinitive = true;
+          } else if (isSendMode) {
+            isRunning = false;
+            buttonStateDefinitive = true;
+          }
+        }
 
-          if (
-            isStopIcon ||
-            ariaLabel.includes('stop') ||
-            ariaLabel.includes('cancel') ||
-            text === 'stop' ||
-            tooltipId.includes('stop')
-          ) {
-            hasStop = true;
+        // ── Fallback: scan <button> elements in the wrapper
+        if (!buttonStateDefinitive) {
+          const inputBtns = wrapper.querySelectorAll('button');
+          
+          let hasStop = false;
+          let hasSend = false;
+          
+          for (const btn of inputBtns) {
+            const html = btn.innerHTML || '';
+            const ariaLabel = (btn.getAttribute('aria-label') || '').toLowerCase();
+            const text = (btn.textContent || '').trim().toLowerCase();
+            const tooltipId = (btn.getAttribute('data-tooltip-id') || '').toLowerCase();
+            
+            const isStopIcon = 
+              html.match(/lucide-square(?:[^a-z0-9-]|$)/i) || 
+              html.includes('lucide-circle-stop') || 
+              html.includes('lucide-octagon');
+
+            if (
+              isStopIcon ||
+              ariaLabel.includes('stop') ||
+              ariaLabel.includes('cancel') ||
+              text === 'stop' ||
+              tooltipId.includes('stop')
+            ) {
+              hasStop = true;
+            }
+            
+            if (
+              html.includes('lucide-send') || 
+              html.includes('lucide-arrow-up') ||
+              html.includes('lucide-arrow-right') ||
+              html.includes('codicon-send') ||
+              html.includes('lucide-corner-down-left') ||
+              ariaLabel.includes('send') ||
+              ariaLabel.includes('submit') ||
+              text === 'send' ||
+              tooltipId.includes('send')
+            ) {
+              hasSend = true;
+            }
           }
           
-          if (
-            html.includes('lucide-send') || 
-            html.includes('lucide-arrow-up') ||
-            html.includes('lucide-arrow-right') ||
-            html.includes('codicon-send') ||
-            html.includes('lucide-corner-down-left') ||
-            ariaLabel.includes('send') ||
-            ariaLabel.includes('submit') ||
-            text === 'send' ||
-            tooltipId.includes('send')
-          ) {
-            hasSend = true;
+          if (hasStop) {
+            isRunning = true;
+            buttonStateDefinitive = true;
+          } else if (hasSend) {
+            isRunning = false;
+            buttonStateDefinitive = true;
+          } else {
+            // Send button absent — check for div-based send/cancel element
+            const altSendEl = inputArea?.querySelector('[data-tooltip-id*="send"]');
+            if (altSendEl) {
+              const tip = (altSendEl.getAttribute('data-tooltip-id') || '').toLowerCase();
+              isRunning = tip.includes('cancel');
+            } else {
+              isRunning = true;
+            }
+            buttonStateDefinitive = true;
           }
         }
-        
-        // Detection logic:
-        // - If stop button found → definitely running
-        // - If send button found → definitely idle
-        // - If NEITHER found (send button removed from DOM) → running
-        //   Antigravity removes the send button entirely while the agent is
-        //   active; no stop icon replaces it. The wrapper drops from 4 to 3
-        //   buttons (Plus, Mode, Mic — no Send).
-        if (hasStop) {
-          isRunning = true;
-          buttonStateDefinitive = true;
-        } else if (hasSend) {
-          isRunning = false;
-          buttonStateDefinitive = true;
-        } else {
-          // Send button absent from wrapper — agent is running
-          isRunning = true;
-          buttonStateDefinitive = true;
-        }
       }
     }
 

package/.next/standalone/lib/scraper/chat-history.ts

@@ -1,7 +1,21 @@
 /**
  * Chat history scraper.
- * Scrolls the Antigravity conversation view to de-virtualize all content,
- * then walks the DOM to extract user/agent messages in order.
+ * Scrolls the Antigravity conversation view viewport-by-viewport,
+ * waiting for content to load at each position, then extracts
+ * user/agent messages in document order.
+ *
+ * Key design decisions:
+ * - Viewport-pinned extraction: collect content at each scroll position
+ *   rather than scrolling everything first, because Antigravity re-virtualizes
+ *   content that scrolls out of view.
+ * - Wait for skeleton resolution: skeleton blocks (.bg-gray-500/10) appear
+ *   temporarily while content loads; we wait for them to clear.
+ * - Clean deduplication: dedup keys are built from cleaned text (without
+ *   injected <style> content) to avoid false collisions.
+ * - User message filtering: excludes CODE tags, tool containers, and
+ *   notify blocks that incorrectly match .whitespace-pre-wrap.
+ * - Agent response categorization: distinguishes between thinking summaries,
+ *   tool descriptions, notify messages, and final responses.
  */
 
 import type { ProxyContext, ChatHistory } from '../types';
@@ -22,110 +36,226 @@ export async function getChatHistory(ctx: ProxyContext): Promise<ChatHistory> {
     if (!scrollArea)
       return { isRunning: false, turnCount: 0, turns: [] };
 
-    // Step 1: Scroll to top to force older content to render
-    scrollArea.scrollTop = 0;
-    await new Promise((r) => setTimeout(r, 300));
-
-    // Step 2: Incrementally scroll down to de-virtualize all content
-    const scrollHeight = scrollArea.scrollHeight;
-    const viewportHeight = scrollArea.clientHeight;
-    const scrollStep = viewportHeight * 0.8;
-    let pos = 0;
-    while (pos < scrollHeight) {
-      scrollArea.scrollTop = pos;
-      await new Promise((r) => setTimeout(r, 100));
-      pos += scrollStep;
-    }
-    scrollArea.scrollTop = scrollArea.scrollHeight;
-    await new Promise((r) => setTimeout(r, 200));
-
-    // Step 3: Walk the DOM to find messages in document order
-    const turns: { role: 'user' | 'agent'; content: string }[] = [];
-    const seen = new Set<string>();
-
     const msgList =
       (scrollArea as Element).querySelector('.mx-auto') || scrollArea;
 
-    const candidates: {
-      el: Element;
-      role: 'user' | 'agent';
-      content: string;
-    }[] = [];
-
-    // Find user messages
-    const allWhitespace = msgList.querySelectorAll('.whitespace-pre-wrap');
-    for (const el of allWhitespace) {
-      const text = el.textContent?.trim();
-      if (!text) continue;
-
-      let isInsideAgentResponse = false;
-      let parent = el.parentElement;
-      while (parent && parent !== msgList) {
-        const cls = parent.getAttribute('class') || '';
-        if (
-          cls.includes('leading-relaxed') &&
-          cls.includes('select-text')
-        ) {
-          isInsideAgentResponse = true;
-          break;
+    // ── Helper: wait for skeleton blocks in current viewport to resolve ──
+    async function waitForLoad(maxWait = 3000) {
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        const skeletons = Array.from(msgList.querySelectorAll(
+          '.rounded-lg.bg-gray-500\\/10'
+        ));
+        let visibleSkeletons = 0;
+        const panelRect = scrollArea!.getBoundingClientRect();
+        for (const sk of skeletons) {
+          const rect = sk.getBoundingClientRect();
+          const relTop = rect.top - panelRect.top;
+          const relBottom = rect.bottom - panelRect.top;
+          if (
+            relBottom > -50 &&
+            relTop < scrollArea!.clientHeight + 50
+          ) {
+            visibleSkeletons++;
+          }
         }
-        parent = parent.parentElement;
+        if (visibleSkeletons === 0) break;
+        await new Promise((r) => setTimeout(r, 100));
       }
-      if (isInsideAgentResponse) continue;
-
-      if (el.closest('[data-lexical-editor]')) continue;
-      if (el.closest('#antigravity\\.agentSidePanelInputBox')) continue;
+    }
 
-      const key = 'user:' + text.substring(0, 200);
-      if (seen.has(key)) continue;
-      seen.add(key);
+    // ── Helper: extract clean text from an element (strips <style>) ──
+    function getCleanText(el: Element): string {
+      const clone = el.cloneNode(true) as Element;
+      clone.querySelectorAll('style, script').forEach((n) => n.remove());
+      return (clone as HTMLElement).textContent?.trim() || '';
+    }
 
-      candidates.push({ el, role: 'user', content: text });
+    // ── Helper: extract clean HTML from an element ──
+    function getCleanHTML(el: Element): string {
+      const clone = el.cloneNode(true) as Element;
+      clone.querySelectorAll('style, script').forEach((n) => n.remove());
+      // Remove Antigravity interactive UI chrome
+      clone
+        .querySelectorAll(
+          'svg.cursor-pointer, [class*="cursor-pointer"][class*="opacity-70"], button[class*="opacity-70"]'
+        )
+        .forEach((n) => n.remove());
+      return (clone as HTMLElement).innerHTML?.trim() || '';
     }
 
-    // Find agent response blocks
-    const allResponses = msgList.querySelectorAll(
-      '.leading-relaxed.select-text'
-    );
-    for (const el of allResponses) {
-      let hidden = false;
+    // ── Helper: check if element is visually hidden ──
+    function isHidden(el: Element, root: Element): boolean {
       let ancestor = el.parentElement;
       let depth = 0;
-      while (ancestor && ancestor !== msgList && depth < 15) {
+      while (ancestor && ancestor !== root && depth < 15) {
         const cls = ancestor.getAttribute('class') || '';
         if (cls.includes('max-h-0') || cls.includes('hidden')) {
-          hidden = true;
-          break;
+          return true;
+        }
+        // Check inline styles too
+        const style = (ancestor as HTMLElement).style;
+        if (
+          style &&
+          (style.display === 'none' || style.maxHeight === '0px')
+        ) {
+          return true;
+        }
+        // Check if the element has zero height (collapsed)
+        if ((ancestor as HTMLElement).offsetHeight === 0) {
+          return true;
         }
         ancestor = ancestor.parentElement;
         depth++;
       }
-      if (hidden) continue;
+      return false;
+    }
 
-      const clone = el.cloneNode(true) as Element;
-      clone.querySelectorAll('style, script').forEach((n) => n.remove());
-      // Remove Antigravity interactive UI chrome (@ mention SVGs, copy buttons, etc.)
-      clone.querySelectorAll(
-        'svg.cursor-pointer, [class*="cursor-pointer"][class*="opacity-70"], button[class*="opacity-70"]'
-      ).forEach((n) => n.remove());
-      const html = (clone as HTMLElement).innerHTML?.trim();
-      if (!html) continue;
-
-      const key = 'agent:' + el.textContent?.trim().substring(0, 200);
-      if (seen.has(key)) continue;
-      seen.add(key);
-
-      candidates.push({ el, role: 'agent', content: html });
+    // ── Viewport-by-viewport extraction ──
+    // Items are tagged with their absolute Y position at collection time
+    // so we can sort chronologically even after elements get re-virtualized.
+    const seen = new Set<string>();
+    const candidates: {
+      absY: number;   // scrollTop + element offset — for chronological sorting
+      role: 'user' | 'agent';
+      content: string;
+      contentType?: string;
+    }[] = [];
+
+    function collectAtCurrentPosition() {
+      const panelRect = scrollArea!.getBoundingClientRect();
+      const currentScroll = scrollArea!.scrollTop;
+
+      // ── Collect user messages ──
+      for (const el of Array.from(msgList.querySelectorAll('.whitespace-pre-wrap'))) {
+        const text = el.textContent?.trim();
+        if (!text || text.length < 2) continue;
+
+        // Skip if inside agent response block
+        if (el.closest('.leading-relaxed.select-text')) continue;
+        // Skip editor / input box
+        if (el.closest('[data-lexical-editor]')) continue;
+        if (
+          el.closest('#antigravity\\.agentSidePanelInputBox')
+        )
+          continue;
+        // Skip CODE tags (inline code references like `file.ts`)
+        if (el.tagName === 'CODE') continue;
+        // Skip elements inside tool containers
+        if (
+          el.closest(
+            '.flex.flex-col.gap-2.border.rounded-lg'
+          )
+        )
+          continue;
+        // Skip elements inside notify containers (these are agent content)
+        if (el.closest('.notify-user-container')) continue;
+
+        // Check if in current viewport
+        const rect = el.getBoundingClientRect();
+        const relTop = rect.top - panelRect.top;
+        if (
+          relTop < -100 ||
+          relTop > scrollArea!.clientHeight + 100
+        )
+          continue;
+
+        const key = 'user:' + text.substring(0, 300);
+        if (seen.has(key)) continue;
+        seen.add(key);
+
+        // Absolute Y position = scroll offset + element's position relative to scroll container
+        const absY = currentScroll + relTop;
+        candidates.push({ absY, role: 'user', content: text });
+      }
+
+      // ── Collect agent response blocks ──
+      for (const el of Array.from(msgList.querySelectorAll(
+        '.leading-relaxed.select-text'
+      ))) {
+        if (isHidden(el, msgList)) continue;
+
+        // Check if in current viewport
+        const rect = el.getBoundingClientRect();
+        const relTop = rect.top - panelRect.top;
+        if (
+          relTop < -100 ||
+          relTop > scrollArea!.clientHeight + 100
+        )
+          continue;
+
+        // Get clean HTML (strips <style>, <script>, UI chrome)
+        const html = getCleanHTML(el);
+        if (!html) continue;
+
+        // Build dedup key from CLEAN text (not raw textContent which includes <style>)
+        const cleanText = getCleanText(el);
+        if (!cleanText) continue;
+
+        const key = 'agent:' + cleanText.substring(0, 300);
+        if (seen.has(key)) continue;
+        seen.add(key);
+
+        // Categorize the response
+        const inNotify = !!el.closest('.notify-user-container');
+        const parentClass =
+          el.parentElement?.getAttribute('class') || '';
+        const isThinkingSummary =
+          parentClass.includes('font-medium') &&
+          parentClass.includes('pb-0');
+
+        // Skip thinking summaries (these are short descriptions of agent thoughts,
+        // not the actual response to the user)
+        if (isThinkingSummary) continue;
+
+        const contentType = inNotify ? 'notify' : 'response';
+        const absY = currentScroll + relTop;
+
+        candidates.push({
+          absY,
+          role: 'agent',
+          content: html,
+          contentType,
+        });
+      }
     }
 
-    // Sort by document position
-    candidates.sort((a, b) => {
-      const pos = a.el.compareDocumentPosition(b.el);
-      if (pos & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
-      if (pos & Node.DOCUMENT_POSITION_PRECEDING) return 1;
-      return 0;
-    });
+    // ── Scroll through entire conversation, collecting at each stop ──
+    const overallStart = Date.now();
+    const OVERALL_TIMEOUT = 30000; // 30s max for the entire scroll
+
+    scrollArea.scrollTop = 0;
+    await waitForLoad(2000);
+    await new Promise((r) => setTimeout(r, 200));
+    collectAtCurrentPosition();
+
+    const step = scrollArea.clientHeight * 0.8; // 80% viewport step
+    let pos = step;
+    let scrollSteps = 0;
+    const maxScrollSteps = 200; // Safety limit
 
+    while (pos < scrollArea.scrollHeight + scrollArea.clientHeight) {
+      if (Date.now() - overallStart > OVERALL_TIMEOUT) break;
+      scrollArea.scrollTop = pos;
+      await waitForLoad(1500);
+      await new Promise((r) => setTimeout(r, 50));
+      collectAtCurrentPosition();
+      pos += step;
+      scrollSteps++;
+      if (scrollSteps > maxScrollSteps) break;
+    }
+
+    // Final collection at bottom
+    scrollArea.scrollTop = scrollArea.scrollHeight;
+    await waitForLoad(1500);
+    await new Promise((r) => setTimeout(r, 200));
+    collectAtCurrentPosition();
+
+    // ── Sort by absolute Y position (chronological order) ──
+    candidates.sort((a, b) => a.absY - b.absY);
+
+    // ── Build final turn list ──
+    const turns: { role: 'user' | 'agent'; content: string }[] = [];
     for (const c of candidates) {
       turns.push({ role: c.role, content: c.content });
     }