@steipete/oracle 0.8.5 → 0.8.6

package/dist/src/browser/actions/promptComposer.js

@@ -18,6 +18,13 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       ${buildClickDispatcher()}
       const SELECTORS = ${JSON.stringify(INPUT_SELECTORS)};
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') {
+          return false;
+        }
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
       const focusNode = (node) => {
         if (!node) {
           return false;
@@ -39,13 +46,17 @@ export async function submitPrompt(deps, prompt, logger) {
         return true;
       };
 
+      const candidates = [];
       for (const selector of SELECTORS) {
         const node = document.querySelector(selector);
-        if (!node) continue;
-        if (focusNode(node)) {
-          return { focused: true };
+        if (node) {
+          candidates.push(node);
         }
       }
+      const preferred = candidates.find((node) => isVisible(node)) || candidates[0];
+      if (preferred && focusNode(preferred)) {
+        return { focused: true };
+      }
       return { focused: false };
     })()`,
         returnByValue: true,
@@ -65,18 +76,36 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
+      const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+      const readValue = (node) => {
+        if (!node) return '';
+        if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+        return node.innerText ?? '';
+      };
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const candidates = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      const active = candidates.find((node) => isVisible(node)) || candidates[0] || null;
       return {
         editorText: editor?.innerText ?? '',
         fallbackValue: fallback?.value ?? '',
+        activeValue: active ? readValue(active) : '',
       };
     })()`,
         returnByValue: true,
     });
     const editorTextRaw = verification.result?.value?.editorText ?? '';
     const fallbackValueRaw = verification.result?.value?.fallbackValue ?? '';
+    const activeValueRaw = verification.result?.value?.activeValue ?? '';
     const editorTextTrimmed = editorTextRaw?.trim?.() ?? '';
     const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? '';
