@steipete/oracle 0.18.0 → 0.20.0

package/dist/src/browser/cancellation.js

@@ -0,0 +1,105 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { BrowserRunCancelledError } from "../oracle/errors.js";
+const context = new AsyncLocalStorage();
+const cleanupContext = new AsyncLocalStorage();
+export const currentBrowserAbortSignal = () => context.getStore();
+export const withoutBrowserCancellation = (task) => cleanupContext.run(true, () => context.run(undefined, task));
+/** Per-run cancellation, including polling and resources that arrive after their caller left. */
+export class BrowserCancellation {
+    signal;
+    log;
+    aborted;
+    onAbort;
+    proxies = new WeakMap();
+    constructor(signal, log = () => { }) {
+        this.signal = signal;
+        this.log = log;
+        if (signal) {
+            let rejectAbort;
+            this.aborted = new Promise((_, reject) => {
+                rejectAbort = reject;
+            });
+            this.aborted.catch(() => undefined);
+            this.onAbort = () => rejectAbort(new BrowserRunCancelledError());
+            if (signal.aborted)
+                this.onAbort();
+            else
+                signal.addEventListener("abort", this.onAbort, { once: true });
+        }
+    }
+    check() {
+        if (this.signal?.aborted)
+            throw new BrowserRunCancelledError();
+    }
+    run(task) {
+        return cleanupContext.run(false, () => context.run(this.signal, task));
+    }
+    dispose() {
+        if (this.onAbort)
+            this.signal?.removeEventListener("abort", this.onAbort);
+    }
+    race(pending) {
+        return this.aborted ? Promise.race([pending, this.aborted]) : pending;
+    }
+    call(create) {
+        this.check();
+        return this.race(create());
+    }
+    acquire(create, releaseLate) {
+        this.check();
+        const pending = create().then(async (resource) => {
+            if (this.signal?.aborted) {
+                await withoutBrowserCancellation(() => releaseLate(resource)).catch((error) => {
+                    this.log(`[browser] Late cancelled resource cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                throw new BrowserRunCancelledError();
+            }
+            return resource;
+        });
+        return this.race(pending);
+    }
+    client(client) {
+        if (!this.signal)
+            return client;
+        const wrap = (target) => {
+            const cached = this.proxies.get(target);
+            if (cached)
+                return cached;
+            const proxy = new Proxy(target, {
+                get: (object, key) => {
+                    const value = Reflect.get(object, key);
+                    if (typeof value === "function") {
+                        if ([
+                            "on",
+                            "once",
+                            "off",
+                            "emit",
+                            "removeListener",
+                            "removeAllListeners",
+                            "addListener",
+                            "close",
+                        ].includes(String(key)))
+                            return value.bind(object);
+                        return (...args) => {
+                            // CDP event subscriptions are synchronous and must remain removable during cleanup.
+                            if (typeof args[0] === "function")
+                                return Reflect.apply(value, object, args);
+                            if (cleanupContext.getStore())
+                                return Reflect.apply(value, object, args);
+                            if (this.signal?.aborted)
+                                return Promise.reject(new BrowserRunCancelledError());
+                            const result = Reflect.apply(value, object, args);
+                            return result && typeof result.then === "function"
+                                ? this.race(Promise.resolve(result))
+                                : result;
+                        };
+                    }
+                    return value && typeof value === "object" ? wrap(value) : value;
+                },
+            });
+            this.proxies.set(target, proxy);
+            return proxy;
+        };
+        return wrap(client);
+    }
+}

package/dist/src/browser/chatgptImages.js

@@ -5,6 +5,7 @@ import { ASSISTANT_ROLE_SELECTOR } from "./constants.js";
 import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
+import { throwIfAssistantUiError } from "./actions/assistantResponse.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 import { resolveSessionArtifactsDir } from "./artifacts.js";
 import { saveAssistantDownloadButtonArtifacts } from "./chatgptFiles.js";
@@ -456,6 +457,7 @@ export async function collectGeneratedImageArtifacts(params) {
                 break;
             }
             const latestSnapshot = await readAssistantSnapshot(params.Runtime, params.minTurnIndex ?? undefined).catch(() => null);
+            throwIfAssistantUiError(latestSnapshot);
             const snapshotText = typeof latestSnapshot?.text === "string" ? latestSnapshot.text.trim() : "";
             if (snapshotText) {
                 latestAnswerText = snapshotText;

package/dist/src/browser/chatgptThrottle.js

@@ -0,0 +1,104 @@
+import { BrowserAutomationError } from "../oracle/errors.js";
+/**
+ * Detection for ChatGPT's own rate-limit notice.
+ *
+ * When ChatGPT decides a session is asking for too much at once it puts a modal
+ * over the page — "Too many requests … We've temporarily limited access to your
+ * conversations … Please wait a few minutes" — with a single "Got it" button.
+ *
+ * The modal is not marked as an error anywhere a DOM scrape would notice. It is
+ * a dialog full of ordinary text, so a menu reader walking the page finds its
+ * button and reports it as an available option. That is how a throttle came to be
+ * reported as `Unable to find model option matching "Thinking 5.5". Available:
+ * Got it` — a message that sends the reader looking for a model-naming bug that
+ * does not exist, when the correct response is to wait a few minutes.
+ *
+ * Observed live: six ChatGPT conversations opened at once triggered it
+ * repeatedly, while five did not, and the limit cleared on its own after a
+ * pause. Runs must therefore treat this as a transient, recoverable state rather
+ * than a failure of the request they were making.
+ */
+const THROTTLE_PHRASES = [
+    "too many requests",
+    "making requests too quickly",
+    "temporarily limited access to your conversations",
+];
+/** True when the text carries ChatGPT's rate-limit wording. */
+export function matchesThrottleNotice(text) {
+    if (!text) {
+        return false;
+    }
+    const normalized = text.toLowerCase();
+    return THROTTLE_PHRASES.some((phrase) => normalized.includes(phrase));
+}
+export function buildThrottleProbeExpression() {
+    return `(() => {
+    const PHRASES = ${JSON.stringify(THROTTLE_PHRASES)};
+    const matches = (value) => {
+      const text = (value || '').toLowerCase();
+      return PHRASES.some((phrase) => text.includes(phrase));
+    };
+    // Dialogs first, because that is what this notice is; the body sweep is a
+    // fallback for a variant that does not carry the role.
+    const dialogs = Array.from(document.querySelectorAll('[role="dialog"], [role="alertdialog"]'));
+    for (const dialog of dialogs) {
+      const text = (dialog.innerText || '').trim();
+      if (matches(text)) return { message: text.slice(0, 400) };
+    }
+    const body = (document.body && document.body.innerText) || '';
+    if (matches(body)) {
+      const line = body
+        .split('\\n')
+        .map((entry) => entry.trim())
+        .find((entry) => matches(entry));
+      return { message: (line || 'ChatGPT is rate limiting this session.').slice(0, 400) };
+    }
+    return null;
+  })()`;
+}
+/**
+ * Looks for the rate-limit notice. Never throws: this runs on paths that are
+ * already reporting a different failure, and a probe that failed must not
+ * replace the original diagnosis with its own.
+ */
+export async function detectChatGptThrottleNotice(Runtime) {
+    try {
+        const evaluated = await Runtime.evaluate({
+            expression: buildThrottleProbeExpression(),
+            returnByValue: true,
+        });
+        const value = evaluated.result?.value;
+        if (value && typeof value.message === "string" && value.message.trim()) {
+            return { message: value.message.trim() };
+        }
+    }
+    catch {
+        // fall through: no notice detected
+    }
+    return null;
+}
+export function buildThrottleError(notice, context) {
+    return new BrowserAutomationError(`ChatGPT is rate limiting this session: ${notice.message} ` +
+        "This is a temporary limit on the account, not a problem with the request — " +
+        "wait a few minutes and retry, and reduce how many conversations are started at once.", {
+        stage: "chatgpt-throttled",
+        details: {
+            // Named so a caller can branch on it rather than parsing the message.
+            retryable: true,
+            origin: context.stage,
+            notice: notice.message,
+        },
+    });
+}
+/**
+ * Replaces a misleading failure with the real one when the page is throttled.
+ * Returns nothing when it is not, leaving the caller's own error intact.
+ */
+export async function throwIfThrottled(Runtime, context, logger) {
+    const notice = await detectChatGptThrottleNotice(Runtime);
+    if (!notice) {
+        return;
+    }
+    logger?.(`[browser] ChatGPT rate limit detected during ${context.stage}: ${notice.message}`);
+    throw buildThrottleError(notice, context);
+}

package/dist/src/browser/chromeLifecycle.js

@@ -1,19 +1,29 @@
-import { rm } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import * as childProcess from "node:child_process";
 import net from "node:net";
+import path from "node:path";
 import CDP from "chrome-remote-interface";
-import { launch, Launcher } from "chrome-launcher";
+import { launch, Launcher, } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
 import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
 export async function launchChrome(config, userDataDir, logger) {
     const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
+    const usingCopiedProfile = Boolean(config.copyProfileSource);
+    const detachSharedChrome = shouldDetachSharedChrome(config);
+    const launchedProfileDirectory = usingCopiedProfile && config.chromeProfile ? config.chromeProfile : "Default";
+    await prepareChromeWindowStateForHiddenLaunch({
+        config,
+        userDataDir,
+        profileDirectory: launchedProfileDirectory,
+        logger,
+    });
     const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress, config.hideWindow ?? false);
     // copy-profile reuses a copied signed-in profile whose cookies are
     // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
     // strip the keychain-mocking flags from both chrome-launcher's defaults and
     // Oracle's set, and ignore the defaults so they aren't re-added.
-    const usingCopiedProfile = Boolean(config.copyProfileSource);
     if (usingCopiedProfile && config.chromeProfile) {
         chromeFlags.push(`--profile-directory=${config.chromeProfile}`);
     }
@@ -26,38 +36,231 @@ export async function launchChrome(config, userDataDir, logger) {
             host: connectHost ?? "127.0.0.1",
             requestedPort: debugPort ?? undefined,
             ignoreDefaultFlags: launchOptions.ignoreDefaultFlags,
+            detachSharedChrome,
         })
-        : await launch({
+        : await launchWithStableProcessLifecycle({
             chromePath: config.chromePath ?? undefined,
             chromeFlags: launchOptions.chromeFlags,
             userDataDir,
             handleSIGINT: false,
             port: debugPort ?? undefined,
             ignoreDefaultFlags: launchOptions.ignoreDefaultFlags,
-        });
+        }, detachSharedChrome);
     const pidLabel = typeof launcher.pid === "number" ? ` (pid ${launcher.pid})` : "";
     const hostLabel = connectHost ? ` on ${connectHost}` : "";
     logger(`Launched Chrome${pidLabel} on port ${launcher.port}${hostLabel}`);
+    if (detachSharedChrome) {
+        logger("[browser] Browser control: Windows Chrome lifecycle detached=true; windowsHide=true.");
+    }
     return Object.assign(launcher, { host: connectHost ?? "127.0.0.1" });
 }
-export async function positionChromeWindowOffscreen(client, logger) {
+function shouldDetachSharedChrome(config, platform = process.platform) {
+    return platform === "win32" && config.manualLogin === true && !config.copyProfileSource;
+}
+export const shouldDetachSharedChromeForTest = shouldDetachSharedChrome;
+const spawnDetachedChromeOnWindows = ((command, args, options) => {
+    const child = childProcess.spawn(command, args, resolveChromeChildSpawnOptions(options, "win32"));
+    child.unref();
+    return child;
+});
+function resolveChromeChildSpawnOptions(options, platform = process.platform) {
+    return platform === "win32"
+        ? {
+            ...options,
+            detached: true,
+            windowsHide: true,
+        }
+        : options;
+}
+export function resolveChromeChildSpawnOptionsForTest(options, platform) {
+    return resolveChromeChildSpawnOptions(options, platform);
+}
+function chromeLauncherModuleOverrides(detachSharedChrome, platform = process.platform) {
+    return detachSharedChrome && platform === "win32"
+        ? { spawn: spawnDetachedChromeOnWindows }
+        : undefined;
+}
+async function launchWithStableProcessLifecycle(options, detachSharedChrome) {
+    if (!detachSharedChrome) {
+        return launch(options);
+    }
+    const launcher = new Launcher(options, chromeLauncherModuleOverrides(detachSharedChrome));
+    await launcher.launch();
+    return launchedChromeFromLauncher(launcher);
+}
+function launchedChromeFromLauncher(launcher) {
+    return {
+        pid: launcher.pid ?? 0,
+        port: launcher.port ?? 0,
+        process: launcher.chromeProcess,
+        kill: () => launcher.kill(),
+        remoteDebuggingPipes: launcher.remoteDebuggingPipes,
+    };
+}
+export async function positionChromeWindowOffscreen(client, userDataDir, logger) {
     if (process.platform !== "darwin") {
         logger("Window hiding is only supported on macOS");
         return;
     }
+    let savedState = false;
     try {
         const { windowId } = await client.Browser.getWindowForTarget();
+        if (!(await readSavedChromeWindowState(userDataDir))) {
+            const { bounds } = await client.Browser.getWindowBounds({ windowId });
+            await writeSavedChromeWindowState(userDataDir, bounds);
+            savedState = true;
+        }
         await client.Browser.setWindowBounds({
             windowId,
             bounds: { left: -32_000, top: -32_000, windowState: "normal" },
         });
-        logger("Chrome window positioned off-screen");
     }
     catch (error) {
+        if (savedState) {
+            await rm(chromeWindowStatePath(userDataDir), { force: true }).catch(() => undefined);
+        }
         const message = error instanceof Error ? error.message : String(error);
         logger(`Failed to position Chrome window off-screen: ${message}`);
+        return;
+    }
+    logger("Chrome window positioned off-screen");
+}
+export async function positionChromeWindowOnscreen(client, userDataDir, logger) {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    try {
+        const savedState = await readSavedChromeWindowState(userDataDir);
+        if (!savedState) {
+            return;
+        }
+        const { windowId } = await client.Browser.getWindowForTarget();
+        await client.Browser.setWindowBounds({
+            windowId,
+            bounds: restoreWindowBounds(savedState.bounds),
+        });
+        await rm(chromeWindowStatePath(userDataDir), { force: true });
+        logger("Chrome window restored to its pre-hide bounds");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to position Chrome window on-screen: ${message}`);
+    }
+}
+const CHROME_WINDOW_STATE_FILENAME = "oracle-window-state.json";
+const DEFAULT_VISIBLE_WINDOW_BOUNDS = {
+    left: 80,
+    top: 80,
+    width: 1280,
+    height: 720,
+    windowState: "normal",
+};
+function chromeWindowStatePath(userDataDir) {
+    return path.join(userDataDir, CHROME_WINDOW_STATE_FILENAME);
+}
+async function readSavedChromeWindowState(userDataDir) {
+    try {
+        const parsed = JSON.parse(await readFile(chromeWindowStatePath(userDataDir), "utf8"));
+        const bounds = parseChromeWindowBounds(parsed.bounds);
+        if (parsed.version !== 1 || !bounds) {
+            return null;
+        }
+        return { version: 1, bounds };
+    }
+    catch {
+        return null;
     }
 }
+async function writeSavedChromeWindowState(userDataDir, bounds) {
+    await mkdir(userDataDir, { recursive: true });
+    await writeFile(chromeWindowStatePath(userDataDir), `${JSON.stringify({ version: 1, bounds })}\n`, "utf8");
+}
+async function prepareChromeWindowStateForHiddenLaunch({ config, userDataDir, profileDirectory, logger, }) {
+    if (process.platform !== "darwin" ||
+        config.headless ||
+        !config.hideWindow ||
+        (await readSavedChromeWindowState(userDataDir))) {
+        return;
+    }
+    const bounds = (await readPersistedChromeWindowBounds(userDataDir, profileDirectory)) ??
+        DEFAULT_VISIBLE_WINDOW_BOUNDS;
+    await writeSavedChromeWindowState(userDataDir, bounds);
+    logger("Recorded Chrome window placement before hidden launch");
+}
+async function readPersistedChromeWindowBounds(userDataDir, profileDirectory) {
+    const root = path.resolve(userDataDir);
+    const profile = path.resolve(root, profileDirectory);
+    if (path.dirname(profile) !== root) {
+        return null;
+    }
+    try {
+        const preferences = JSON.parse(await readFile(path.join(profile, "Preferences"), "utf8"));
+        return persistedPlacementToBounds(preferences.browser?.window_placement);
+    }
+    catch {
+        return null;
+    }
+}
+function persistedPlacementToBounds(placement) {
+    if (!placement) {
+        return null;
+    }
+    if (placement.maximized === true) {
+        return { windowState: "maximized" };
+    }
+    const left = finiteNumber(placement.left);
+    const top = finiteNumber(placement.top);
+    const right = finiteNumber(placement.right);
+    const bottom = finiteNumber(placement.bottom);
+    if (left === null || top === null || right === null || bottom === null) {
+        return null;
+    }
+    const width = right - left;
+    const height = bottom - top;
+    if (width <= 0 || height <= 0) {
+        return null;
+    }
+    return { left, top, width, height, windowState: "normal" };
+}
+function parseChromeWindowBounds(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const bounds = value;
+    const windowState = bounds.windowState ?? "normal";
+    if (windowState !== "normal") {
+        return ["minimized", "maximized", "fullscreen"].includes(windowState) ? { windowState } : null;
+    }
+    const left = finiteNumber(bounds.left);
+    const top = finiteNumber(bounds.top);
+    const width = finiteNumber(bounds.width);
+    const height = finiteNumber(bounds.height);
+    if (left === null ||
+        top === null ||
+        width === null ||
+        height === null ||
+        width <= 0 ||
+        height <= 0) {
+        return null;
+    }
+    return { left, top, width, height, windowState: "normal" };
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function restoreWindowBounds(bounds) {
+    const windowState = bounds.windowState ?? "normal";
+    if (windowState !== "normal") {
+        return { windowState };
+    }
+    return {
+        left: bounds.left ?? 80,
+        top: bounds.top ?? 80,
+        width: bounds.width,
+        height: bounds.height,
+        windowState: "normal",
+    };
+}
 export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger, opts) {
     const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
     let handling;
@@ -68,7 +271,8 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
         handling = true;
         const inFlight = opts?.isInFlight?.() ?? false;
         const forceCleanup = opts?.forceProfileCleanup ?? false;
-        const leaveRunning = (keepBrowser || inFlight) && !forceCleanup;
+        const preserveSharedChrome = opts?.preserveSharedChromeOnSignal ?? false;
+        const leaveRunning = (keepBrowser || inFlight || preserveSharedChrome) && !forceCleanup;
         if (leaveRunning) {
             logger(`Received ${signal}; leaving Chrome running${inFlight ? " (assistant response pending)" : ""}`);
         }
@@ -136,23 +340,28 @@ export async function connectToRemoteChrome(host, port, logger, targetUrl, brows
             approvalWaitMs: options?.approvalWaitMs,
         });
     }
-    if (targetUrl) {
-        const targetConnection = await connectToNewTarget(host, port, targetUrl, logger, {
-            opened: () => `Opened dedicated remote Chrome tab targeting ${targetUrl}`,
-            openFailed: (message) => `Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`,
-            attachFailed: (targetId, message) => `Failed to attach to dedicated remote Chrome tab ${targetId} (${message}); falling back to first target.`,
+    const newTargetUrl = targetUrl || (options?.fallbackToDefault === false ? "about:blank" : undefined);
+    if (newTargetUrl) {
+        const targetConnection = await connectToNewTarget(host, port, newTargetUrl, logger, {
+            opened: () => `Opened dedicated remote Chrome tab targeting ${newTargetUrl}`,
+            openFailed: (message) => `Failed to open dedicated remote Chrome tab (${message}); ${options?.fallbackToDefault === false ? "refusing to reuse an unrelated tab" : "falling back to first target"}.`,
+            attachFailed: (targetId, message) => `Failed to attach to dedicated remote Chrome tab ${targetId} (${message}); ${options?.fallbackToDefault === false ? "refusing to reuse an unrelated tab" : "falling back to first target"}.`,
             closeFailed: (targetId, message) => `Failed to close unused remote Chrome tab ${targetId}: ${message}`,
         });
         if (targetConnection) {
             return {
                 client: targetConnection.client,
                 targetId: targetConnection.targetId,
-                close: async () => {
+                close: async (closeOptions) => {
                     await targetConnection.client.close().catch(() => undefined);
-                    await closeRemoteChromeTarget(host, port, targetConnection.targetId, logger);
+                    if (!closeOptions?.preserveTarget)
+                        await closeRemoteChromeTarget(host, port, targetConnection.targetId, logger);
                 },
             };
         }
+        if (options?.fallbackToDefault === false) {
+            throw new Error("Unable to create a dedicated remote Chrome tab; refusing to reuse an unrelated conversation.");
+        }
     }
     const fallbackClient = await CDP({ host, port });
     logger(`Connected to remote Chrome DevTools protocol at ${host}:${port}`);
@@ -183,7 +392,7 @@ export async function listRemoteChromeTargets(options) {
         const targets = await CDP.List({ host: options.host, port: options.port });
         return targets;
     }
-    const browser = await CDP({ target: options.browserWSEndpoint, local: true });
+    const browser = await connectToBrowserWebSocket(options.host, options.port, options.browserWSEndpoint, options.logger ?? (() => { }), options.approvalWaitMs);
     try {
         const result = await browser.Target.getTargets();
         return (result.targetInfos ?? []).map((target) => ({
@@ -223,9 +432,9 @@ export async function connectToRemoteChromeTarget(host, port, logger, options) {
             client,
             targetId,
             browserWSEndpoint: options.browserWSEndpoint,
-            close: async () => {
+            close: async (closeOptions) => {
                 await browser.Target.detachFromTarget({ sessionId: attached.sessionId }).catch(() => undefined);
-                if (options.closeTargetOnDispose && targetId) {
+                if (options.closeTargetOnDispose && targetId && !closeOptions?.preserveTarget) {
                     await browser.Target.closeTarget({ targetId }).catch(() => undefined);
                 }
                 await browser.close().catch(() => undefined);
@@ -241,33 +450,54 @@ async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger,
     if (!approvalWaitMs || approvalWaitMs <= 0) {
         return (await CDP({ target: browserWSEndpoint, local: true }));
     }
-    logger(`Waiting for Chrome remote debugging approval for ${host}:${port}...`);
-    const deadline = Date.now() + approvalWaitMs;
+    logger(`[browser] Waiting for Chrome remote debugging approval for ${host}:${port}...`);
+    const startedAt = Date.now();
+    const deadline = startedAt + approvalWaitMs;
+    const progress = setInterval(() => {
+        logger(`[browser] Still waiting for Chrome remote debugging approval for ${host}:${port} (${formatApprovalWait(Date.now() - startedAt)} elapsed). Click Allow in an open Chrome window.`);
+    }, 15_000);
     let lastApprovalError;
-    while (Date.now() < deadline) {
-        const remainingMs = Math.max(1, deadline - Date.now());
-        try {
-            return await Promise.race([
-                CDP({ target: browserWSEndpoint, local: true }),
-                new Promise((_, reject) => {
-                    setTimeout(() => {
-                        reject(new Error("__oracle_remote_debugging_approval_timeout__"));
-                    }, remainingMs);
-                }),
-            ]);
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                error.message === "__oracle_remote_debugging_approval_timeout__") {
-                break;
+    try {
+        while (Date.now() < deadline) {
+            const remainingMs = Math.max(1, deadline - Date.now());
+            let timeout;
+            let expired = false;
+            try {
+                const connecting = CDP({ target: browserWSEndpoint, local: true }).then(async (client) => {
+                    // An approval arriving after our deadline must not leak a connection.
+                    if (expired)
+                        await client.close().catch(() => undefined);
+                    return client;
+                });
+                return await Promise.race([
+                    connecting,
+                    new Promise((_, reject) => {
+                        timeout = setTimeout(() => {
+                            expired = true;
+                            reject(new Error("__oracle_remote_debugging_approval_timeout__"));
+                        }, remainingMs);
+                    }),
+                ]);
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message === "__oracle_remote_debugging_approval_timeout__") {
+                    break;
+                }
+                if (!isRemoteDebuggingApprovalError(error)) {
+                    throw error;
+                }
+                lastApprovalError = error;
             }
-            if (!isRemoteDebuggingApprovalError(error)) {
-                throw error;
+            finally {
+                clearTimeout(timeout);
             }
-            lastApprovalError = error;
             await delay(Math.min(500, Math.max(0, deadline - Date.now())));
         }
     }
+    finally {
+        clearInterval(progress);
+    }
     const suffix = lastApprovalError instanceof Error && lastApprovalError.message
         ? ` Last Chrome response: ${lastApprovalError.message}`
         : "";
@@ -598,7 +828,7 @@ function parseDebugPortEnv() {
     }
     return value;
 }
-async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, ignoreDefaultFlags, }) {
+async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, ignoreDefaultFlags, detachSharedChrome, }) {
     const launcher = new Launcher({
         chromePath: chromePath ?? undefined,
         chromeFlags,
@@ -606,7 +836,7 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
         handleSIGINT: false,
         port: requestedPort ?? undefined,
         ignoreDefaultFlags,
-    });
+    }, chromeLauncherModuleOverrides(detachSharedChrome));
     if (host) {
         const patched = launcher;
         patched.isDebuggerReady = function patchedIsDebuggerReady() {
@@ -634,13 +864,8 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
         };
     }
     await launcher.launch();
-    const kill = async () => launcher.kill();
     return {
-        pid: launcher.pid ?? undefined,
-        port: launcher.port ?? 0,
-        process: launcher.chromeProcess,
-        kill,
+        ...launchedChromeFromLauncher(launcher),
         host: host ?? undefined,
-        remoteDebuggingPipes: launcher.remoteDebuggingPipes,
     };
 }