@steipete/oracle 0.15.2 → 0.16.1

package/dist/src/browser/index.js

@@ -4,9 +4,9 @@ import os from "node:os";
 import net from "node:net";
 import { resolveBrowserConfig } from "./config.js";
 import { copyChromeProfile } from "./profileCopy.js";
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
+import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, createChromePageTarget, ensureChromePageTargetAfterClose, closeBlankChromeTabs, } from "./chromeLifecycle.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
-import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
+import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
 import { INPUT_SELECTORS } from "./constants.js";
 import { uploadAttachmentViaDataTransfer } from "./actions/remoteFileTransfer.js";
 import { ensureThinkingTime } from "./actions/thinkingTime.js";
@@ -19,6 +19,7 @@ import { BrowserAutomationError } from "../oracle/errors.js";
 import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
 import { buildConversationTurnCountExpression } from "./conversationTurns.js";
 import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { connectionLostUserMessage, isRecoverableChromeDisconnect, probeChromeTargetLiveness, } from "./cdpLiveness.js";
 import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
 import { collectGeneratedImageArtifacts } from "./chatgptImages.js";
@@ -32,6 +33,7 @@ import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./ac
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
 import { createConversationUrlMonitor, } from "./conversationUrlMonitor.js";
+import { extractStableConversationIdFromUrl as extractConversationIdFromUrl, isStableConversationUrl as isConversationUrl, } from "./conversationUrl.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
 export { formatThinkingLog, formatThinkingWaitingLog, buildThinkingStatusExpressionForTest, readThinkingStatusForTest, sanitizeThinkingText, startThinkingStatusMonitorForTest, } from "./actions/thinkingStatus.js";
@@ -281,6 +283,25 @@ async function createAssistantTimeoutError(params) {
     }
     return warningError;
 }
+/**
+ * Make the page behave like a focused foreground tab.
+ *
+ * The send button is activated with trusted CDP input events dispatched at
+ * viewport coordinates. Chrome delivers those only to a window that is being
+ * composited, so a hidden (`--browser-hide-window`), minimized, or occluded
+ * window swallows the click while the automation still believes it clicked.
+ * Soft-fails: focus emulation is an optimization, never a hard requirement.
+ */
+async function enableFocusEmulation(client, logger, label) {
+    try {
+        await client.Emulation.setFocusEmulationEnabled({ enabled: true });
+        logger(`[browser] Focus emulation enabled for ${label}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] Focus emulation unavailable: ${message}`);
+    }
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -356,13 +377,13 @@ async function pollGeneratedImageOrTextAssistantResponse(Runtime, timeoutMs, min
     }
     return null;
 }