-    if (!editorTextTrimmed && !fallbackValueTrimmed) {
+    const activeValueTrimmed = activeValueRaw?.trim?.() ?? '';
+    if (!editorTextTrimmed && !fallbackValueTrimmed && !activeValueTrimmed) {
         // Learned: occasionally Input.insertText doesn't land in the editor; force textContent/value + input events.
         await runtime.evaluate({
             expression: `(() => {
@@ -100,16 +129,33 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
+      const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+      const readValue = (node) => {
+        if (!node) return '';
+        if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+        return node.innerText ?? '';
+      };
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const candidates = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      const active = candidates.find((node) => isVisible(node)) || candidates[0] || null;
       return {
         editorText: editor?.innerText ?? '',
         fallbackValue: fallback?.value ?? '',
+        activeValue: active ? readValue(active) : '',
       };
     })()`,
         returnByValue: true,
     });
     const observedEditor = postVerification.result?.value?.editorText ?? '';
     const observedFallback = postVerification.result?.value?.fallbackValue ?? '';
-    const observedLength = Math.max(observedEditor.length, observedFallback.length);
+    const observedActive = postVerification.result?.value?.activeValue ?? '';
+    const observedLength = Math.max(observedEditor.length, observedFallback.length, observedActive.length);
     if (promptLength >= 50_000 && observedLength > 0 && observedLength < promptLength - 2_000) {
         // Learned: very large prompts can truncate silently; fail fast so we can fall back to file uploads.
         await logDomFailure(runtime, logger, 'prompt-too-large');
@@ -144,10 +190,12 @@ export async function submitPrompt(deps, prompt, logger) {
 export async function clearPromptComposer(Runtime, logger) {
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const result = await Runtime.evaluate({
         expression: `(() => {
       const fallback = document.querySelector(${fallbackSelectorLiteral});
       const editor = document.querySelector(${primarySelectorLiteral});
+      const inputSelectors = ${inputSelectorsLiteral};
       let cleared = false;
       if (fallback) {
         fallback.value = '';
@@ -160,6 +208,24 @@ export async function clearPromptComposer(Runtime, logger) {
         editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
         cleared = true;
       }
+      const nodes = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      for (const node of nodes) {
+        if (!node) continue;
+        if (node instanceof HTMLTextAreaElement) {
+          node.value = '';
+          node.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+          node.dispatchEvent(new Event('change', { bubbles: true }));
+          cleared = true;
+          continue;
+        }
+        if (node.isContentEditable || node.getAttribute('contenteditable') === 'true') {
+          node.textContent = '';
+          node.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+          cleared = true;
+        }
+      }
       return { cleared };
     })()`,
         returnByValue: true,
@@ -281,15 +347,34 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
     const encodedPrompt = JSON.stringify(prompt.trim());
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const stopSelectorLiteral = JSON.stringify(STOP_BUTTON_SELECTOR);
     const assistantSelectorLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
-    const baselineLiteral = typeof baselineTurns === 'number' && Number.isFinite(baselineTurns) && baselineTurns >= 0
+    const turnSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    let baseline = typeof baselineTurns === 'number' && Number.isFinite(baselineTurns) && baselineTurns >= 0
         ? Math.floor(baselineTurns)
-        : -1;
+        : null;
+    if (baseline === null) {
+        try {
+            const { result } = await Runtime.evaluate({
+                expression: `document.querySelectorAll(${turnSelectorLiteral}).length`,
+                returnByValue: true,
+            });
+            const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+            if (Number.isFinite(raw)) {
+                baseline = Math.max(0, Math.floor(raw));
+            }
+        }
+        catch {
+            // ignore; baseline stays unknown
+        }
+    }
+    const baselineLiteral = baseline ?? -1;
     // Learned: ChatGPT can echo/format text; normalize markdown and use prefix matches to detect the sent prompt.
     const script = `(() => {
-	    const editor = document.querySelector(${primarySelectorLiteral});
-	    const fallback = document.querySelector(${fallbackSelectorLiteral});
+		    const editor = document.querySelector(${primarySelectorLiteral});
+		    const fallback = document.querySelector(${fallbackSelectorLiteral});
+		    const inputSelectors = ${inputSelectorsLiteral};
 	    const normalize = (value) => {
 	      let text = value?.toLowerCase?.() ?? '';
 	      // Strip markdown *markers* but keep content (ChatGPT renders fence markers differently).
@@ -303,35 +388,53 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
 	    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
 	    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
 	    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
+	    const readValue = (node) => {
+	      if (!node) return '';
+	      if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+	      return node.innerText ?? '';
+	    };
+	    const isVisible = (node) => {
+	      if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+	      const rect = node.getBoundingClientRect();
+	      return rect.width > 0 && rect.height > 0;
+	    };
+	    const inputs = inputSelectors
+	      .map((selector) => document.querySelector(selector))
+	      .filter((node) => Boolean(node));
+	    const visibleInputs = inputs.filter((node) => isVisible(node));
+	    const activeInputs = visibleInputs.length > 0 ? visibleInputs : inputs;
 	    const userMatched =
 	      normalizedPrompt.length > 0 && normalizedTurns.some((text) => text.includes(normalizedPrompt));
 	    const prefixMatched =
 	      normalizedPromptPrefix.length > 30 &&
 	      normalizedTurns.some((text) => text.includes(normalizedPromptPrefix));
-	    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
-	    const lastMatched =
-	      normalizedPrompt.length > 0 &&
-	      (lastTurn.includes(normalizedPrompt) ||
-	        (normalizedPromptPrefix.length > 30 && lastTurn.includes(normalizedPromptPrefix)));
-	    const baseline = ${baselineLiteral};
-	    const hasNewTurn = baseline < 0 ? true : normalizedTurns.length > baseline;
-      const stopVisible = Boolean(document.querySelector(${stopSelectorLiteral}));
-      const assistantVisible = Boolean(
-        document.querySelector(${assistantSelectorLiteral}) ||
-        document.querySelector('[data-testid*="assistant"]'),
-      );
-      // Learned: composer clearing + stop button or assistant presence is a reliable fallback signal.
+		    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
+		    const lastMatched =
+		      normalizedPrompt.length > 0 &&
+		      (lastTurn.includes(normalizedPrompt) ||
+		        (normalizedPromptPrefix.length > 30 && lastTurn.includes(normalizedPromptPrefix)));
+		    const baseline = ${baselineLiteral};
+		    const hasNewTurn = baseline < 0 ? false : normalizedTurns.length > baseline;
+		    const stopVisible = Boolean(document.querySelector(${stopSelectorLiteral}));
+		    const assistantVisible = Boolean(
+		      document.querySelector(${assistantSelectorLiteral}) ||
+		      document.querySelector('[data-testid*="assistant"]'),
+		    );
+	    // Learned: composer clearing + stop button or assistant presence is a reliable fallback signal.
       const editorValue = editor?.innerText ?? '';
       const fallbackValue = fallback?.value ?? '';
-      const composerCleared = !(String(editorValue).trim() || String(fallbackValue).trim());
+      const activeEmpty =
+        activeInputs.length === 0 ? null : activeInputs.every((node) => !String(readValue(node)).trim());
+      const composerCleared = activeEmpty ?? !(String(editorValue).trim() || String(fallbackValue).trim());
       const href = typeof location === 'object' && location.href ? location.href : '';
       const inConversation = /\\/c\\//.test(href);
-	    return {
-      userMatched,
-      prefixMatched,
-      lastMatched,
-      hasNewTurn,
-      stopVisible,
+		    return {
+        baseline,
+	      userMatched,
+	      prefixMatched,
+	      lastMatched,
+	      hasNewTurn,
+	      stopVisible,
       assistantVisible,
       composerCleared,
       inConversation,
@@ -346,12 +449,14 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const info = result.value;
         const turnsCount = result.value?.turnsCount;
-        if (info?.hasNewTurn && (info?.lastMatched || info?.userMatched || info?.prefixMatched)) {
+        const matchesPrompt = Boolean(info?.lastMatched || info?.userMatched || info?.prefixMatched);
+        const baselineUnknown = typeof info?.baseline === 'number' ? info.baseline < 0 : baselineLiteral < 0;
+        if (matchesPrompt && (baselineUnknown || info?.hasNewTurn)) {
             return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
         }
         const fallbackCommit = info?.composerCleared &&
-            ((info?.stopVisible ?? false) ||
-                (info?.hasNewTurn && (info?.assistantVisible || info?.inConversation)));
+            Boolean(info?.hasNewTurn) &&
+            ((info?.stopVisible ?? false) || info?.assistantVisible || info?.inConversation);
         if (fallbackCommit) {
             return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
         }
@@ -374,3 +479,7 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
     }
     throw new Error('Prompt did not appear in conversation before timeout (send may have failed)');
 }
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    verifyPromptCommitted,
+};

package/dist/src/browser/chromeLifecycle.js

@@ -7,6 +7,7 @@ import { promisify } from 'node:util';
 import CDP from 'chrome-remote-interface';
 import { launch, Launcher } from 'chrome-launcher';
 import { cleanupStaleProfileState } from './profileState.js';
+import { delay } from './utils.js';
 const execFileAsync = promisify(execFile);
 export async function launchChrome(config, userDataDir, logger) {
     const connectHost = resolveRemoteDebugHost();
@@ -181,17 +182,32 @@ async function connectToNewTarget(host, port, url, logger, messages) {
     }
     return null;
 }
-export async function connectWithNewTab(port, logger, initialUrl, host) {
+export async function connectWithNewTab(port, logger, initialUrl, host, options) {
     const effectiveHost = host ?? '127.0.0.1';
     const url = initialUrl ?? 'about:blank';
-    const targetConnection = await connectToNewTarget(effectiveHost, port, url, logger, {
-        opened: (targetId) => `Opened isolated browser tab (target=${targetId})`,
-        openFailed: (message) => `Failed to open isolated browser tab (${message}); falling back to default target.`,
-        attachFailed: (targetId, message) => `Failed to attach to isolated browser tab ${targetId} (${message}); falling back to default target.`,
-        closeFailed: (targetId, message) => `Failed to close unused browser tab ${targetId}: ${message}`,
-    });
-    if (targetConnection) {
-        return targetConnection;
+    const fallbackToDefault = options?.fallbackToDefault ?? true;
+    const retries = Math.max(0, options?.retries ?? 0);
+    const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 250);
+    const fallbackLabel = fallbackToDefault ? 'falling back to default target.' : 'strict mode: not falling back.';
+    let attempt = 0;
+    while (attempt <= retries) {
+        const targetConnection = await connectToNewTarget(effectiveHost, port, url, logger, {
+            opened: (targetId) => `Opened isolated browser tab (target=${targetId})`,
+            openFailed: (message) => `Failed to open isolated browser tab (${message}); ${fallbackLabel}`,
+            attachFailed: (targetId, message) => `Failed to attach to isolated browser tab ${targetId} (${message}); ${fallbackLabel}`,
+            closeFailed: (targetId, message) => `Failed to close unused browser tab ${targetId}: ${message}`,
+        });
+        if (targetConnection) {
+            return targetConnection;
+        }
+        if (attempt >= retries) {
+            break;
+        }
+        attempt += 1;
+        await delay(retryDelayMs * attempt);
+    }
+    if (!fallbackToDefault) {
+        throw new Error('Failed to open isolated browser tab; refusing to attach to default target.');
     }
     const client = await connectToChrome(port, logger, effectiveHost);
     return { client };

package/dist/src/browser/config.js

@@ -12,6 +12,13 @@ export const DEFAULT_BROWSER_CONFIG = {
     timeoutMs: 1_200_000,
     debugPort: null,
     inputTimeoutMs: 60_000,
+    assistantRecheckDelayMs: 0,
+    assistantRecheckTimeoutMs: 120_000,
+    reuseChromeWaitMs: 10_000,
+    profileLockTimeoutMs: 300_000,
+    autoReattachDelayMs: 0,
+    autoReattachIntervalMs: 0,
+    autoReattachTimeoutMs: 120_000,
     cookieSync: true,
     cookieNames: null,
     cookieSyncWaitMs: 0,
@@ -57,6 +64,13 @@ export function resolveBrowserConfig(config) {
         timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
         debugPort: config?.debugPort ?? debugPortEnv ?? DEFAULT_BROWSER_CONFIG.debugPort,
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
+        assistantRecheckDelayMs: config?.assistantRecheckDelayMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckDelayMs,
+        assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
+        reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
+        profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
+        autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
+        autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
+        autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
         cookieSync: config?.cookieSync ?? cookieSyncDefault,
         cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
         cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,