@steipete/oracle 0.14.0 → 0.15.0

package/dist/src/browser/index.js

@@ -3,6 +3,7 @@ import path from "node:path";
 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 { syncCookies } from "./cookies.js";
 import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
@@ -66,6 +67,11 @@ function classifyPreservedBrowserError(error, headless) {
 function shouldPreserveBrowserOnError(error, headless) {
     return classifyPreservedBrowserError(error, headless) !== null;
 }
+function shouldKeepLocalBrowserOpen(options) {
+    if (options.usingCopiedProfile)
+        return false;
+    return options.effectiveKeepBrowser || options.preserveBrowserOnError;
+}
 export function shouldPreserveBrowserOnErrorForTest(error, headless) {
     return shouldPreserveBrowserOnError(error, headless);
 }
@@ -240,20 +246,39 @@ function formatChatGptUiWarningType(type) {
             return "authentication/challenge";
     }
 }
-async function createAssistantTimeoutError(params) {
+async function createChatGptUiWarningError(params) {
     const [uiWarning] = await collectChatGptUiWarnings(params.Runtime);
-    if (!uiWarning) {
-        return new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime: params.runtime, diagnostics: params.diagnostics }, params.cause);
-    }
+    if (!uiWarning)
+        return null;
     params.logger(`[browser] ChatGPT UI warning detected (${uiWarning.type}): ${uiWarning.message}`);
-    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for the assistant: ${uiWarning.message}`, {
-        stage: "assistant-timeout",
+    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for ${params.waitTarget}: ${uiWarning.message}`, {
+        stage: params.stage,
         code: "chatgpt-ui-warning",
         uiWarning,
         runtime: params.runtime,
         diagnostics: params.diagnostics,
     }, params.cause);
 }
