lazy-gravity 0.6.0 → 0.6.2

package/dist/services/responseMonitor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseMonitor = exports.RESPONSE_SELECTORS = void 0;
+exports.captureResponseMonitorBaseline = captureResponseMonitorBaseline;
 const logger_1 = require("../utils/logger");
 const assistantDomExtractor_1 = require("./assistantDomExtractor");
 /** Lean DOM selectors for response extraction */
@@ -433,6 +434,125 @@ exports.RESPONSE_SELECTORS = {
         return diag;
     })()`,
 };
+/**
+ * Prefer the active runtime context first, then fall back to any discovered contexts.
+ */
+function getOrderedContextTargets(cdpService) {
+    const primaryId = cdpService.getPrimaryContextId?.() ?? null;
+    const rawContexts = cdpService.getContexts?.() ?? [];
+    const contexts = rawContexts
+        .filter((ctx) => ctx && typeof ctx.id === 'number')
+        .map((ctx) => ({
+        id: ctx.id,
+        name: typeof ctx.name === 'string' ? ctx.name : undefined,
+        url: typeof ctx.url === 'string' ? ctx.url : undefined,
+    }));
+    if (contexts.length === 0) {
+        return primaryId !== null ? [{ id: primaryId }] : [];
+    }
+    if (primaryId === null) {
+        return contexts;
+    }
+    const primary = contexts.find((ctx) => ctx.id === primaryId);
+    const ordered = primary ? [primary] : [{ id: primaryId }];
+    for (const ctx of contexts) {
+        if (ctx.id !== primaryId)
+            ordered.push(ctx);
+    }
+    return ordered;
+}
+/**
+ * Evaluate an expression across known runtime contexts until one returns an acceptable value.
+ */
+async function evaluateAcrossContexts(cdpService, expression, accept, options) {
+    const awaitPromise = options?.awaitPromise ?? true;
+    const targets = getOrderedContextTargets(cdpService);
+    let firstValue = null;
+    let lastError = null;
+    if (targets.length === 0) {
+        const result = await cdpService.call('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise,
+        });
+        return {
+            value: (result?.result?.value ?? null),
+            contextId: null,
+            contextName: null,
+            contextUrl: null,
+        };
+    }
+    for (const target of targets) {
+        try {
+            const result = await cdpService.call('Runtime.evaluate', {
+                expression,
+                returnByValue: true,
+                awaitPromise,
+                contextId: target.id,
+            });
+            const value = (result?.result?.value ?? null);
+            const probed = {
+                value,
+                contextId: target.id,
+                contextName: target.name ?? null,
+                contextUrl: target.url ?? null,
+            };
+            if (!firstValue)
+                firstValue = probed;
+            if (accept(value)) {
+                return probed;
+            }
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (firstValue) {
+        return firstValue;
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    return {
+        value: null,
+        contextId: null,
+        contextName: null,
+        contextUrl: null,
+    };
+}
+/**
+ * Capture the current assistant/output DOM state before sending a new prompt.
+ * This avoids races where a fast reply is mistaken for baseline text.
+ */
+async function captureResponseMonitorBaseline(cdpService) {
+    let text = null;
+    try {
+        const textResult = await evaluateAcrossContexts(cdpService, exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+        text = typeof textResult.value === 'string' ? textResult.value.trim() || null : null;
+    }
+    catch {
+        text = null;
+    }
+    const processLogKeys = new Set();
+    try {
+        const logResult = await evaluateAcrossContexts(cdpService, exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+        const logEntries = logResult.value;
+        if (Array.isArray(logEntries)) {
+            for (const entry of logEntries) {
+                const key = String(entry || '').replace(/\r/g, '').trim().slice(0, 200);
+                if (key)
+                    processLogKeys.add(key);
+            }
+        }
+    }
+    catch {
+        // best-effort baseline capture
+    }
+    return {
+        text,
+        processLogKeys: Array.from(processLogKeys),
+    };
+}
 /**
  * Lean AI response monitor.
  *
@@ -452,6 +572,8 @@ class ResponseMonitor {
     onTimeout;
     onPhaseChange;
     onProcessLog;
+    initialBaselineText;
+    initialSeenProcessLogKeys;
     pollTimer = null;
     isRunning = false;
     lastText = null;
@@ -462,6 +584,7 @@ class ResponseMonitor {
     quotaDetected = false;
     seenProcessLogKeys = new Set();
     structuredDiagLogged = false;
+    lastContentContextId = null;
     // CDP disconnect handling (#48)
     isPaused = false;
     onCdpDisconnected = null;
@@ -480,6 +603,8 @@ class ResponseMonitor {
         this.onTimeout = options.onTimeout;
         this.onPhaseChange = options.onPhaseChange;
         this.onProcessLog = options.onProcessLog;
+        this.initialBaselineText = options.initialBaselineText;
+        this.initialSeenProcessLogKeys = options.initialSeenProcessLogKeys;
     }
     /** Start monitoring */
     async start() {
@@ -508,28 +633,38 @@ class ResponseMonitor {
         this.quotaDetected = false;
         this.seenProcessLogKeys = new Set();
         this.onPhaseChange?.(this.currentPhase, null);
-        // Capture baseline text
-        try {
-            const baseResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
-            const rawValue = baseResult?.result?.value;
-            this.baselineText = typeof rawValue === 'string' ? rawValue.trim() || null : null;
-        }
-        catch {
-            this.baselineText = null;
+        if (this.initialBaselineText !== undefined) {
+            this.baselineText = this.initialBaselineText;
         }
-        // Capture baseline process logs as already-seen keys
-        try {
-            const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
-            const logEntries = logResult?.result?.value;
-            if (Array.isArray(logEntries)) {
-                this.seenProcessLogKeys = new Set(logEntries
-                    .map((s) => (s || '').replace(/\r/g, '').trim())
-                    .filter((s) => s.length > 0)
-                    .map((s) => s.slice(0, 200)));
+        else {
+            try {
+                const baseResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+                this.baselineText = typeof baseResult.value === 'string' ? baseResult.value.trim() || null : null;
+            }
+            catch {
+                this.baselineText = null;
             }
         }
-        catch {
-            // baseline capture only
+        if (this.initialSeenProcessLogKeys !== undefined) {
+            this.seenProcessLogKeys = new Set(this.initialSeenProcessLogKeys
+                .map((s) => (s || '').replace(/\r/g, '').trim())
+                .filter((s) => s.length > 0)
+                .map((s) => s.slice(0, 200)));
+        }
+        else {
+            try {
+                const logResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+                const logEntries = logResult.value;
+                if (Array.isArray(logEntries)) {
+                    this.seenProcessLogKeys = new Set(logEntries
+                        .map((s) => (s || '').replace(/\r/g, '').trim())
+                        .filter((s) => s.length > 0)
+                        .map((s) => s.slice(0, 200)));
+                }
+            }
+            catch {
+                // baseline capture only
+            }
         }
         // In structured mode, also capture activity lines from the structured
         // extraction to align the baseline with polling logic. The PROCESS_LOGS
@@ -538,8 +673,8 @@ class ResponseMonitor {
         // 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);
+                const structuredBaseline = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED, (value) => (0, assistantDomExtractor_1.classifyAssistantSegments)(value).diagnostics.source === 'dom-structured');
+                const baselineClassified = (0, assistantDomExtractor_1.classifyAssistantSegments)(structuredBaseline.value);
                 if (baselineClassified.diagnostics.source === 'dom-structured') {
                     for (const line of baselineClassified.activityLines) {
                         const key = (line || '').replace(/\r/g, '').trim().slice(0, 200);
@@ -589,12 +724,15 @@ class ResponseMonitor {
     /** Click the stop button to interrupt LLM generation */
     async clickStopButton() {
         try {
-            const result = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.CLICK_STOP_BUTTON));
-            const value = result?.result?.value;
+            const result = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.CLICK_STOP_BUTTON, (value) => !!(value && typeof value === 'object' && value.ok));
+            const value = result.value;
             if (this.isRunning) {
                 await this.stop();
             }
-            return value ?? { ok: false, error: 'CDP evaluation returned empty' };
+            if (value && typeof value.ok === 'boolean') {
+                return value;
+            }
+            return { ok: false, error: 'CDP evaluation returned empty' };
         }
         catch (error) {
             return { ok: false, error: error.message || 'Failed to click stop button' };
@@ -693,17 +831,70 @@ class ResponseMonitor {
             }
         }, this.pollIntervalMs);
     }
-    buildEvaluateParams(expression) {
-        const params = {
-            expression,
-            returnByValue: true,
+    async evaluateAcrossContexts(expression, accept) {
+        const result = await evaluateAcrossContexts(this.cdpService, expression, accept, {
             awaitPromise: true,
-        };
-        const contextId = this.cdpService.getPrimaryContextId?.();
-        if (contextId !== null && contextId !== undefined) {
-            params.contextId = contextId;
+        });
+        if (result.contextId !== null
+            && accept(result.value)
+            && this.lastContentContextId !== result.contextId) {
+            this.lastContentContextId = result.contextId;
+            logger_1.logger.debug(`[ResponseMonitor] Using context ${result.contextId} (${result.contextName ?? 'unknown'} | ${result.contextUrl ?? 'no-url'})`);
+        }
+        return result;
+    }
+    async logStructuredExtractionDiagnostics(payload) {
+        try {
+            const dumpResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.DUMP_ALL_TEXTS, (value) => Array.isArray(value) && value.length > 0);
+            const dumpValue = Array.isArray(dumpResult.value) ? dumpResult.value : [];
+            const accepted = dumpValue.filter((entry) => !entry?.skip).slice(0, 5);
+            const skipped = dumpValue.filter((entry) => entry?.skip).slice(0, 5);
+            logger_1.logger.warn(`[ResponseMonitor:diag] Structured payload invalid — ${dumpValue.length} candidate(s), ` +
+                `${accepted.length} accepted, ${skipped.length} skipped ` +
+                `(context=${dumpResult.contextId ?? 'none'})`);
+            logger_1.logger.debug('[ResponseMonitor:diag] Candidate details:', JSON.stringify({
+                payloadType: payload === null ? 'null' : typeof payload,
+                contextId: dumpResult.contextId,
+                contextUrl: dumpResult.contextUrl,
+                totalCandidates: dumpValue.length,
+                accepted: accepted.map((entry) => ({
+                    sel: entry.sel,
+                    len: entry.len,
+                    preview: entry.preview,
+                })),
+                skipped: skipped.map((entry) => ({
+                    sel: entry.sel,
+                    skip: entry.skip,
+                    len: entry.len,
+                    preview: entry.preview,
+                })),
+            }));
+        }
+        catch (error) {
+            logger_1.logger.warn('[ResponseMonitor:diag] DUMP_ALL_TEXTS failed:', error);
+        }
+        try {
+            const domResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.DOM_DIAGNOSTIC, (value) => !!value && typeof value === 'object' && (Array.isArray(value.allTextNodes)
+                || Array.isArray(value.activityNodes)
+                || Array.isArray(value.detailsDump)));
+            const domValue = domResult.value;
+            logger_1.logger.warn(`[ResponseMonitor:diag] DOM_DIAGNOSTIC — ` +
+                `details=${domValue?.detailsCount ?? 0}, ` +
+                `activity=${Array.isArray(domValue?.activityNodes) ? domValue.activityNodes.length : 0}, ` +
+                `textNodes=${Array.isArray(domValue?.allTextNodes) ? domValue.allTextNodes.length : 0} ` +
+                `(context=${domResult.contextId ?? 'none'})`);
+            logger_1.logger.debug('[ResponseMonitor:diag] DOM_DIAGNOSTIC details:', JSON.stringify({
+                contextId: domResult.contextId,
+                contextUrl: domResult.contextUrl,
+                detailsCount: domValue?.detailsCount ?? null,
+                detailsDump: Array.isArray(domValue?.detailsDump) ? domValue.detailsDump.slice(0, 3) : [],
+                activityNodes: Array.isArray(domValue?.activityNodes) ? domValue.activityNodes.slice(0, 5) : [],
+                allTextNodes: Array.isArray(domValue?.allTextNodes) ? domValue.allTextNodes.slice(0, 5) : [],
+            }));
+        }
+        catch (error) {
+            logger_1.logger.warn('[ResponseMonitor:diag] DOM_DIAGNOSTIC failed:', error);
         }
-        return params;
     }
     /**
      * Emit new process log entries, deduplicating against previously seen keys.
@@ -738,20 +929,20 @@ class ResponseMonitor {
     async poll() {
         try {
             // 1. Stop button check
-            const stopResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.STOP_BUTTON));
-            const stopValue = stopResult?.result?.value;
+            const stopResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.STOP_BUTTON, (value) => !!(value && typeof value === 'object' && value.isGenerating));
+            const stopValue = stopResult.value;
             const isGenerating = !!(stopValue && typeof stopValue === 'object' && stopValue.isGenerating);
             // 2. Quota error check
-            const quotaResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.QUOTA_ERROR));
-            const quotaDetected = quotaResult?.result?.value === true;
+            const quotaResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.QUOTA_ERROR, (value) => value === true);
+            const quotaDetected = quotaResult.value === true;
             // 3. Text extraction (structured or legacy)
             let currentText = null;
             let structuredHandledLogs = false;
             if (this.extractionMode === 'structured') {
                 // Structured: use DOM segment extraction with HTML-to-Markdown
                 try {
-                    const structuredResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED));
-                    const payload = structuredResult?.result?.value;
+                    const structuredResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_STRUCTURED, (value) => (0, assistantDomExtractor_1.classifyAssistantSegments)(value).diagnostics.source === 'dom-structured');
+                    const payload = structuredResult.value;
                     const classified = (0, assistantDomExtractor_1.classifyAssistantSegments)(payload);
                     if (classified.diagnostics.source === 'dom-structured') {
                         currentText = classified.finalOutputText.trim() || null;
@@ -768,6 +959,7 @@ class ResponseMonitor {
                     else if (!this.structuredDiagLogged) {
                         this.structuredDiagLogged = true;
                         logger_1.logger.warn('[ResponseMonitor:poll] Structured extraction failed — reason:', classified.diagnostics.fallbackReason ?? 'unknown', '| payload type:', typeof payload, '| payload:', payload === null ? 'null' : payload === undefined ? 'undefined' : 'object');
+                        await this.logStructuredExtractionDiagnostics(payload);
                     }
                 }
                 catch (error) {
@@ -776,19 +968,14 @@ class ResponseMonitor {
             }
             // Legacy path (or fallback from structured)
             if (currentText === null) {
-                const textResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
-                const rawText = textResult?.result?.value;
-                const exceptionDetail = textResult?.result?.exceptionDetails ?? textResult?.exceptionDetails;
-                if (exceptionDetail) {
-                    logger_1.logger.warn('[ResponseMonitor:poll] RESPONSE_TEXT threw:', exceptionDetail.text ?? JSON.stringify(exceptionDetail).slice(0, 200));
-                }
-                currentText = typeof rawText === 'string' ? rawText.trim() || null : null;
+                const textResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.RESPONSE_TEXT, (value) => typeof value === 'string' && value.trim().length > 0);
+                currentText = typeof textResult.value === 'string' ? textResult.value.trim() || null : null;
             }
             // 4. Process log extraction — always when structured didn't handle it
             if (!structuredHandledLogs) {
                 try {
-                    const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
-                    const logEntries = logResult?.result?.value;
+                    const logResult = await this.evaluateAcrossContexts(exports.RESPONSE_SELECTORS.PROCESS_LOGS, (value) => Array.isArray(value) && value.length > 0);
+                    const logEntries = logResult.value;
                     if (Array.isArray(logEntries)) {
                         this.emitNewProcessLogs(logEntries);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Control Antigravity from anywhere — a local, secure bot (Discord + Telegram) that lets you remotely operate Antigravity on your home PC from your smartphone.",
   "main": "dist/index.js",
   "bin": {