@steipete/oracle 0.7.5 → 0.8.0

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

@@ -1,9 +1,9 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from '../constants.js';
 import { logDomFailure } from '../domDebug.js';
 import { buildClickDispatcher } from './domEvents.js';
-export async function ensureModelSelection(Runtime, desiredModel, logger) {
+export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = 'select') {
     const outcome = await Runtime.evaluate({
-        expression: buildModelSelectionExpression(desiredModel),
+        expression: buildModelSelectionExpression(desiredModel, strategy),
         awaitPromise: true,
         returnByValue: true,
     });
@@ -36,11 +36,12 @@ export async function ensureModelSelection(Runtime, desiredModel, logger) {
  * Builds the DOM expression that runs inside the ChatGPT tab to select a model.
  * The string is evaluated inside Chrome, so keep it self-contained and well-commented.
  */
-function buildModelSelectionExpression(targetModel) {
+function buildModelSelectionExpression(targetModel, strategy) {
     const matchers = buildModelMatchersLiteral(targetModel);
     const labelLiteral = JSON.stringify(matchers.labelTokens);
     const idLiteral = JSON.stringify(matchers.testIdTokens);
     const primaryLabelLiteral = JSON.stringify(targetModel);
+    const strategyLiteral = JSON.stringify(strategy);
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     return `(() => {
@@ -50,6 +51,7 @@ function buildModelSelectionExpression(targetModel) {
     const LABEL_TOKENS = ${labelLiteral};
     const TEST_IDS = ${idLiteral};
     const PRIMARY_LABEL = ${primaryLabelLiteral};
+    const MODEL_STRATEGY = ${strategyLiteral};
     const INITIAL_WAIT_MS = 150;
     const REOPEN_INTERVAL_MS = 400;
     const MAX_WAIT_MS = 20000;
@@ -86,6 +88,9 @@ function buildModelSelectionExpression(targetModel) {
     }
 
     const getButtonLabel = () => (button.textContent ?? '').trim();
+    if (MODEL_STRATEGY === 'current') {
+      return { status: 'already-selected', label: getButtonLabel() };
+    }
     const buttonMatchesTarget = () => {
       const normalizedLabel = normalizeText(getButtonLabel());
       if (!normalizedLabel) return false;
@@ -476,5 +481,5 @@ function buildModelMatchersLiteral(targetModel) {
     };
 }
 export function buildModelSelectionExpressionForTest(targetModel) {
-    return buildModelSelectionExpression(targetModel);
+    return buildModelSelectionExpression(targetModel, 'select');
 }

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

@@ -17,16 +17,36 @@ export async function ensureNotBlocked(Runtime, headless, logger) {
 }
 const LOGIN_CHECK_TIMEOUT_MS = 5_000;
 export async function ensureLoggedIn(Runtime, logger, options = {}) {
+    // Learned: ChatGPT can render the UI (project view) while auth silently failed.
+    // A backend-api probe plus DOM login CTA check catches both cases.
     const outcome = await Runtime.evaluate({
         expression: buildLoginProbeExpression(LOGIN_CHECK_TIMEOUT_MS),
         awaitPromise: true,
         returnByValue: true,
     });
     const probe = normalizeLoginProbe(outcome.result?.value);
-    if (probe.ok && !probe.domLoginCta && !probe.onAuthPage) {
-        logger('Login check passed (no login button detected on page)');
+    if (probe.ok) {
+        logger(`Login check passed (status=${probe.status}, domLoginCta=${Boolean(probe.domLoginCta)})`);
         return;
     }
+    const accepted = await attemptWelcomeBackLogin(Runtime, logger);
+    if (accepted) {
+        // Learned: "Welcome back" account picker needs a click even when cookies are valid,
+        // and the redirect can lag, so re-probe before failing hard.
+        await delay(1500);
+        const retryOutcome = await Runtime.evaluate({
+            expression: buildLoginProbeExpression(LOGIN_CHECK_TIMEOUT_MS),
+            awaitPromise: true,
+            returnByValue: true,
+        });
+        const retryProbe = normalizeLoginProbe(retryOutcome.result?.value);
+        if (retryProbe.ok) {
+            logger('Login restored via Welcome back account picker');
+            return;
+        }
+        logger(`Login retry after Welcome back failed (status=${retryProbe.status}, domLoginCta=${Boolean(retryProbe.domLoginCta)})`);
+    }
+    logger(`Login probe failed (status=${probe.status}, domLoginCta=${Boolean(probe.domLoginCta)}, onAuthPage=${Boolean(probe.onAuthPage)}, url=${probe.pageUrl ?? 'n/a'}, error=${probe.error ?? 'none'})`);
     const domLabel = probe.domLoginCta ? ' Login button detected on page.' : '';
     const cookieHint = options.remoteSession
         ? 'The remote Chrome session is not signed into ChatGPT. Sign in there, then rerun.'
@@ -35,9 +55,99 @@ export async function ensureLoggedIn(Runtime, logger, options = {}) {
             : 'ChatGPT login appears missing; open chatgpt.com in Chrome to refresh the session or provide inline cookies (--browser-inline-cookies[(-file)] / ORACLE_BROWSER_COOKIES_JSON).';
     throw new Error(`ChatGPT session not detected.${domLabel} ${cookieHint}`);
 }
+async function attemptWelcomeBackLogin(Runtime, logger) {
+    const outcome = await Runtime.evaluate({
+        expression: `(() => {
+      // Learned: "Welcome back" shows as a modal with account chips; click the email chip.
+      const TIMEOUT_MS = 30000;
+      const getLabel = (node) =>
+        (node?.textContent || node?.getAttribute?.('aria-label') || '').trim();
+      const isAccount = (label) =>
+        Boolean(label) &&
+        label.includes('@') &&
+        !/log in|sign up|create account|another account/i.test(label);
+      const findAccount = () => {
+        const candidates = Array.from(document.querySelectorAll('[role="button"],button,a'));
+        return candidates.find((node) => isAccount(getLabel(node))) || null;
+      };
+      const clickAccount = () => {
+        const account = findAccount();
+        if (!account) return null;
+        try {
+          (account).click();
+        } catch (_error) {
+          return { clicked: false, reason: 'click-failed' };
+        }
+        return { clicked: true, label: getLabel(account) };
+      };
+      const immediate = clickAccount();
+      if (immediate) {
+        return immediate;
+      }
+      const root = document.documentElement || document.body;
+      if (!root) {
+        return { clicked: false, reason: 'no-root' };
+      }
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          observer.disconnect();
+          resolve({ clicked: false, reason: 'timeout' });
+        }, TIMEOUT_MS);
+        const observer = new MutationObserver(() => {
+          const result = clickAccount();
+          if (result) {
+            clearTimeout(timer);
+            observer.disconnect();
+            resolve(result);
+          }
+        });
+        observer.observe(root, {
+          subtree: true,
+          childList: true,
+          characterData: true,
+        });
+      });
+    })()`,
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    if (outcome.exceptionDetails) {
+        const details = outcome.exceptionDetails;
+        const description = (details.exception && typeof details.exception.description === 'string' && details.exception.description) ||
+            details.text ||
+            'unknown error';
+        logger(`Welcome back auto-select probe failed: ${description}`);
+    }
+    const result = outcome.result?.value;
+    if (!result) {
+        logger('Welcome back auto-select probe returned no result.');
+        return false;
+    }
+    if (result?.clicked) {
+        logger(`Welcome back modal detected; selected account ${result.label ?? '(unknown)'}`);
+        return true;
+    }
+    if (result?.reason && result.reason !== 'timeout') {
+        logger(`Welcome back modal present but auto-select failed (${result.reason}).`);
+    }
+    if (result?.reason === 'timeout') {
+        logger('Welcome back modal not detected after login probe failure.');
+    }
+    return false;
+}
 export async function ensurePromptReady(Runtime, timeoutMs, logger) {
     const ready = await waitForPrompt(Runtime, timeoutMs);
     if (!ready) {
+        const authUrl = await currentUrl(Runtime);
+        if (authUrl && isAuthLoginUrl(authUrl)) {
+            // Learned: auth.openai.com/login can appear after cookies are copied; allow manual login window.
+            logger('Auth login page detected; waiting for manual login to complete...');
+            const extended = Math.min(Math.max(timeoutMs, 60_000), 20 * 60_000);
+            const loggedIn = await waitForPrompt(Runtime, extended);
+            if (loggedIn) {
+                return;
+            }
+        }
         await logDomFailure(Runtime, logger, 'prompt-textarea');
         throw new Error('Prompt textarea did not appear before timeout');
     }
@@ -56,6 +166,25 @@ async function waitForDocumentReady(Runtime, timeoutMs) {
     }
     throw new Error('Page did not reach ready state in time');
 }
+async function currentUrl(Runtime) {
+    const { result } = await Runtime.evaluate({
+        expression: 'typeof location === "object" && location.href ? location.href : null',
+        returnByValue: true,
+    });
+    return typeof result?.value === 'string' ? result.value : null;
+}
+function isAuthLoginUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.hostname.includes('auth.openai.com')) {
+            return true;
+        }
+        return /^\/log-?in/i.test(parsed.pathname);
+    }
+    catch {
+        return false;
+    }
+}
 async function waitForPrompt(Runtime, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -93,7 +222,9 @@ async function isCloudflareInterstitial(Runtime) {
     return Boolean(result.value);
 }
 function buildLoginProbeExpression(timeoutMs) {
-    return `(() => {
+    return `(async () => {
+    // Learned: /backend-api/me is the most reliable "am I logged in" signal.
+    // Some UIs render without a session; use DOM + network for a robust answer.
     const timer = setTimeout(() => {}, ${timeoutMs});
     const pageUrl = typeof location === 'object' && location?.href ? location.href : null;
     const onAuthPage =
@@ -138,16 +269,40 @@ function buildLoginProbeExpression(timeoutMs) {
       return false;
     };
 
+    let status = 0;
+    let error = null;
+    try {
+      if (typeof fetch === 'function') {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), ${timeoutMs});
+        try {
+          // Credentials included so we see a 200 only when cookies are valid.
+          const response = await fetch('/backend-api/me', {
+            cache: 'no-store',
+            credentials: 'include',
+            signal: controller.signal,
+          });
+          status = response.status || 0;
+        } finally {
+          clearTimeout(timeout);
+        }
+      }
+    } catch (err) {
+      error = err ? String(err) : 'unknown';
+    }
+
     const domLoginCta = hasLoginCta();
+    const loginSignals = domLoginCta || onAuthPage;
     clearTimeout(timer);
     return {
-      ok: !domLoginCta && !onAuthPage,
-      status: 0,
+      ok: !loginSignals && (status === 0 || status === 200),
+      status,
       redirected: false,
       url: pageUrl,
       pageUrl,
       domLoginCta,
       onAuthPage,
+      error,
     };
   })()`;
 }

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

@@ -1,4 +1,4 @@
-import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, CONVERSATION_TURN_SELECTOR, } from '../constants.js';
+import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, CONVERSATION_TURN_SELECTOR, STOP_BUTTON_SELECTOR, ASSISTANT_ROLE_SELECTOR, } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 import { buildClickDispatcher } from './domEvents.js';
@@ -12,7 +12,7 @@ const ENTER_KEY_EVENT = {
 const ENTER_KEY_TEXT = '\r';
 export async function submitPrompt(deps, prompt, logger) {
     const { runtime, input } = deps;
-    await waitForDomReady(runtime, logger);
+    await waitForDomReady(runtime, logger, deps.inputTimeoutMs ?? undefined);
     const encodedPrompt = JSON.stringify(prompt);
     const focusResult = await runtime.evaluate({
         expression: `(() => {
@@ -22,6 +22,7 @@ export async function submitPrompt(deps, prompt, logger) {
         if (!node) {
           return false;
         }
+        // Learned: React/ProseMirror require a real click + focus + selection for inserts to stick.
         dispatchClickSequence(node);
         if (typeof node.focus === 'function') {
           node.focus();
@@ -76,6 +77,7 @@ export async function submitPrompt(deps, prompt, logger) {
     const editorTextTrimmed = editorTextRaw?.trim?.() ?? '';
     const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? '';
     if (!editorTextTrimmed && !fallbackValueTrimmed) {
+        // Learned: occasionally Input.insertText doesn't land in the editor; force textContent/value + input events.
         await runtime.evaluate({
             expression: `(() => {
         const fallback = document.querySelector(${fallbackSelectorLiteral});
@@ -109,6 +111,7 @@ export async function submitPrompt(deps, prompt, logger) {
     const observedFallback = postVerification.result?.value?.fallbackValue ?? '';
     const observedLength = Math.max(observedEditor.length, observedFallback.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');
         throw new BrowserAutomationError('Prompt appears truncated in the composer (likely too large).', {
             stage: 'submit-prompt',
@@ -134,7 +137,9 @@ export async function submitPrompt(deps, prompt, logger) {
     else {
         logger('Clicked send button');
     }
-    await verifyPromptCommitted(runtime, prompt, 30_000, logger);
+    const commitTimeoutMs = Math.max(60_000, deps.inputTimeoutMs ?? 0);
+    // Learned: the send button can succeed but the turn doesn't appear immediately; verify commit via turns/stop button.
+    return await verifyPromptCommitted(runtime, prompt, commitTimeoutMs, logger, deps.baselineTurns ?? undefined);
 }
 export async function clearPromptComposer(Runtime, logger) {
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
@@ -165,8 +170,8 @@ export async function clearPromptComposer(Runtime, logger) {
     }
     await delay(250);
 }
-async function waitForDomReady(Runtime, logger) {
-    const deadline = Date.now() + 10_000;
+async function waitForDomReady(Runtime, logger, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({
             expression: `(() => {
@@ -183,7 +188,7 @@ async function waitForDomReady(Runtime, logger) {
         }
         await delay(150);
     }
-    logger?.('Page did not reach ready/composer state within 10s; continuing cautiously.');
+    logger?.(`Page did not reach ready/composer state within ${timeoutMs}ms; continuing cautiously.`);
 }
 function buildAttachmentReadyExpression(attachmentNames) {
     const namesLiteral = JSON.stringify(attachmentNames.map((name) => name.toLowerCase()));
@@ -241,6 +246,7 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
       dataDisabled === 'true' ||
       style.pointerEvents === 'none' ||
       style.display === 'none';
+    // Learned: some send buttons render but are inert; only click when truly enabled.
     if (disabled) return 'disabled';
     // Use unified pointer/mouse sequence to satisfy React handlers.
     dispatchClickSequence(button);
@@ -270,11 +276,17 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     }
     return false;
 }
-async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
+async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselineTurns) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const stopSelectorLiteral = JSON.stringify(STOP_BUTTON_SELECTOR);
+    const assistantSelectorLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
+    const baselineLiteral = typeof baselineTurns === 'number' && Number.isFinite(baselineTurns) && baselineTurns >= 0
+        ? Math.floor(baselineTurns)
+        : -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});
@@ -297,11 +309,35 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
 	      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 editorValue = editor?.innerText ?? '';
+      const fallbackValue = fallback?.value ?? '';
+      const composerCleared = !(String(editorValue).trim() || String(fallbackValue).trim());
+      const href = typeof location === 'object' && location.href ? location.href : '';
+      const inConversation = /\\/c\\//.test(href);
 	    return {
       userMatched,
       prefixMatched,
-      fallbackValue: fallback?.value ?? '',
-      editorValue: editor?.innerText ?? '',
+      lastMatched,
+      hasNewTurn,
+      stopVisible,
+      assistantVisible,
+      composerCleared,
+      inConversation,
+      href,
+      fallbackValue,
+      editorValue,
       lastTurn,
       turnsCount: normalizedTurns.length,
     };
@@ -309,8 +345,15 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const info = result.value;
-        if (info?.userMatched || info?.prefixMatched) {
-            return;
+        const turnsCount = result.value?.turnsCount;
+        if (info?.hasNewTurn && (info?.lastMatched || info?.userMatched || info?.prefixMatched)) {
+            return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
+        }
+        const fallbackCommit = info?.composerCleared &&
+            ((info?.stopVisible ?? false) ||
+                (info?.hasNewTurn && (info?.assistantVisible || info?.inConversation)));
+        if (fallbackCommit) {
+            return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
         }
         await delay(100);
     }

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

@@ -1,9 +1,9 @@
-import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { FILE_INPUT_SELECTORS } from '../constants.js';
 import { waitForAttachmentVisible } from './attachments.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
+import { transferAttachmentViaDataTransfer } from './attachmentDataTransfer.js';
 /**
  * Upload file to remote Chrome by transferring content via CDP
  * Used when browser is on a different machine than CLI
@@ -13,17 +13,7 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
     if (!dom) {
         throw new Error('DOM domain unavailable while uploading attachments.');
     }
-    // Read file content from local filesystem
-    const fileContent = await readFile(attachment.path);
-    // Enforce file size limit to avoid CDP protocol issues
-    const MAX_BYTES = 20 * 1024 * 1024; // 20MB limit for CDP transfer
-    if (fileContent.length > MAX_BYTES) {
-        throw new Error(`Attachment ${path.basename(attachment.path)} is too large for remote upload (${fileContent.length} bytes). Maximum size is ${MAX_BYTES} bytes.`);
-    }
-    const base64Content = fileContent.toString('base64');
-    const fileName = path.basename(attachment.path);
-    const mimeType = guessMimeType(fileName);
-    logger(`Transferring ${fileName} (${fileContent.length} bytes) to remote browser...`);
+    logger(`Transferring ${path.basename(attachment.path)} to remote browser...`);
     // Find file input element
     const documentNode = await dom.getDocument();
     let fileInputSelector;
@@ -38,151 +28,10 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
         await logDomFailure(runtime, logger, 'file-input');
         throw new Error('Unable to locate ChatGPT file attachment input.');
     }
-    // Inject file via JavaScript DataTransfer API
-    const expression = `
-    (function() {
-      // Check for required file APIs
-      if (!('File' in window) || !('Blob' in window) || !('DataTransfer' in window) || typeof atob !== 'function') {
-        return { success: false, error: 'Required file APIs are not available in this browser' };
-      }
-
-      const fileInput = document.querySelector(${JSON.stringify(fileInputSelector)});
-      if (!fileInput) {
-        return { success: false, error: 'File input not found' };
-      }
-
-      // Validate that the element is actually a file input
-      if (!(fileInput instanceof HTMLInputElement) || fileInput.type !== 'file') {
-        return { success: false, error: 'Found element is not a file input' };
-      }
-
-      // Convert base64 to Blob
-      const base64Data = ${JSON.stringify(base64Content)};
-      const binaryString = atob(base64Data);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      const blob = new Blob([bytes], { type: ${JSON.stringify(mimeType)} });
-
-      // Create File object
-      const file = new File([blob], ${JSON.stringify(fileName)}, {
-        type: ${JSON.stringify(mimeType)},
-        lastModified: Date.now()
-      });
-
-      // Create DataTransfer and assign to input
-      const dataTransfer = new DataTransfer();
-      dataTransfer.items.add(file);
-      let assigned = false;
-
-      const proto = Object.getPrototypeOf(fileInput);
-      const descriptor = proto ? Object.getOwnPropertyDescriptor(proto, 'files') : null;
-      if (descriptor?.set) {
-        try {
-          descriptor.set.call(fileInput, dataTransfer.files);
-          assigned = true;
-        } catch {
-          assigned = false;
-        }
-      }
-      if (!assigned) {
-        try {
-          Object.defineProperty(fileInput, 'files', {
-            configurable: true,
-            get: () => dataTransfer.files,
-          });
-          assigned = true;
-        } catch {
-          assigned = false;
-        }
-      }
-      if (!assigned) {
-        try {
-          fileInput.files = dataTransfer.files;
-          assigned = true;
-        } catch {
-          assigned = false;
-        }
-      }
-      if (!assigned) {
-        return { success: false, error: 'Unable to assign FileList to input' };
-      }
-
-      // Trigger both input and change events for better compatibility
-      fileInput.dispatchEvent(new Event('input', { bubbles: true }));
-      fileInput.dispatchEvent(new Event('change', { bubbles: true }));
-
-      return { success: true, fileName: file.name, size: file.size };
-    })()
-  `;
-    const evalResult = await runtime.evaluate({ expression, returnByValue: true });
-    // Check for JavaScript exceptions during evaluation
-    if (evalResult.exceptionDetails) {
-        const description = evalResult.exceptionDetails.text ?? 'JS evaluation failed';
-        throw new Error(`Failed to transfer file to remote browser: ${description}`);
-    }
-    // Validate result structure before accessing
-    if (!evalResult.result || typeof evalResult.result.value !== 'object' || evalResult.result.value == null) {
-        throw new Error('Failed to transfer file to remote browser: unexpected evaluation result');
-    }
-    const uploadResult = evalResult.result.value;
-    if (!uploadResult.success) {
-        throw new Error(`Failed to transfer file to remote browser: ${uploadResult.error || 'Unknown error'}`);
-    }
-    logger(`File transferred: ${uploadResult.fileName} (${uploadResult.size} bytes)`);
+    const transferResult = await transferAttachmentViaDataTransfer(runtime, attachment, fileInputSelector);
+    logger(`File transferred: ${transferResult.fileName} (${transferResult.size} bytes)`);
     // Give ChatGPT a moment to process the file
     await delay(500);
-    await waitForAttachmentVisible(runtime, fileName, 10_000, logger);
+    await waitForAttachmentVisible(runtime, transferResult.fileName, 10_000, logger);
     logger('Attachment queued');
 }
-function guessMimeType(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    const mimeTypes = {
-        // Text files
-        '.txt': 'text/plain',
-        '.md': 'text/markdown',
-        '.csv': 'text/csv',
-        // Code files
-        '.json': 'application/json',
-        '.js': 'text/javascript',
-        '.ts': 'text/typescript',
-        '.jsx': 'text/javascript',
-        '.tsx': 'text/typescript',
-        '.py': 'text/x-python',
-        '.java': 'text/x-java',
-        '.c': 'text/x-c',
-        '.cpp': 'text/x-c++',
-        '.h': 'text/x-c',
-        '.hpp': 'text/x-c++',
-        '.sh': 'text/x-sh',
-        '.bash': 'text/x-sh',
-        // Web files
-        '.html': 'text/html',
-        '.css': 'text/css',
-        '.xml': 'text/xml',
-        '.yaml': 'text/yaml',
-        '.yml': 'text/yaml',
-        // Documents
-        '.pdf': 'application/pdf',
-        '.doc': 'application/msword',
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.xls': 'application/vnd.ms-excel',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.ppt': 'application/vnd.ms-powerpoint',
-        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-        // Images
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif',
-        '.svg': 'image/svg+xml',
-        '.webp': 'image/webp',
-        // Archives
-        '.zip': 'application/zip',
-        '.tar': 'application/x-tar',
-        '.gz': 'application/gzip',
-        '.7z': 'application/x-7z-compressed',
-    };
-    return mimeTypes[ext] || 'application/octet-stream';
-}

package/dist/src/browser/chromeLifecycle.js

@@ -68,7 +68,13 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
             }
         })().finally(() => {
             const exitCode = signal === 'SIGINT' ? 130 : 1;
-            process.exit(exitCode);
+            // Vitest treats any `process.exit()` call as an unhandled failure, even if mocked.
+            // Keep production behavior (hard-exit on signals) while letting tests observe state changes.
+            process.exitCode = exitCode;
+            const isTestRun = process.env.VITEST === '1' || process.env.NODE_ENV === 'test';
+            if (!isTestRun) {
+                process.exit(exitCode);
+            }
         });
     };
     for (const signal of signals) {

package/dist/src/browser/config.js

@@ -1,4 +1,5 @@
-import { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
+import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
+import { normalizeBrowserModelStrategy } from './modelStrategy.js';
 import { isTemporaryChatUrl, normalizeChatgptUrl } from './utils.js';
 import os from 'node:os';
 import path from 'node:path';
@@ -10,7 +11,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     chatgptUrl: CHATGPT_URL,
     timeoutMs: 1_200_000,
     debugPort: null,
-    inputTimeoutMs: 30_000,
+    inputTimeoutMs: 60_000,
     cookieSync: true,
     cookieNames: null,
     inlineCookies: null,
@@ -19,6 +20,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     keepBrowser: false,
     hideWindow: false,
     desiredModel: DEFAULT_MODEL_TARGET,
+    modelStrategy: DEFAULT_MODEL_STRATEGY,
     debug: false,
     allowCookieErrors: false,
     remoteChrome: null,
@@ -32,7 +34,10 @@ export function resolveBrowserConfig(config) {
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
     const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
-    if (isTemporaryChatUrl(normalizedUrl) && /\bpro\b/i.test(desiredModel)) {
+    const modelStrategy = normalizeBrowserModelStrategy(config?.modelStrategy) ??
+        DEFAULT_BROWSER_CONFIG.modelStrategy ??
+        DEFAULT_MODEL_STRATEGY;
+    if (modelStrategy === 'select' && isTemporaryChatUrl(normalizedUrl) && /\bpro\b/i.test(desiredModel)) {
         throw new Error('Temporary Chat mode does not expose Pro models in the ChatGPT model picker. ' +
             'Remove "temporary-chat=true" from your browser URL, or use a non-Pro model label (e.g. "GPT-5.2").');
     }
@@ -58,6 +63,7 @@ export function resolveBrowserConfig(config) {
         keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
         hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,
         desiredModel,
+        modelStrategy,
         chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
         chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,