+async function throwChatGptUiWarningIfPresent(params) {
+    const error = await createChatGptUiWarningError(params);
+    if (error)
+        throw error;
+}
+async function createAssistantTimeoutError(params) {
+    const warningError = await createChatGptUiWarningError({
+        Runtime: params.Runtime,
+        logger: params.logger,
+        runtime: params.runtime,
+        stage: "assistant-timeout",
+        waitTarget: "the assistant",
+        diagnostics: params.diagnostics,
+        cause: params.cause,
+    });
+    if (!warningError) {
+        return new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime: params.runtime, diagnostics: params.diagnostics }, params.cause);
+    }
+    return warningError;
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -334,7 +359,8 @@ function isImageOnlyUiChromeText(text) {
     return (normalized.length === 0 ||
         normalized === "edit" ||
         normalized === "stopped thinking" ||
-        normalized === "stopped thinking edit");
+        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));
 }
 function normalizeBrowserFollowUpPrompts(values) {
     return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
@@ -409,6 +435,15 @@ async function maybeArchiveCompletedConversation({ Runtime, logger, config, conv
 export function maybeArchiveCompletedConversationForTest(args) {
     return maybeArchiveCompletedConversation(args);
 }
+async function captureDeepResearchTargetBaseline(client, logger) {
+    try {
+        return { targetKeys: await captureDeepResearchTargetKeys(client), captured: true };
+    }
+    catch {
+        logger("[browser] Deep Research target baseline unavailable; retaining conversation-turn owner scoping.");
+        return { targetKeys: [], captured: false };
+    }
+}
 async function runSubmissionWithRecovery({ prompt, attachments, fallbackSubmission, submit, reloadPromptComposer, prepareFallbackSubmission, logger, }) {
     let currentPrompt = prompt;
     let currentAttachments = attachments;
@@ -500,6 +535,10 @@ export async function runBrowserMode(options) {
     const attachments = options.attachments ?? [];
     const fallbackSubmission = options.fallbackSubmission;
     let config = resolveBrowserConfig(options.config);
+    const usingCopiedProfile = Boolean(config.copyProfileSource);
+    if (usingCopiedProfile && (config.attachRunning || config.remoteChrome)) {
+        throw new BrowserAutomationError("--copy-profile requires a locally launched Chrome instance and cannot be combined with attach-running or remote Chrome.", { stage: "profile-config" });
+    }
     const isResumingConversation = Boolean(config.resumeConversationUrl);
     const followUpPrompts = normalizeBrowserFollowUpPrompts(options.followUpPrompts);
     if (config.researchMode === "deep" && followUpPrompts.length > 0) {
@@ -593,6 +632,12 @@ export async function runBrowserMode(options) {
         return runRemoteBrowserMode(promptText, attachments, config, logger, options);
     }
     const manualLogin = Boolean(config.manualLogin);
+    if (manualLogin && usingCopiedProfile) {
+        throw new BrowserAutomationError("--copy-profile cannot be combined with --browser-manual-login: choose either a throwaway copied profile or the persistent manual-login profile.", { stage: "profile-config" });
+    }
+    // Manual-login and copy-profile both start from an already-signed-in profile,
+    // so neither clears nor syncs cookies.
+    const profileIsPreSigned = manualLogin || usingCopiedProfile;
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
         : defaultManualLoginProfileDir();
@@ -609,6 +654,11 @@ export async function runBrowserMode(options) {
             keepBrowser: effectiveKeepBrowser,
         });
     }
+    else if (config.copyProfileSource) {
+        const copiedProfileDirectory = await copyChromeProfile(config.copyProfileSource, userDataDir, config.chromeProfile);
+        config = { ...config, chromeProfile: copiedProfileDirectory };
+        logger(`Seeded temporary Chrome profile ${copiedProfileDirectory} from ${config.copyProfileSource} (copy-profile mode; signed-in session reused without manual login)`);
+    }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
     }
@@ -638,6 +688,9 @@ export async function runBrowserMode(options) {
             tabLease = null;
             await handle.release().catch(() => undefined);
         }
+        if (usingCopiedProfile) {
+            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        }
         throw error;
     }
     const { chrome, reusedChrome } = acquiredChrome;
@@ -654,6 +707,8 @@ export async function runBrowserMode(options) {
             isInFlight: () => runStatus !== "complete",
             emitRuntimeHint,
             preserveUserDataDir: manualLogin,
+            // copy-profile is a throwaway copy of a signed-in profile; never leave it on disk.
+            forceProfileCleanup: usingCopiedProfile,
         });
     }
     catch {
@@ -690,9 +745,10 @@ export async function runBrowserMode(options) {
             }
             else {
                 const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+                const devtoolsRetries = manualLogin ? 6 : 0;
                 const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
                     fallbackToDefault: !strictTabIsolation,
-                    retries: strictTabIsolation ? 3 : 0,
+                    retries: devtoolsRetries,
                     retryDelayMs: 500,
                 });
                 client = connection.client;
