@steipete/oracle 0.18.0 → 0.20.0

package/dist/src/browser/recoveryTarget.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { sessionStore } from "../sessionStore.js";
+import { connectToRemoteChromeTarget } from "./chromeLifecycle.js";
+import { resolveBrowserApprovalWait } from "./config.js";
+import { extractConversationIdFromUrl } from "./reattachHelpers.js";
+import { STOP_BUTTON_SELECTORS } from "./constants.js";
+import { hasActiveBrowserTargetLease } from "./tabLeaseRegistry.js";
+import { buildTargetRetirementExpression, buildTargetRetirementRollbackExpression, normalizeChromeHost, } from "./targetClaim.js";
+function processMayBeAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+export function hasOtherLiveBrowserController(metadata) {
+    for (const pid of [metadata.browser?.runtime?.controllerPid, metadata.lifecycle?.workerPid]) {
+        if (!pid || pid === process.pid)
+            continue;
+        if (processMayBeAlive(pid))
+            return true;
+    }
+    return false;
+}
+async function targetHasActiveController(metadata, capture) {
+    for (const other of await sessionStore.listSessions()) {
+        if (other.id === metadata.id)
+            continue;
+        const runtime = other.browser?.runtime;
+        if (runtime?.chromeTargetId !== capture.targetId ||
+            runtime.chromePort !== capture.port ||
+            normalizeChromeHost(runtime.chromeHost ?? "127.0.0.1") !== normalizeChromeHost(capture.host))
+            continue;
+        if ([runtime.controllerPid, other.lifecycle?.workerPid].some((pid) => pid && processMayBeAlive(pid)))
+            return true;
+    }
+    const runtime = metadata.browser?.runtime;
+    const profileDirs = new Set([
+        runtime?.userDataDir,
+        runtime?.chromeProfileRoot,
+        metadata.browser?.config?.manualLoginProfileDir,
+    ].filter((dir) => Boolean(dir)));
+    for (const dir of profileDirs) {
+        if (await hasActiveBrowserTargetLease(dir, capture))
+            return true;
+    }
+    return false;
+}
+export function matchesOwnedRecoveryTarget(metadata, capture) {
+    const runtime = metadata.browser?.runtime;
+    const owned = runtime?.ownedRecoveryTarget;
+    const conversationId = runtime?.conversationId ?? extractConversationIdFromUrl(runtime?.tabUrl ?? "");
+    return Boolean(owned &&
+        capture &&
+        conversationId &&
+        capture.conversationId === conversationId &&
+        owned.targetId === capture.targetId &&
+        normalizeChromeHost(owned.host) === normalizeChromeHost(capture.host) &&
+        owned.port === capture.port &&
+        owned.browserWSEndpoint === capture.browserWSEndpoint);
+}
+/** Call only after the full recovered answer and completed session have been saved. */
+export async function retireRecoveredBrowserTarget(sessionId, capture, logger, deps = {}) {
+    if (!capture)
+        return;
+    let connection;
+    let lockedClaim;
+    const reservationId = randomUUID();
+    let retired = false;
+    try {
+        const metadata = await sessionStore.readSession(sessionId);
+        if (!metadata ||
+            metadata.status !== "completed" ||
+            hasOtherLiveBrowserController(metadata) ||
+            !matchesOwnedRecoveryTarget(metadata, capture))
+            return;
+        const claimId = metadata.browser?.runtime?.ownedRecoveryTarget?.claimId;
+        if (!claimId)
+            return;
+        const connect = deps.connect ?? connectToRemoteChromeTarget;
+        connection = await connect(capture.host, capture.port, logger, {
+            targetId: capture.targetId,
+            browserWSEndpoint: capture.browserWSEndpoint,
+            closeTargetOnDispose: false,
+            approvalWaitMs: resolveBrowserApprovalWait(metadata.browser?.config?.approvalWaitMs),
+        });
+        const { Runtime, Target } = connection.client;
+        const state = await Runtime.evaluate({
+            expression: `(() => ({ url: location.href, generating: Array.from(document.querySelectorAll(${JSON.stringify(STOP_BUTTON_SELECTORS.join(","))})).some(node => node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0) }))()`,
+            returnByValue: true,
+        });
+        const value = state.result?.value;
+        if (!value ||
+            value.generating !== false ||
+            extractConversationIdFromUrl(value.url ?? "") !== capture.conversationId)
+            return;
+        const { targetInfos } = await Target.getTargets();
+        if (!targetInfos.some((target) => target.type === "page" && target.targetId !== capture.targetId)) {
+            const replacement = await Target.createTarget({ url: "about:blank" });
+            if (!replacement.targetId)
+                return;
+        }
+        if (await targetHasActiveController(metadata, capture))
+            return;
+        lockedClaim = claimId;
+        const locked = await Runtime.evaluate({
+            expression: buildTargetRetirementExpression(claimId, capture.conversationId, reservationId),
+            returnByValue: true,
+        });
+        if (locked.exceptionDetails || locked.result?.value !== true)
+            return;
+        const result = await Target.closeTarget({ targetId: capture.targetId });
+        if (!result.success)
+            throw new Error("Chrome refused target retirement");
+        retired = true;
+        logger("Retired Oracle-owned browser tab after saving the recovered answer.");
+    }
+    catch (error) {
+        logger(`Recovered answer is saved; browser tab cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        if (connection && lockedClaim && !retired) {
+            await connection.client.Runtime.evaluate({
+                expression: buildTargetRetirementRollbackExpression(lockedClaim, reservationId),
+            }).catch(() => undefined);
+        }
+        await connection?.close().catch(() => undefined);
+    }
+}

package/dist/src/browser/sessionRunner.js

@@ -2,10 +2,11 @@ import chalk from "chalk";
 import { formatTokenCount } from "../oracle/runUtils.js";
 import { formatFinishLine } from "../oracle/finishLine.js";
 import { runBrowserMode } from "../browserMode.js";
-import { assembleBrowserPrompt } from "./prompt.js";
+import { DEFAULT_BROWSER_CONFIG } from "./config.js";
+import { assembleBrowserPrompt, cleanupGeneratedBrowserBundles, materializeBrowserFallback, } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
-import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -57,7 +58,50 @@ function buildBrowserRunWarnings(args) {
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
-    const promptArtifacts = await assemblePrompt(runOptions, { cwd });
+    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    const inputTimeoutMs = browserConfig.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs;
+    let preparationTimedOut = false;
+    let preparationTimeout;
+    let promptArtifacts;
+    try {
+        promptArtifacts = await Promise.race([
+            assemblePrompt(runOptions, { cwd }).then(async (artifacts) => {
+                if (preparationTimedOut)
+                    await cleanupGeneratedBrowserBundles(artifacts);
+                return artifacts;
+            }),
+            new Promise((_, reject) => {
+                preparationTimeout = setTimeout(() => {
+                    preparationTimedOut = true;
+                    reject(new BrowserAutomationError(`Browser prompt preparation timed out after ${inputTimeoutMs}ms; increase --browser-input-timeout if local files need more time.`, {
+                        stage: "prepare-prompt",
+                        code: "prompt-preparation-timeout",
+                        timeoutMs: inputTimeoutMs,
+                    }));
+                }, inputTimeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (preparationTimeout) {
+            clearTimeout(preparationTimeout);
+        }
+    }
+    try {
+        return await executeAssembledBrowserSession({
+            runOptions,
+            browserConfig,
+            log,
+            promptArtifacts,
+            executeBrowser,
+            persistRuntimeHint,
+        });
+    }
+    finally {
+        await cleanupGeneratedBrowserBundles(promptArtifacts);
+    }
+}
+async function executeAssembledBrowserSession({ runOptions, browserConfig, log, promptArtifacts, executeBrowser, persistRuntimeHint, }) {
     if (runOptions.verbose) {
         log(chalk.dim(`[verbose] Browser config: ${JSON.stringify({
             ...browserConfig,
@@ -91,7 +135,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         if (typeof message !== "string")
             return;
         const shouldAlwaysPrint = message.startsWith("[browser] ") &&
-            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|research|waiting for chatgpt|remote debugging approval|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -103,7 +147,22 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (runOptions.verbose) {
         log(chalk.dim("Chrome automation does not stream output; this may take a minute..."));
     }
-    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    let fallbackSubmission = undefined;
+    if (promptArtifacts.fallback) {
+        fallbackSubmission = {
+            prompt: promptArtifacts.fallback.composerText,
+            attachments: promptArtifacts.fallback.attachments,
+            pendingBundle: promptArtifacts.fallback.pendingBundle ?? undefined,
+            prepare: async () => {
+                const prepared = await materializeBrowserFallback(promptArtifacts);
+                if (!prepared || !fallbackSubmission)
+                    return;
+                fallbackSubmission.prompt = prepared.composerText;
+                fallbackSubmission.attachments = prepared.attachments;
+                fallbackSubmission.pendingBundle = undefined;
+            },
+        };
+    }
     const executionBrowserConfig = runOptions.browserResumeConversationUrl
         ? { ...browserConfig, resumeConversationUrl: runOptions.browserResumeConversationUrl }
         : browserConfig;
@@ -112,12 +171,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         browserResult = await executeBrowser({
             prompt: promptArtifacts.composerText,
             attachments: promptArtifacts.attachments,
-            fallbackSubmission: promptArtifacts.fallback
-                ? {
-                    prompt: promptArtifacts.fallback.composerText,
-                    attachments: promptArtifacts.fallback.attachments,
-                }
-                : undefined,
+            fallbackSubmission,
             config: executionBrowserConfig,
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
@@ -151,6 +205,10 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (modelSelection) {
         log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
+    const thinkingSelection = browserResult.thinkingSelection;
+    if (thinkingSelection) {
+        log(`[browser] Thinking effort evidence: ${formatBrowserThinkingSelectionEvidence(thinkingSelection)}`);
+    }
     const warnings = buildBrowserRunWarnings({
         runOptions,
         browserConfig,
@@ -220,16 +278,20 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromeProfileRoot: browserResult.chromeProfileRoot,
             userDataDir: browserResult.userDataDir,
             chromeTargetId: browserResult.chromeTargetId,
+            ownedRecoveryTarget: browserResult.ownedRecoveryTarget,
             tabUrl: browserResult.tabUrl,
             conversationId: browserResult.conversationId,
             promptSubmitted: browserResult.promptSubmitted,
+            researchPlan: browserResult.researchPlan,
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         archive: browserResult.archive,
         modelSelection,
+        thinkingSelection,
         warnings,
         answerText,
         artifacts: savedArtifacts,
+        savedFiles: browserResult.savedFiles,
     };
 }
 export async function ensureSessionArtifacts(params) {