-function isImageOnlyUiChromeText(text) {
+export function isImageOnlyUiChromeText(text) {
     const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
     return (normalized.length === 0 ||
         normalized === "edit" ||
         normalized === "stopped thinking" ||
         normalized === "stopped thinking edit" ||
-        /^thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
+        /^(?:reasoning\s+|pro thinking\s+)?thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
 }
 function normalizeBrowserFollowUpPrompts(values) {
     return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
@@ -516,7 +537,17 @@ async function closeRemoteConnectionAfterRun(options) {
     }
 }
 function shouldCloseOwnedRunTargetAfterRun(options) {
-    return options.runStatus === "complete" && options.ownsTarget && !options.keepBrowser;
+    return (options.runStatus === "complete" &&
+        options.ownsTarget &&
+        (Boolean(options.closeOwnedTabOnComplete) || !options.keepBrowser));
+}
+function shouldCleanupBlankTabsAfterLastLease(options) {
+    return (options.runStatus === "complete" &&
+        options.ownsTarget &&
+        !options.connectionClosedUnexpectedly &&
+        options.manualLogin &&
+        options.keepBrowser &&
+        Boolean(options.chromePort));
 }
 function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
     return {
@@ -777,20 +808,54 @@ export async function runBrowserMode(options) {
         const disconnectPromise = new Promise((_, reject) => {
             client?.on("disconnect", () => {
                 connectionClosedUnexpectedly = true;
-                logger("Chrome window closed; attempting to abort run.");
-                reject(new Error("Chrome window closed before oracle finished. Please keep it open until completion."));
+                void (async () => {
+                    const liveness = await probeChromeTargetLiveness({
+                        host: chromeHost,
+                        port: chrome.port,
+                        targetId: lastTargetId ?? isolatedTargetId,
+                    });
+                    const recoverable = isRecoverableChromeDisconnect(liveness);
+                    if (recoverable) {
+                        logger("CDP client disconnected; Chrome/target still reachable. Leaving run recoverable for reattach.");
+                    }
+                    else {
+                        logger("Chrome window closed; attempting to abort run.");
+                    }
+                    reject(new BrowserAutomationError(connectionLostUserMessage({ recoverable }), {
+                        stage: "connection-lost",
+                        recoverableDisconnect: recoverable,
+                        disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
+                        runtime: {
+                            chromePid: chrome.pid,
+                            chromePort: chrome.port,
+                            chromeHost,
+                            userDataDir,
+                            chromeTargetId: lastTargetId ?? isolatedTargetId ?? undefined,
+                            tabUrl: liveness.matchedUrl ?? lastUrl,
+                            conversationId: (liveness.matchedUrl ?? lastUrl)
+                                ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                                : undefined,
+                            promptSubmitted,
+                            controllerPid: process.pid,
+                        },
+                    }));
+                })();
             });
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
         const { Network, Page, Runtime, Input, DOM, Target } = client;
-        if (!config.headless && config.hideWindow) {
-            await hideChromeWindow(chrome, logger);
-        }
         const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
         if (DOM && typeof DOM.enable === "function") {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
+        if (!config.headless && config.hideWindow) {
+            await positionChromeWindowOffscreen(client, logger);
+        }
+        // The send button is clicked with trusted CDP input events at viewport
+        // coordinates, which ChatGPT silently drops when the window is hidden or
+        // occluded. Emulate focus so the page behaves like a foreground tab.
+        await enableFocusEmulation(client, logger, "local target");
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         if (!profileIsPreSigned) {
             await Network.clearBrowserCookies();
@@ -911,6 +976,18 @@ export async function runBrowserMode(options) {
                 }));
             }
         }
+        const chatMode = await raceWithDisconnect(ensureChatMode(Runtime, Input, config.inputTimeoutMs, logger, {
+            resetWorkConversation: config.browserTabRef && !isResumingConversation
+                ? async () => {
+                    await navigateToChatGPT(Page, Runtime, config.url, logger);
+                    await ensureNotBlocked(Runtime, config.headless, logger);
+                    await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                }
+                : undefined,
+        }));
+        if (chatMode === "switched") {
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         const captureRuntimeSnapshot = async () => {
             try {
@@ -1692,19 +1769,34 @@ export async function runBrowserMode(options) {
             throw normalizedError;
         }
         if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
-            logger(`Chrome window closed before completion: ${normalizedError.message}`);
+            logger(`Chrome connection lost before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
         await emitRuntimeHint();
-        throw new BrowserAutomationError("Chrome window closed before oracle finished. Please keep it open until completion.", {
+        if (normalizedError instanceof BrowserAutomationError &&
+            normalizedError.details?.stage === "connection-lost") {
+            throw normalizedError;
+        }
+        const liveness = await probeChromeTargetLiveness({
+            host: chromeHost,
+            port: chrome.port,
+            targetId: lastTargetId ?? isolatedTargetId,
+        });
+        const recoverable = isRecoverableChromeDisconnect(liveness);
+        throw new BrowserAutomationError(connectionLostUserMessage({ recoverable }), {
             stage: "connection-lost",
+            recoverableDisconnect: recoverable,
+            disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
             runtime: {
                 chromePid: chrome.pid,
                 chromePort: chrome.port,
                 chromeHost,
                 userDataDir,
                 chromeTargetId: lastTargetId,
-                tabUrl: lastUrl,
+                tabUrl: liveness.matchedUrl ?? lastUrl,
+                conversationId: (liveness.matchedUrl ?? lastUrl)
+                    ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                    : undefined,
                 promptSubmitted,
                 controllerPid: process.pid,
             },
@@ -1723,15 +1815,12 @@ export async function runBrowserMode(options) {
         // Close the isolated tab once the response has been fully captured to prevent
         // tab accumulation across repeated runs. Keep the tab open on incomplete runs
         // so reattach can recover the response.
-        if (shouldCloseOwnedRunTargetAfterRun({
+        const shouldCloseOwnedRunTarget = shouldCloseOwnedRunTargetAfterRun({
             runStatus,
             ownsTarget,
             keepBrowser: effectiveKeepBrowser,
-        }) &&
-            isolatedTargetId &&
-            chrome?.port) {
-            await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
-        }
+            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+        });
         let keepBrowserOpen = shouldKeepLocalBrowserOpen({
             effectiveKeepBrowser,
             preserveBrowserOnError,
@@ -1749,18 +1838,6 @@ export async function runBrowserMode(options) {
             }
             return otherActiveBrowserTabLeases;
         };
-        if (runStatus === "complete" &&
-            manualLogin &&
-            !connectionClosedUnexpectedly &&
-            chrome?.port &&
-            ownsTarget) {
-            const otherLeasesActive = await hasOtherActiveLeases().catch(() => true);
-            if (!otherLeasesActive) {
-                await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
-                    excludeTargetIds: [isolatedTargetId, lastTargetId],
-                }).catch(() => undefined);
-            }
-        }
         if (!keepBrowserOpen && manualLogin && tabLease) {
             const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
             if (cleanupLockTimeoutMs > 0) {
@@ -1778,10 +1855,55 @@ export async function runBrowserMode(options) {
                 terminatedRecordedChrome = await terminateRecordedChromeForProfile(userDataDir, logger).catch(() => false);
             }
         }
+        const closeOwnedRunTarget = async () => {
+            if (!shouldCloseOwnedRunTarget || !isolatedTargetId || !chrome?.port) {
+                return;
+            }
+            const safeToClose = !effectiveKeepBrowser ||
+                Boolean(await ensureChromePageTargetAfterClose(chrome.port, isolatedTargetId, logger, chromeHost));
+            if (!safeToClose) {
+                logger(`[browser] Leaving completed browser tab open because Chrome has no replacement page target.`);
+                return;
+            }
+            const closeConfirmed = await closeTab(chrome.port, isolatedTargetId, logger, chromeHost);
+            if (!closeConfirmed && effectiveKeepBrowser) {
+                const replacementTargetId = await createChromePageTarget(chrome.port, logger, chromeHost);
+                if (!replacementTargetId) {
+                    logger(`[browser] Chrome page retention could not be verified after closing ${isolatedTargetId}.`);
+                }
+            }
+        };
+        const cleanupBlankTabs = async () => {
+            if (!shouldCleanupBlankTabsAfterLastLease({
+                runStatus,
+                ownsTarget,
+                connectionClosedUnexpectedly,
+                manualLogin,
+                keepBrowser: effectiveKeepBrowser,
+                chromePort: chrome?.port,
+            }) ||
+                !chrome?.port) {
+                return;
+            }
+            await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
+                excludeTargetIds: [isolatedTargetId, lastTargetId],
+                preserveOneBlank: true,
+            });
+        };
         if (tabLease) {
             const handle = tabLease;
             tabLease = null;
-            await handle.release().catch(() => undefined);
+            const onRelease = async ({ isLastLease }) => {
+                await closeOwnedRunTarget();
+                if (isLastLease) {
+                    await cleanupBlankTabs();
+                }
+            };
+            await handle.release({ onRelease }).catch(() => undefined);
+        }
+        else {
+            await closeOwnedRunTarget();
+            await cleanupBlankTabs();
         }
         removeDialogHandler?.();
         removeTerminationHooks?.();
@@ -1961,7 +2083,7 @@ function detachKeptChromeProcess(chrome) {
         // Best-effort only; cleanup should not mask the original browser result.
     }
 }
-async function acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps = {}) {
+export async function acquireManualLoginChromeForRun(userDataDir, config, logger, sessionId, deps = {}) {
     const maybeReuse = deps.maybeReuse ?? maybeReuseRunningChrome;
     const launch = deps.launch ?? launchChrome;
     const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
@@ -2176,14 +2298,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
-        try {
-            await client.Emulation.setFocusEmulationEnabled({ enabled: true });
-            logger("[browser] Focus emulation enabled for remote target");
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger(`[browser] Focus emulation unavailable: ${message}`);
-        }
+        await enableFocusEmulation(client, logger, "remote target");
         const activeConversationUrlMonitor = createConversationUrlMonitor({
             readUrl: async () => {
                 const { result } = await Runtime.evaluate({
@@ -2222,6 +2337,18 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 expectedConversationUrl: config.resumeConversationUrl,
             });
         }
+        const chatMode = await ensureChatMode(Runtime, Input, config.inputTimeoutMs, logger, {
+            resetWorkConversation: attachedExistingTab && !config.resumeConversationUrl
+                ? async () => {
+                    await navigateToChatGPT(Page, Runtime, config.url, logger);
+                    await ensureNotBlocked(Runtime, config.headless, logger);
+                    await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+                }
+                : undefined,
+        });
+        if (chatMode === "switched") {
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
             const { result } = await Runtime.evaluate({
@@ -2829,15 +2956,27 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             throw normalizedError;
         }
-        throw new BrowserAutomationError("Remote Chrome connection lost before Oracle finished.", {
+        const liveness = await probeChromeTargetLiveness({
+            host,
+            port,
+            targetId: remoteTargetId,
+            browserWSEndpoint,
+        });
+        const recoverable = isRecoverableChromeDisconnect(liveness);
+        throw new BrowserAutomationError(connectionLostUserMessage({ recoverable, remote: true }), {
             stage: "connection-lost",
+            recoverableDisconnect: recoverable,
+            disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
             runtime: {
                 chromeHost: host,
                 chromePort: port,
                 chromeBrowserWSEndpoint: browserWSEndpoint,
                 chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
-                tabUrl: lastUrl,
+                tabUrl: liveness.matchedUrl ?? lastUrl,
+                conversationId: (liveness.matchedUrl ?? lastUrl)
+                    ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                    : undefined,
                 promptSubmitted,
                 controllerPid: process.pid,
             },
@@ -2857,17 +2996,40 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         removeDialogHandler?.();
+        const keepRemoteBrowser = Boolean(config.keepBrowser);
+        const shouldCloseOwnedRemoteTarget = shouldCloseOwnedRunTargetAfterRun({
+            runStatus,
+            ownsTarget,
+            keepBrowser: keepRemoteBrowser,
+            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+        });
+        const closeOwnedRemoteTarget = async () => {
+            if (!shouldCloseOwnedRemoteTarget || !remoteTargetId) {
+                return;
+            }
+            const safeToClose = !keepRemoteBrowser ||
+                Boolean(await ensureChromePageTargetAfterClose(port, remoteTargetId, logger, host));
+            if (!safeToClose) {
+                logger(`[browser] Leaving completed remote browser tab open because Chrome has no replacement page target.`);
+                return;
+            }
+            const closeConfirmed = await closeTab(port, remoteTargetId, logger, host);
+            if (!closeConfirmed && keepRemoteBrowser) {
+                const replacementTargetId = await createChromePageTarget(port, logger, host);
+                if (!replacementTargetId) {
+                    logger(`[browser] Remote Chrome page retention could not be verified after closing ${remoteTargetId}.`);
+                }
+            }
+        };
         if (tabLease) {
             const handle = tabLease;
             tabLease = null;
-            await handle.release().catch(() => undefined);
+            await handle
+                .release({ onRelease: async () => closeOwnedRemoteTarget() })
+                .catch(() => undefined);
         }
-        if (shouldCloseOwnedRunTargetAfterRun({
-            runStatus,
-            ownsTarget,
-            keepBrowser: Boolean(config.keepBrowser),
-        })) {
-            await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
+        else {
+            await closeOwnedRemoteTarget();
         }
         // Don't kill remote Chrome - it's not ours to manage
         const totalSeconds = (Date.now() - startedAt) / 1000;
@@ -2890,6 +3052,7 @@ export const __test__ = {
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
     resolveManualLoginWaitMs,
+    shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
 };
@@ -3089,9 +3252,6 @@ async function readConversationTurnCount(Runtime, logger) {
     }
     return null;
 }
-function isConversationUrl(url) {
-    return /\/c\/[a-z0-9-]+/i.test(url);
-}
 function describeDevtoolsFirewallHint(host, port) {
     if (!isWsl())
         return null;
@@ -3112,10 +3272,6 @@ function isWsl() {
         return true;
     return os.release().toLowerCase().includes("microsoft");
 }
-function extractConversationIdFromUrl(url) {
-    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
-    return match?.[1];
-}
 async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {