lazy-gravity 0.1.0 → 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

@@ -98,6 +98,7 @@ class ErrorPopupDetector {
     cdpService;
     pollIntervalMs;
     onErrorPopup;
+    onResolved;
     pollTimer = null;
     isRunning = false;
     /** Key of the last detected error popup (for duplicate notification prevention) */
@@ -112,6 +113,7 @@ class ErrorPopupDetector {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 3000;
         this.onErrorPopup = options.onErrorPopup;
+        this.onResolved = options.onResolved;
     }
     /** Start monitoring. */
     start() {
@@ -223,8 +225,12 @@ class ErrorPopupDetector {
             }
             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) {

package/dist/services/planningDetector.js

@@ -149,6 +149,7 @@ class PlanningDetector {
     cdpService;
     pollIntervalMs;
     onPlanningRequired;
+    onResolved;
     pollTimer = null;
     isRunning = false;
     /** Key of the last detected planning info (for duplicate notification prevention) */
@@ -163,6 +164,7 @@ class PlanningDetector {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
         this.onPlanningRequired = options.onPlanningRequired;
+        this.onResolved = options.onResolved;
     }
     /** Start monitoring. */
     start() {
@@ -270,8 +272,12 @@ class PlanningDetector {
             }
             else {
                 // Reset when buttons disappear (prepare for next planning detection)
+                const wasDetected = this.lastDetectedKey !== null;
                 this.lastDetectedKey = null;
                 this.lastDetectedInfo = null;
+                if (wasDetected && this.onResolved) {
+                    this.onResolved();
+                }
             }
         }
         catch (error) {

package/dist/services/responseMonitor.js

@@ -453,7 +453,6 @@ class ResponseMonitor {
     onPhaseChange;
     onProcessLog;
     pollTimer = null;
-    timeoutTimer = null;
     isRunning = false;
     lastText = null;
     baselineText = null;
@@ -463,6 +462,13 @@ class ResponseMonitor {
     quotaDetected = false;
     seenProcessLogKeys = new Set();
     structuredDiagLogged = false;
+    // CDP disconnect handling (#48)
+    isPaused = false;
+    onCdpDisconnected = null;
+    onCdpReconnected = null;
+    onCdpReconnectFailed = null;
+    // Activity-based timeout (#49)
+    lastActivityTime = 0;
     constructor(options) {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 2000;
@@ -478,18 +484,31 @@ class ResponseMonitor {
     }
     /** Start monitoring */
     async start() {
+        return this.initMonitoring(false);
+    }
+    /**
+     * Start monitoring in passive mode.
+     * Same as start() but with generationStarted=true, so text changes
+     * are detected immediately without waiting for the stop button to appear.
+     * Used when joining an existing session that may already be generating.
+     */
+    async startPassive() {
+        return this.initMonitoring(true);
+    }
+    /** Internal initialization shared between start() and startPassive() */
+    async initMonitoring(passive) {
         if (this.isRunning)
             return;
         this.isRunning = true;
+        this.isPaused = false;
         this.lastText = null;
         this.baselineText = null;
-        this.generationStarted = false;
-        this.currentPhase = 'waiting';
+        this.generationStarted = passive;
+        this.currentPhase = passive ? 'generating' : 'waiting';
         this.stopGoneCount = 0;
         this.quotaDetected = false;
         this.seenProcessLogKeys = new Set();
-        // Always fire callback on start, even though phase is already 'waiting'
-        this.onPhaseChange?.('waiting', null);
+        this.onPhaseChange?.(this.currentPhase, null);
         // Capture baseline text
         try {
             const baseResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
@@ -513,35 +532,44 @@ class ResponseMonitor {
         catch {
             // baseline capture only
         }
-        // Set timeout timer
-        if (this.maxDurationMs > 0) {
-            this.timeoutTimer = setTimeout(async () => {
-                const lastText = this.lastText ?? '';
-                this.setPhase('timeout', lastText);
-                await this.stop();
-                try {
-                    await Promise.resolve(this.onTimeout?.(lastText));
-                }
-                catch (error) {
-                    logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+        // In structured mode, also capture activity lines from the structured
+        // extraction to align the baseline with polling logic. The PROCESS_LOGS
+        // script skips <details> content, but structured extraction (Pass 2)
+        // explicitly walks <details> elements — without this, tool-call/thinking
+        // entries from previous turns leak into the process log as "new" entries.
+        if (this.extractionMode === 'structured') {
+            try {
+                const structuredBaseline = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED));
+                const baselineClassified = (0, assistantDomExtractor_1.classifyAssistantSegments)(structuredBaseline?.result?.value);
+                if (baselineClassified.diagnostics.source === 'dom-structured') {
+                    for (const line of baselineClassified.activityLines) {
+                        const key = (line || '').replace(/\r/g, '').trim().slice(0, 200);
+                        if (key)
+                            this.seenProcessLogKeys.add(key);
+                    }
                 }
-            }, this.maxDurationMs);
+            }
+            catch {
+                // structured baseline is best-effort
+            }
         }
-        logger_1.logger.info(`── Monitoring started | poll=${this.pollIntervalMs}ms timeout=${this.maxDurationMs / 1000}s baseline=${this.baselineText?.length ?? 0}ch`);
-        // Start polling
+        // Activity-based timeout: track last activity time instead of fixed timer (#49)
+        this.lastActivityTime = Date.now();
+        // Register CDP connection event listeners (#48)
+        this.registerCdpConnectionListeners();
+        const mode = passive ? 'Passive monitoring' : 'Monitoring';
+        logger_1.logger.debug(`── ${mode} started | poll=${this.pollIntervalMs}ms inactivityTimeout=${this.maxDurationMs / 1000}s baseline=${this.baselineText?.length ?? 0}ch`);
         this.schedulePoll();
     }
     /** Stop monitoring */
     async stop() {
         this.isRunning = false;
+        this.isPaused = false;
+        this.unregisterCdpConnectionListeners();
         if (this.pollTimer) {
             clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-            this.timeoutTimer = null;
-        }
     }
     /** Get current phase */
     getPhase() {
@@ -593,14 +621,71 @@ class ResponseMonitor {
                 case 'quotaReached':
                     logger_1.logger.warn('Quota Reached');
                     break;
+                case 'disconnected':
+                    logger_1.logger.warn(`CDP Disconnected — paused (${len} chars captured)`);
+                    break;
                 default:
                     logger_1.logger.phase(`${phase}`);
             }
             this.onPhaseChange?.(phase, text);
         }
     }
+    registerCdpConnectionListeners() {
+        this.onCdpDisconnected = () => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.warn('[ResponseMonitor] CDP disconnected — pausing poll');
+            this.isPaused = true;
+            if (this.pollTimer) {
+                clearTimeout(this.pollTimer);
+                this.pollTimer = null;
+            }
+            this.setPhase('disconnected', this.lastText);
+        };
+        this.onCdpReconnected = () => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.warn('[ResponseMonitor] CDP reconnected — resuming poll');
+            this.isPaused = false;
+            this.lastActivityTime = Date.now();
+            const resumePhase = this.generationStarted ? 'generating' : 'waiting';
+            this.setPhase(resumePhase, this.lastText);
+            this.schedulePoll();
+        };
+        this.onCdpReconnectFailed = async (err) => {
+            if (!this.isRunning)
+                return;
+            logger_1.logger.error('[ResponseMonitor] CDP reconnection failed — stopping monitor:', err.message);
+            const lastText = this.lastText ?? '';
+            this.setPhase('disconnected', lastText);
+            await this.stop();
+            try {
+                await Promise.resolve(this.onTimeout?.(lastText));
+            }
+            catch (error) {
+                logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+            }
+        };
+        this.cdpService.on('disconnected', this.onCdpDisconnected);
+        this.cdpService.on('reconnected', this.onCdpReconnected);
+        this.cdpService.on('reconnectFailed', this.onCdpReconnectFailed);
+    }
+    unregisterCdpConnectionListeners() {
+        if (this.onCdpDisconnected) {
+            this.cdpService.removeListener('disconnected', this.onCdpDisconnected);
+            this.onCdpDisconnected = null;
+        }
+        if (this.onCdpReconnected) {
+            this.cdpService.removeListener('reconnected', this.onCdpReconnected);
+            this.onCdpReconnected = null;
+        }
+        if (this.onCdpReconnectFailed) {
+            this.cdpService.removeListener('reconnectFailed', this.onCdpReconnectFailed);
+            this.onCdpReconnectFailed = null;
+        }
+    }
     schedulePoll() {
-        if (!this.isRunning)
+        if (!this.isRunning || this.isPaused)
             return;
         this.pollTimer = setTimeout(async () => {
             await this.poll();
@@ -637,6 +722,7 @@ class ResponseMonitor {
             newEntries.push(normalized.slice(0, 300));
         }
         if (newEntries.length > 0) {
+            this.lastActivityTime = Date.now();
             try {
                 this.onProcessLog?.(newEntries.join('\n\n'));
             }
@@ -714,6 +800,7 @@ class ResponseMonitor {
             }
             // Handle stop button appearing
             if (isGenerating) {
+                this.lastActivityTime = Date.now();
                 if (!this.generationStarted) {
                     this.generationStarted = true;
                     this.setPhase('thinking', null);
@@ -748,6 +835,7 @@ class ResponseMonitor {
             // Text change handling
             const textChanged = effectiveText !== null && effectiveText !== this.lastText;
             if (textChanged) {
+                this.lastActivityTime = Date.now();
                 this.lastText = effectiveText;
                 if (this.currentPhase === 'waiting' || this.currentPhase === 'thinking') {
                     this.setPhase('generating', effectiveText);
@@ -773,6 +861,19 @@ class ResponseMonitor {
                     return;
                 }
             }
+            // Activity-based inactivity timeout (#49)
+            if (this.maxDurationMs > 0 && Date.now() - this.lastActivityTime >= this.maxDurationMs) {
+                const lastText = this.lastText ?? '';
+                this.setPhase('timeout', lastText);
+                await this.stop();
+                try {
+                    await Promise.resolve(this.onTimeout?.(lastText));
+                }
+                catch (error) {
+                    logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+                }
+                return;
+            }
         }
         catch (error) {
             logger_1.logger.error('[ResponseMonitor] poll error:', error);