@@ -732,11 +788,11 @@ export async function runBrowserMode(options) {
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
-        if (!manualLogin) {
+        if (!profileIsPreSigned) {
             await Network.clearBrowserCookies();
         }
         const manualLoginCookieSync = manualLogin && Boolean(config.manualLoginCookieSync);
-        const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
+        const cookieSyncEnabled = config.cookieSync && (!profileIsPreSigned || manualLoginCookieSync);
         if (cookieSyncEnabled) {
             if (manualLoginCookieSync) {
                 logger("Manual login mode: seeding persistent profile with cookies from your Chrome profile.");
@@ -1039,8 +1095,8 @@ export async function runBrowserMode(options) {
                 attachmentNames: attachmentExpectations,
                 onPromptSubmitted: markPromptSubmitted,
             };
-            const deepResearchTargetKeys = deepResearch && client
-                ? await captureDeepResearchTargetKeys(client).catch(() => [])
+            const deepResearchTargetBaseline = deepResearch && client
+                ? await captureDeepResearchTargetBaseline(client, logger)
                 : undefined;
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
@@ -1074,7 +1130,12 @@ export async function runBrowserMode(options) {
             }
             // Reattach needs a /c/ URL; ChatGPT can update it late, so poll in the background.
             scheduleConversationHint("post-submit", config.timeoutMs ?? 120_000);
-            return { baselineTurns, baselineAssistantText, deepResearchTargetKeys };
+            return {
+                baselineTurns,
+                baselineAssistantText,
+                deepResearchTargetKeys: deepResearchTargetBaseline?.targetKeys,
+                deepResearchTargetBaselineCaptured: deepResearchTargetBaseline?.captured,
+            };
         };
         const reloadPromptComposer = async () => {
             logger("[browser] Composer became unresponsive; reloading page and retrying once.");
@@ -1084,6 +1145,7 @@ export async function runBrowserMode(options) {
         let baselineTurns = null;
         let baselineAssistantText = null;
         let deepResearchTargetKeys = [];
+        let deepResearchTargetBaselineCaptured = false;
         await acquireProfileLockIfNeeded();
         try {
             const submission = await runSubmissionWithRecovery({
@@ -1101,6 +1163,7 @@ export async function runBrowserMode(options) {
             baselineTurns = submission.baselineTurns;
             baselineAssistantText = submission.baselineAssistantText;
             deepResearchTargetKeys = submission.deepResearchTargetKeys ?? [];
+            deepResearchTargetBaselineCaptured = submission.deepResearchTargetBaselineCaptured ?? false;
         }
         finally {
             await releaseProfileLockIfHeld();
@@ -1108,7 +1171,10 @@ export async function runBrowserMode(options) {
         const imageArtifactMinTurnIndex = baselineTurns;
         if (deepResearch) {
             await raceWithDisconnect(waitForResearchPlanAutoConfirm(Runtime, logger));
-            const researchResult = await raceWithDisconnect(waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, { ignoredTargetKeys: deepResearchTargetKeys }));
+            const researchResult = await raceWithDisconnect(waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, {
+                ignoredTargetKeys: deepResearchTargetKeys,
+                targetBaselineCaptured: deepResearchTargetBaselineCaptured,
+            }));
             await updateConversationHint("post-deep-research", 15_000).catch(() => false);
             runStatus = "complete";
             const durationMs = Date.now() - startedAt;
@@ -1504,6 +1570,23 @@ export async function runBrowserMode(options) {
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePid: chrome.pid,
+                    chromePort: chrome.port,
+                    chromeHost,
+                    userDataDir,
+                    chromeTargetId: lastTargetId,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {
@@ -1576,6 +1659,10 @@ export async function runBrowserMode(options) {
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
         const preservedErrorKind = classifyPreservedBrowserError(normalizedError, config.headless);
         if (preservedErrorKind === "cloudflare-challenge") {
+            if (usingCopiedProfile) {
+                logger("Cloudflare challenge detected; closing Chrome and removing the copied profile because copy-profile runs cannot be retained.");
+                throw new BrowserAutomationError("Cloudflare challenge detected. Copy-profile runs cannot be retained; complete the check in the source Chrome profile, then rerun.", { stage: "cloudflare-challenge", reattachable: false }, normalizedError);
+            }
             preserveBrowserOnError = true;
             const runtime = {
                 chromePid: chrome.pid,
@@ -1599,6 +1686,13 @@ export async function runBrowserMode(options) {
             }, normalizedError);
         }
         if (preservedErrorKind === "reattachable-capture") {
+            if (usingCopiedProfile) {
+                logger("Assistant capture incomplete; closing Chrome and removing the copied profile because copy-profile runs cannot be reattached.");
+                const details = normalizedError instanceof BrowserAutomationError
+                    ? { ...normalizedError.details, runtime: undefined, reattachable: false }
+                    : { stage: "assistant-recheck", reattachable: false };
+                throw new BrowserAutomationError(normalizedError.message, details, normalizedError);
+            }
             preserveBrowserOnError = true;
             await emitRuntimeHint();
             logger("Assistant capture incomplete; leaving browser open for reattach.");
@@ -1651,7 +1745,11 @@ export async function runBrowserMode(options) {
             chrome?.port) {
             await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
         }
-        let keepBrowserOpen = effectiveKeepBrowser || preserveBrowserOnError;
+        let keepBrowserOpen = shouldKeepLocalBrowserOpen({
+            effectiveKeepBrowser,
+            preserveBrowserOnError,
+            usingCopiedProfile,
+        });
         let cleanupProfileLock = null;
         let terminatedRecordedChrome = false;
         let otherActiveBrowserTabLeases = null;
@@ -2209,8 +2307,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 attachmentNames: attachmentExpectations,
                 onPromptSubmitted: markPromptSubmitted,
             };
-            const deepResearchTargetKeys = deepResearch && client
-                ? await captureDeepResearchTargetKeys(client).catch(() => [])
+            const deepResearchTargetBaseline = deepResearch && client
+                ? await captureDeepResearchTargetBaseline(client, logger)
                 : undefined;
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
@@ -2224,7 +2322,12 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
             }
-            return { baselineTurns, baselineAssistantText, deepResearchTargetKeys };
+            return {
+                baselineTurns,
+                baselineAssistantText,
+                deepResearchTargetKeys: deepResearchTargetBaseline?.targetKeys,
+                deepResearchTargetBaselineCaptured: deepResearchTargetBaseline?.captured,
+            };
         };
         const reloadPromptComposer = async () => {
             logger("[browser] Composer became unresponsive; reloading page and retrying once.");
@@ -2234,6 +2337,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         let baselineTurns = null;
         let baselineAssistantText = null;
         let deepResearchTargetKeys = [];
+        let deepResearchTargetBaselineCaptured = false;
         const submission = await runSubmissionWithRecovery({
             prompt: promptText,
             attachments,
@@ -2249,10 +2353,14 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         baselineTurns = submission.baselineTurns;
         baselineAssistantText = submission.baselineAssistantText;
         deepResearchTargetKeys = submission.deepResearchTargetKeys ?? [];
+        deepResearchTargetBaselineCaptured = submission.deepResearchTargetBaselineCaptured ?? false;
         const imageArtifactMinTurnIndex = baselineTurns;
         if (deepResearch) {
             await waitForResearchPlanAutoConfirm(Runtime, logger);
-            const researchResult = await waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, { ignoredTargetKeys: deepResearchTargetKeys });
+            const researchResult = await waitForDeepResearchCompletion(Runtime, logger, config.timeoutMs, baselineTurns, Page, client, {
+                ignoredTargetKeys: deepResearchTargetKeys,
+                targetBaselineCaptured: deepResearchTargetBaselineCaptured,
+            });
             await emitRuntimeHint();
             const durationMs = Date.now() - startedAt;
             const tokens = estimateTokenCount(researchResult.text);
@@ -2616,6 +2724,23 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePort: port,
+                    chromeHost: host,
+                    chromeBrowserWSEndpoint: browserWSEndpoint,
+                    chromeProfileRoot,
+                    chromeTargetId: remoteTargetId ?? undefined,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {
@@ -2757,6 +2882,7 @@ export const __test__ = {
     listIgnoredRemoteChromeFlags,
     resolveManualLoginWaitMs,
     shouldCloseOwnedRunTargetAfterRun,
+    shouldKeepLocalBrowserOpen,
 };
 export { syncCookies } from "./cookies.js";
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";

package/dist/src/browser/profileCopy.js

@@ -0,0 +1,93 @@
+import { spawn } from "node:child_process";
+import { cp, mkdir, readFile, rm } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Cache/derived subdirectories that bloat the copy and carry no signed-in-session
+ * signal, so they are skipped when seeding a copied Chrome profile.
+ */
+const RSYNC_EXCLUDES = [
+    "Cache/",
+    "Code Cache/",
+    "GPUCache/",
+    "DawnGraphiteCache/",
+    "DawnWebGPUCache/",
+    "GrShaderCache/",
+    "ShaderCache/",
+    "Service Worker/CacheStorage/",
+    "Service Worker/ScriptCache/",
+    "Service Worker/Database/",
+];
+/**
+ * Copy a signed-in Chrome user-data directory into `destDir` so a throwaway
+ * Chrome can launch on the copy and reuse the live session WITHOUT a manual
+ * sign-in. Copies the `Default/` profile (minus cache dirs) plus the top-level
+ * `Local State` file.
+ *
+ * `Local State` is required: on macOS it holds the Keychain-wrapped
+ * "Chrome Safe Storage" key that decrypts the profile's cookies — a cookies-only
+ * copy fails the logged-in check. Decryption only succeeds when the copy is
+ * launched by the real Chrome binary (the one on the Keychain ACL).
+ *
+ * Uses rsync (present on macOS/Linux) so a live, in-use source profile copies
+ * cleanly — rsync exit 24 ("source files vanished") is tolerated.
+ */
+export async function copyChromeProfile(srcUserDataDir, destDir, requestedProfile) {
+    try {
+        const localStatePath = path.join(srcUserDataDir, "Local State");
+        const copiedLocalStatePath = path.join(destDir, "Local State");
+        await cp(localStatePath, copiedLocalStatePath).catch((err) => {
+            throw new Error(`--copy-profile: could not copy required "Local State" from ${srcUserDataDir} ` +
+                `(needed to select and decrypt the signed-in profile): ${err.message}`);
+        });
+        const localState = await readFile(copiedLocalStatePath, "utf8");
+        const profileDirectory = resolveChromeProfileDirectory(srcUserDataDir, localState, requestedProfile);
+        const srcProfile = path.join(srcUserDataDir, profileDirectory);
+        const destProfile = path.join(destDir, profileDirectory);
+        await mkdir(destProfile, { recursive: true });
+        // `Local State` is required (holds the Keychain-wrapped key that decrypts the
+        // cookies), so a copy failure must fail fast — otherwise the run continues with
+        // a profile that silently looks logged-out.
+        const args = ["-a"];
+        for (const exclude of RSYNC_EXCLUDES) {
+            args.push("--exclude", exclude);
+        }
+        args.push(`${srcProfile}/`, `${destProfile}/`);
+        await new Promise((resolve, reject) => {
+            const child = spawn("rsync", args, { stdio: "ignore" });
+            child.on("error", (err) => reject(new Error(`--copy-profile requires rsync on PATH (spawn failed): ${err.message}`)));
+            child.on("close", (code) => code === 0 || code === 24
+                ? resolve()
+                : reject(new Error(`rsync failed copying Chrome profile (exit ${code})`)));
+        });
+        return profileDirectory;
+    }
+    catch (error) {
+        // The destination is always a newly-created throwaway profile. Remove partial
+        // session-bearing copies before surfacing setup failures.
+        await rm(destDir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function resolveChromeProfileDirectory(srcUserDataDir, localState, requestedProfile) {
+    let profile = requestedProfile?.trim();
+    if (!profile) {
+        try {
+            const parsed = JSON.parse(localState);
+            profile =
+                typeof parsed.profile?.last_used === "string" ? parsed.profile.last_used.trim() : "";
+        }
+        catch (error) {
+            throw new Error(`--copy-profile: could not parse "Local State" to select the active Chrome profile: ${error.message}`);
+        }
+    }
+    profile ||= "Default";
+    const root = path.resolve(srcUserDataDir);
+    const resolved = path.resolve(root, profile);
+    if (path.dirname(resolved) !== root) {
+        throw new Error(`--copy-profile: Chrome profile must be a direct child of the user-data directory; received ${JSON.stringify(profile)}.`);
+    }
+    return path.basename(resolved);
+}
+export function resolveChromeProfileDirectoryForTest(srcUserDataDir, localState, requestedProfile) {
+    return resolveChromeProfileDirectory(srcUserDataDir, localState, requestedProfile);
+}

package/dist/src/browser/projectSourcesRunner.js

@@ -97,9 +97,10 @@ export async function runBrowserProjectSources(request) {
             preserveUserDataDir: manualLogin,
         });
         const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+        const devtoolsRetries = manualLogin ? 6 : 0;
         const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
             fallbackToDefault: !strictTabIsolation,
-            retries: strictTabIsolation ? 3 : 0,
+            retries: devtoolsRetries,
             retryDelayMs: 500,
         });
         client = connection.client;