lazy-gravity 0.0.4 → 0.2.0

package/dist/services/chatSessionService.js

@@ -30,6 +30,118 @@ const GET_CHAT_TITLE_SCRIPT = `(() => {
     const hasActiveChat = title.length > 0 && title !== 'Agent';
     return { title: title || '(Untitled)', hasActiveChat };
 })()`;
+/**
+ * Script to find the Past Conversations button and return its coordinates.
+ * We use coordinates so that the actual click is done via CDP Input.dispatchMouseEvent,
+ * which works reliably in Electron (DOM .click() can be ignored).
+ *
+ * Returns: { found: boolean, x: number, y: number }
+ */
+const FIND_PAST_CONVERSATIONS_BUTTON_SCRIPT = `(() => {
+    const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
+    const getRect = (el) => {
+        const rect = el.getBoundingClientRect();
+        return { found: true, x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+    };
+
+    // Strategy 1 (primary): data-past-conversations-toggle attribute
+    const toggle = document.querySelector('[data-past-conversations-toggle]');
+    if (toggle && isVisible(toggle)) return getRect(toggle);
+
+    // Strategy 2: data-tooltip-id containing "history"
+    const tooltipEls = Array.from(document.querySelectorAll('[data-tooltip-id]'));
+    for (const el of tooltipEls) {
+        if (!isVisible(el)) continue;
+        const tid = (el.getAttribute('data-tooltip-id') || '').toLowerCase();
+        if (tid.includes('history') || tid.includes('past-conversations')) {
+            return getRect(el);
+        }
+    }
+
+    // Strategy 3: SVG with lucide-history class
+    const icons = Array.from(document.querySelectorAll('svg.lucide-history, svg[class*="lucide-history"]'));
+    for (const icon of icons) {
+        const parent = icon.closest('a, button, [role="button"], div[class*="cursor-pointer"]');
+        const target = parent instanceof HTMLElement && isVisible(parent) ? parent : icon;
+        if (isVisible(target)) return getRect(target);
+    }
+
+    return { found: false, x: 0, y: 0 };
+})()`;
+/**
+ * Script to scrape session items from the open Past Conversations panel.
+ * Expects the panel to already be visible.
+ *
+ * Returns: { sessions: SessionListItem[] }
+ */
+const SCRAPE_PAST_CONVERSATIONS_SCRIPT = `(() => {
+    const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
+    const normalize = (text) => (text || '').trim();
+
+    const items = [];
+    const seen = new Set();
+
+    // Find the scrollable conversation list container
+    const containers = Array.from(document.querySelectorAll('div[class*="overflow-auto"], div[class*="overflow-y-scroll"]'));
+    const container = containers.find((c) => isVisible(c) && c.querySelectorAll('div[class*="cursor-pointer"]').length > 0) || document;
+
+    // Detect the "Other Conversations" section boundary.
+    // Sessions below this header belong to other projects and must be excluded.
+    let boundaryTop = Infinity;
+    const headerCandidates = container.querySelectorAll('div[class*="text-xs"][class*="opacity"]');
+    for (const el of headerCandidates) {
+        if (!isVisible(el)) continue;
+        const t = normalize(el.textContent || '');
+        if (/^Other\\s+Conversations?$/i.test(t)) {
+            boundaryTop = el.getBoundingClientRect().top;
+            break;
+        }
+    }
+
+    // Each session row is a div with cursor-pointer
+    const rows = Array.from(container.querySelectorAll('div[class*="cursor-pointer"]'));
+    for (const row of rows) {
+        if (!isVisible(row)) continue;
+        // Skip rows that are below the "Other Conversations" boundary
+        if (row.getBoundingClientRect().top >= boundaryTop) continue;
+        // Find the session title — nested span within the row
+        const spans = Array.from(row.querySelectorAll('span.text-sm span, span.text-sm'));
+        let title = '';
+        for (const span of spans) {
+            const t = normalize(span.textContent || '');
+            // Skip timestamp labels like "1 hr ago", "7 mins ago"
+            if (/^\\d+\\s+(min|hr|hour|day|sec|week|month|year)s?\\s+ago$/i.test(t)) continue;
+            // Skip very short or action-like labels
+            if (t.length < 2 || t.length > 200) continue;
+            if (/^(show\\s+\\d+\\s+more|new|past|history|settings|close|menu)\\b/i.test(t)) continue;
+            title = t;
+            break;
+        }
+        if (!title || seen.has(title)) continue;
+        seen.add(title);
+        // Detect if this is the active/current session (has focusBackground class)
+        const isActive = /focusBackground/i.test(row.className || '');
+        items.push({ title, isActive });
+    }
+    return { sessions: items };
+})()`;
+/**
+ * Script to find the "Show N more..." link and return its coordinates.
+ * Returns: { found: boolean, x: number, y: number }
+ */
+const FIND_SHOW_MORE_BUTTON_SCRIPT = `(() => {
+    const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
+    const els = Array.from(document.querySelectorAll('div, span'));
+    for (const el of els) {
+        if (!isVisible(el)) continue;
+        const text = (el.textContent || '').trim();
+        if (/^Show\\s+\\d+\\s+more/i.test(text)) {
+            const rect = el.getBoundingClientRect();
+            return { found: true, x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+        }
+    }
+    return { found: false, x: 0, y: 0 };
+})()`;
 /**
  * Build a script that activates an existing chat in the side panel by its title.
  * Uses broad selector fallbacks because Antigravity's DOM structure can vary across versions.
@@ -235,14 +347,35 @@ function buildActivateViaPastConversationsScript(title) {
         };
 
         return (async () => {
-            let opened = clickByPatterns([
-                'past conversations',
-                'past conversation',
-                'conversation history',
-                'past chats',
-                '過去の会話',
-                'chat history',
-            ]);
+            // Primary: click via data-past-conversations-toggle attribute
+            let opened = false;
+            const toggleBtn = document.querySelector('[data-past-conversations-toggle]');
+            if (toggleBtn && isVisible(toggleBtn)) {
+                const clickable = getClickable(toggleBtn);
+                if (clickable) { clickable.click(); opened = true; }
+            }
+            if (!opened) {
+                // Fallback: data-tooltip-id containing "history"
+                const tooltipEls = asArray(document.querySelectorAll('[data-tooltip-id]'));
+                for (const el of tooltipEls) {
+                    if (!isVisible(el)) continue;
+                    const tid = normalize(el.getAttribute('data-tooltip-id') || '');
+                    if (tid.includes('history') || tid.includes('past-conversations')) {
+                        const cl = getClickable(el);
+                        if (cl) { cl.click(); opened = true; break; }
+                    }
+                }
+            }
+            if (!opened) {
+                opened = clickByPatterns([
+                    'past conversations',
+                    'past conversation',
+                    'conversation history',
+                    'past chats',
+                    '過去の会話',
+                    'chat history',
+                ]);
+            }
             if (!opened) {
                 opened = clickIconHistoryButton();
             }
@@ -286,6 +419,94 @@ function buildActivateViaPastConversationsScript(title) {
 class ChatSessionService {
     static ACTIVATE_SESSION_MAX_WAIT_MS = 30000;
     static ACTIVATE_SESSION_RETRY_INTERVAL_MS = 800;
+    static LIST_SESSIONS_TARGET = 20;
+    /**
+     * List recent sessions by opening the Past Conversations panel.
+     *
+     * Flow (all clicks via CDP Input.dispatchMouseEvent for Electron compatibility):
+     *   1. Find Past Conversations button coordinates
+     *   2. Click it via CDP mouse events
+     *   3. Wait for panel to render
+     *   4. Scrape visible sessions
+     *   5. If < TARGET sessions, find & click "Show N more..."
+     *   6. Re-scrape
+     *   7. Close panel with Escape key
+     *
+     * @param cdpService CdpService instance to use
+     * @returns Array of session list items (empty array on failure)
+     */
+    async listAllSessions(cdpService) {
+        try {
+            // Step 1: Find Past Conversations button
+            const btnState = await this.evaluateOnAnyContext(cdpService, FIND_PAST_CONVERSATIONS_BUTTON_SCRIPT, false);
+            if (!btnState?.found) {
+                return [];
+            }
+            // Step 2: Click via CDP mouse events (reliable in Electron)
+            await this.cdpMouseClick(cdpService, btnState.x, btnState.y);
+            // Step 3: Wait for panel to render
+            await new Promise((r) => setTimeout(r, 500));
+            // Step 4: Scrape sessions
+            let scrapeResult = await this.evaluateOnAnyContext(cdpService, SCRAPE_PAST_CONVERSATIONS_SCRIPT, false);
+            let sessions = scrapeResult?.sessions ?? [];
+            // Step 5: If fewer than TARGET, click "Show N more..."
+            if (sessions.length < ChatSessionService.LIST_SESSIONS_TARGET) {
+                const showMoreState = await this.evaluateOnAnyContext(cdpService, FIND_SHOW_MORE_BUTTON_SCRIPT, false);
+                if (showMoreState?.found) {
+                    await this.cdpMouseClick(cdpService, showMoreState.x, showMoreState.y);
+                    await new Promise((r) => setTimeout(r, 500));
+                    // Step 6: Re-scrape
+                    scrapeResult = await this.evaluateOnAnyContext(cdpService, SCRAPE_PAST_CONVERSATIONS_SCRIPT, false);
+                    sessions = scrapeResult?.sessions ?? [];
+                }
+            }
+            // Step 7: Close panel with Escape
+            await cdpService.call('Input.dispatchKeyEvent', {
+                type: 'keyDown', key: 'Escape', code: 'Escape',
+                windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27,
+            });
+            await cdpService.call('Input.dispatchKeyEvent', {
+                type: 'keyUp', key: 'Escape', code: 'Escape',
+                windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27,
+            });
+            return sessions.slice(0, ChatSessionService.LIST_SESSIONS_TARGET);
+        }
+        catch (_) {
+            return [];
+        }
+    }
+    /**
+     * Evaluate a script on the first context that returns a truthy value.
+     */
+    async evaluateOnAnyContext(cdpService, expression, awaitPromise) {
+        const contexts = cdpService.getContexts();
+        for (const ctx of contexts) {
+            try {
+                const result = await cdpService.call('Runtime.evaluate', {
+                    expression, returnByValue: true, awaitPromise, contextId: ctx.id,
+                });
+                const value = result?.result?.value;
+                if (value)
+                    return value;
+            }
+            catch (_) { /* try next context */ }
+        }
+        return null;
+    }
+    /**
+     * Click at coordinates via CDP Input.dispatchMouseEvent.
+     */
+    async cdpMouseClick(cdpService, x, y) {
+        await cdpService.call('Input.dispatchMouseEvent', {
+            type: 'mouseMoved', x, y,
+        });
+        await cdpService.call('Input.dispatchMouseEvent', {
+            type: 'mousePressed', x, y, button: 'left', clickCount: 1,
+        });
+        await cdpService.call('Input.dispatchMouseEvent', {
+            type: 'mouseReleased', x, y, button: 'left', clickCount: 1,
+        });
+    }
     /**
      * Start a new chat session in the Antigravity UI.
      *

package/dist/services/errorPopupDetector.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorPopupDetector = void 0;
+const logger_1 = require("../utils/logger");
+const approvalDetector_1 = require("./approvalDetector");
+/**
+ * Detection script for the Antigravity UI error popup.
+ *
+ * Looks for dialog/modal containers containing error-related text patterns
+ * like "agent terminated", "error", "failed", etc. and extracts popup info.
+ */
+const DETECT_ERROR_POPUP_SCRIPT = `(() => {
+    const ERROR_PATTERNS = [
+        'agent terminated',
+        'terminated due to error',
+        'unexpected error',
+        'something went wrong',
+        'an error occurred',
+    ];
+
+    const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+
+    // Try dialog/modal first
+    const dialogs = Array.from(document.querySelectorAll(
+        '[role="dialog"], [role="alertdialog"], .modal, .dialog'
+    )).filter(el => el.offsetParent !== null || el.getAttribute('aria-modal') === 'true');
+
+    // Fallback: look for fixed/absolute positioned overlays
+    if (dialogs.length === 0) {
+        const overlays = Array.from(document.querySelectorAll('div[class*="fixed"], div[class*="absolute"]'))
+            .filter(el => {
+                const style = window.getComputedStyle(el);
+                return (style.position === 'fixed' || style.position === 'absolute')
+                    && style.zIndex && parseInt(style.zIndex, 10) > 10
+                    && el.querySelector('button');
+            });
+        dialogs.push(...overlays);
+    }
+
+    for (const dialog of dialogs) {
+        const fullText = normalize(dialog.textContent || '');
+        const isError = ERROR_PATTERNS.some(p => fullText.includes(p));
+        if (!isError) continue;
+
+        // Extract title from heading elements or first prominent text
+        const headingEl = dialog.querySelector('h1, h2, h3, h4, [class*="title"], [class*="heading"]');
+        const title = headingEl ? (headingEl.textContent || '').trim() : '';
+
+        // Extract body text (excluding button text and title)
+        const allButtons = Array.from(dialog.querySelectorAll('button'))
+            .filter(btn => btn.offsetParent !== null);
+        const buttonTexts = new Set(allButtons.map(btn => (btn.textContent || '').trim()));
+
+        const bodyParts = [];
+        const walker = document.createTreeWalker(dialog, NodeFilter.SHOW_TEXT);
+        let node;
+        while ((node = walker.nextNode())) {
+            const text = (node.textContent || '').trim();
+            if (!text) continue;
+            if (buttonTexts.has(text)) continue;
+            if (text === title) continue;
+            bodyParts.push(text);
+        }
+        const body = bodyParts.join(' ').slice(0, 1000);
+
+        const buttons = allButtons.map(btn => (btn.textContent || '').trim()).filter(t => t.length > 0);
+
+        if (buttons.length === 0) continue;
+
+        return { title: title || 'Error', body, buttons };
+    }
+
+    return null;
+})()`;
+/**
+ * Read clipboard content via navigator.clipboard.readText().
+ * Requires awaitPromise=true since clipboard API returns a Promise.
+ */
+const READ_CLIPBOARD_SCRIPT = `(async () => {
+    try {
+        const text = await navigator.clipboard.readText();
+        return text || null;
+    } catch (e) {
+        return null;
+    }
+})()`;
+/**
+ * Detects error popup dialogs (e.g. "Agent terminated due to error") in the
+ * Antigravity UI via polling.
+ *
+ * Follows the same polling pattern as PlanningDetector / ApprovalDetector:
+ * - start()/stop() lifecycle
+ * - Duplicate notification prevention via lastDetectedKey
+ * - Cooldown to suppress rapid re-detection
+ * - CDP error tolerance (continues polling on error)
+ */
+class ErrorPopupDetector {
+    cdpService;
+    pollIntervalMs;
+    onErrorPopup;
+    onResolved;
+    pollTimer = null;
+    isRunning = false;
+    /** Key of the last detected error popup (for duplicate notification prevention) */
+    lastDetectedKey = null;
+    /** Full ErrorPopupInfo from the last detection */
+    lastDetectedInfo = null;
+    /** Timestamp of last notification (for cooldown-based dedup) */
+    lastNotifiedAt = 0;
+    /** Cooldown period in ms to suppress duplicate notifications (10s for error popups) */
+    static COOLDOWN_MS = 10000;
+    constructor(options) {
+        this.cdpService = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs ?? 3000;
+        this.onErrorPopup = options.onErrorPopup;
+        this.onResolved = options.onResolved;
+    }
+    /** Start monitoring. */
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastDetectedKey = null;
+        this.lastDetectedInfo = null;
+        this.lastNotifiedAt = 0;
+        this.schedulePoll();
+    }
+    /** Stop monitoring. */
+    async stop() {
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /** Return the last detected error popup info. Returns null if nothing has been detected. */
+    getLastDetectedInfo() {
+        return this.lastDetectedInfo;
+    }
+    /** Returns whether monitoring is currently active. */
+    isActive() {
+        return this.isRunning;
+    }
+    /**
+     * Click the Dismiss button via CDP.
+     * @returns true if click succeeded
+     */
+    async clickDismissButton() {
+        return this.clickButton('Dismiss');
+    }
+    /**
+     * Click the "Copy debug info" button via CDP.
+     * @returns true if click succeeded
+     */
+    async clickCopyDebugInfoButton() {
+        return this.clickButton('Copy debug info');
+    }
+    /**
+     * Click the Retry button via CDP.
+     * @returns true if click succeeded
+     */
+    async clickRetryButton() {
+        return this.clickButton('Retry');
+    }
+    /**
+     * Read clipboard content from the browser via navigator.clipboard.readText().
+     * Should be called after clickCopyDebugInfoButton() with a short delay.
+     * @returns Clipboard text or null if unavailable
+     */
+    async readClipboard() {
+        try {
+            const result = await this.runEvaluateScript(READ_CLIPBOARD_SCRIPT, true);
+            return typeof result === 'string' ? result : null;
+        }
+        catch (error) {
+            logger_1.logger.error('[ErrorPopupDetector] Error reading clipboard:', error);
+            return null;
+        }
+    }
+    /** Schedule the next poll. */
+    schedulePoll() {
+        if (!this.isRunning)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            await this.poll();
+            if (this.isRunning) {
+                this.schedulePoll();
+            }
+        }, this.pollIntervalMs);
+    }
+    /**
+     * Single poll iteration:
+     *   1. Detect error popup from DOM (with contextId)
+     *   2. Notify via callback only on new detection (prevent duplicates)
+     *   3. Reset lastDetectedKey / lastDetectedInfo when popup disappears
+     */
+    async poll() {
+        try {
+            const contextId = this.cdpService.getPrimaryContextId();
+            const callParams = {
+                expression: DETECT_ERROR_POPUP_SCRIPT,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null) {
+                callParams.contextId = contextId;
+            }
+            const result = await this.cdpService.call('Runtime.evaluate', callParams);
+            const info = result?.result?.value ?? null;
+            if (info) {
+                // Duplicate prevention: use title + body snippet as key
+                const key = `${info.title}::${info.body.slice(0, 100)}`;
+                const now = Date.now();
+                const withinCooldown = (now - this.lastNotifiedAt) < ErrorPopupDetector.COOLDOWN_MS;
+                if (key !== this.lastDetectedKey && !withinCooldown) {
+                    this.lastDetectedKey = key;
+                    this.lastDetectedInfo = info;
+                    this.lastNotifiedAt = now;
+                    this.onErrorPopup(info);
+                }
+                else if (key === this.lastDetectedKey) {
+                    // Same key -- update stored info silently
+                    this.lastDetectedInfo = info;
+                }
+            }
+            else {
+                // Reset when popup disappears (prepare for next detection)
+                const wasDetected = this.lastDetectedKey !== null;
+                this.lastDetectedKey = null;
+                this.lastDetectedInfo = null;
+                if (wasDetected && this.onResolved) {
+                    this.onResolved();
+                }
+            }
+        }
+        catch (error) {
+            // Ignore CDP errors and continue monitoring
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('WebSocket is not connected')) {
+                return;
+            }
+            logger_1.logger.error('[ErrorPopupDetector] Error during polling:', error);
+        }
+    }
+    /** Internal click handler using buildClickScript from approvalDetector. */
+    async clickButton(buttonText) {
+        try {
+            const result = await this.runEvaluateScript((0, approvalDetector_1.buildClickScript)(buttonText));
+            return result?.ok === true;
+        }
+        catch (error) {
+            logger_1.logger.error('[ErrorPopupDetector] Error while clicking button:', error);
+            return false;
+        }
+    }
+    /** Execute Runtime.evaluate with contextId and return result.value. */
+    async runEvaluateScript(expression, awaitPromise = false) {
+        const contextId = this.cdpService.getPrimaryContextId();
+        const callParams = {
+            expression,
+            returnByValue: true,
+            awaitPromise,
+        };
+        if (contextId !== null) {
+            callParams.contextId = contextId;
+        }
+        const result = await this.cdpService.call('Runtime.evaluate', callParams);
+        return result?.result?.value;
+    }
+}
+exports.ErrorPopupDetector = ErrorPopupDetector;