@loadmill/droid-cua 2.8.0 → 2.10.0

package/README.md

@@ -40,6 +40,7 @@ Under the hood, `droid-cua` uses an AI agent to explore your app, execute action
 
 - Mac: [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA.dmg)
 - Mac (Intel): [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA-intel.dmg)
+- Windows: [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA-Setup.exe)
 
 **2. Launch the app**
 
@@ -67,6 +68,10 @@ You can also keep project run history in a results folder and review past runs f
 - **Android** - Physical devices and emulators
 - **iOS** - Simulators on macOS
 
+Desktop app support:
+- macOS: Android and iOS simulator workflows
+- Windows: Android workflows only
+
 ## Requirements
 
 **All platforms:**
@@ -154,10 +159,9 @@ Example headless config:
     "executionModeInstructions": ""
   },
   "appContextEnabled": true,
-  "appContextBudget": 300,
   "appContextPath": "../tests/context.md",
   "contextOptimizationEnabled": true,
-  "contextOptimizationThreshold": 30000
+  "contextOptimizationThreshold": 20000
 }
 ```
 
@@ -177,7 +181,6 @@ Supported CLI options include:
 - `--config`
 - `--cua-model`
 - `--context`
-- `--app-context-budget`
 - `--no-context`
 - `--context-optimization-threshold`
 - `--no-context-optimization`
@@ -185,8 +188,6 @@ Supported CLI options include:
 - `--execution-prompt`
 - `--base-prompt-file`
 - `--execution-prompt-file`
-- `--strict`
-- `--no-strict`
 - `--record`
 - `--debug`
 
@@ -195,7 +196,7 @@ Config and precedence rules:
 - CLI flags override config file values.
 - `--context` overrides the config app-context path.
 - `--no-context` disables app context entirely.
-- Context Optimization is enabled by default with a `30000` input-token threshold.
+- Context Optimization is enabled by default with a `20000` input-token threshold.
 - `--context-optimization-threshold <tokens>` sets the threshold and enables Context Optimization.
 - `--no-context-optimization` disables Context Optimization.
 - `--base-prompt` and `--execution-prompt` let you pass prompt customizations inline on the command line.

package/build/index.js

@@ -11,16 +11,18 @@ import { ExecutionEngine } from "./src/core/execution-engine.js";
 import { buildBaseSystemPrompt, buildExecutionModePrompt } from "./src/core/prompts.js";
 import { startInkShell } from "./src/cli/ink-shell.js";
 import { ExecutionMode } from "./src/modes/execution-mode.js";
+import { createOpenAiExecutor } from "./src/device/openai.js";
 import { logger } from "./src/utils/logger.js";
 import { selectDevice } from "./src/cli/device-selector.js";
-import { buildAppContextBriefing, DEFAULT_APP_CONTEXT_BUDGET } from "./src/core/app-context.js";
-import { CONTEXT_OPTIMIZATION_ENABLED_ENV, CONTEXT_OPTIMIZATION_THRESHOLD_ENV, } from "./src/core/context-optimization.js";
+import { resolveExecutionAppContext } from "./src/core/app-context.js";
+import { createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
 import { resolveHeadlessExecutionConfig } from "./src/cli/headless-execution-config.js";
 import { resolveHeadlessTarget } from "./src/cli/headless-target.js";
 import { printCliOutput } from "./src/utils/console-output.js";
 import { emitDesktopDebug } from "./src/utils/desktop-debug.js";
 import { createHeadlessDebugArtifacts } from "./src/cli/headless-debug.js";
 import { loadHeadlessInstructions } from "./src/cli/headless-instructions.js";
+import { createLoadmillApiClient } from "./src/integrations/loadmill/client.js";
 dotenv.config();
 const args = minimist(process.argv.slice(2));
 const targetConfig = resolveHeadlessTarget(args);
@@ -30,14 +32,31 @@ const recordScreenshots = args["record"] || false;
 const instructionsFile = args.instructions || args.i || null;
 const appContextPath = typeof args.context === "string" ? args.context : null;
 const debugMode = args["debug"] || false;
-const strictFlag = args.strict === true;
-const noStrictFlag = args["no-strict"] === true || args.strict === false;
-if (strictFlag && noStrictFlag) {
-    throw new Error("--strict and --no-strict cannot be used together.");
-}
 const screenshotDir = path.join("droid-cua-recording-" + Date.now());
 if (recordScreenshots)
     await mkdir(screenshotDir, { recursive: true });
+function createCliRuntimeContext(configOverrides = {}) {
+    // CLI env/config is bootstrap input only. After this boundary the shared
+    // runtime uses explicit run-scoped config and credentials objects.
+    const context = createRunContext({
+        config: resolveRuntimeConfigFromEnv(process.env, configOverrides),
+        credentials: resolveRuntimeCredentialsFromEnv(process.env),
+    });
+    const openAi = createOpenAiExecutor({
+        client: context.clients.openai,
+        config: context.config,
+    });
+    const loadmillClient = createLoadmillApiClient({
+        token: context.credentials.loadmillApiToken,
+        baseUrl: context.credentials.loadmillBaseUrl,
+    });
+    return {
+        ...context,
+        openAi,
+        openAiClient: context.clients.openai,
+        loadmillClient,
+    };
+}
 async function main() {
     const isHeadlessInstructionsRun = Boolean(instructionsFile);
     const isBrowserTarget = targetConfig.target === "web";
@@ -63,7 +82,6 @@ async function main() {
     let deviceInfo;
     if (isBrowserTarget) {
         targetId = await connectToBrowser({
-            url: targetConfig.url,
             headless: true,
             sessionMode: targetConfig.sessionMode
         });
@@ -91,10 +109,12 @@ async function main() {
         let instructions = [];
         let executionMode = null;
         try {
+            const headlessConfig = await resolveHeadlessExecutionConfig(args);
             await headlessDebug.startExecutionSession(runId, {
                 testName,
                 platform: deviceInfo.platform,
-                deviceName: deviceInfo.device_name
+                deviceName: deviceInfo.device_name,
+                aimAssistMode: headlessConfig.aimAssistMode
             });
             const currentLogFilePath = await headlessDebug.getCurrentLogFilePath();
             if (currentLogFilePath) {
@@ -102,71 +122,53 @@ async function main() {
             }
             console.log(`\nRunning test from: ${instructionsFile}\n`);
             instructions = await loadHeadlessInstructions(instructionsFile);
-            const taskText = instructions.join("\n");
-            const headlessConfig = await resolveHeadlessExecutionConfig(args);
-            process.env.OPENAI_CUA_MODEL = headlessConfig.cuaModel;
-            process.env[CONTEXT_OPTIMIZATION_ENABLED_ENV] = String(headlessConfig.contextOptimizationEnabled);
-            process.env[CONTEXT_OPTIMIZATION_THRESHOLD_ENV] = String(headlessConfig.contextOptimizationThreshold);
-            console.log(`Using CUA model: ${headlessConfig.cuaModel}`);
-            let appContextBriefing = "";
-            if (!headlessConfig.appContextEnabled) {
-                emitDesktopDebug("app_context.status", "execution", { runId }, {
+            const appContext = await resolveExecutionAppContext({
+                enabled: headlessConfig.appContextEnabled,
+                contextPath: headlessConfig.appContextPath,
+            });
+            const appContextText = appContext.text;
+            const runtimeContext = createCliRuntimeContext({
+                cuaModel: headlessConfig.cuaModel,
+                promptCustomizations: headlessConfig.promptCustomizations,
+                contextOptimizationEnabled: headlessConfig.contextOptimizationEnabled,
+                contextOptimizationThreshold: headlessConfig.contextOptimizationThreshold,
+                appContext: {
+                    enabled: headlessConfig.appContextEnabled,
+                    path: appContext.contextPath,
+                    status: appContext.status,
+                    text: appContextText,
+                    message: appContext.message,
+                },
+            });
+            console.log(`Using CUA model: ${runtimeContext.config.cuaModel}`);
+            if (appContext.status === "loaded" || appContext.status === "empty") {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
                     source: "cli_context_flag",
-                    contextPath: null,
-                    budget: headlessConfig.appContextBudget,
-                    status: "disabled"
+                    contextPath: appContext.contextPath,
+                    status: appContext.status,
+                    text: appContextText
                 });
-            }
-            else if (headlessConfig.appContextPath) {
-                try {
-                    const result = await buildAppContextBriefing({
-                        contextPath: headlessConfig.appContextPath,
-                        taskText,
-                        budget: headlessConfig.appContextBudget,
-                    });
-                    appContextBriefing = result.briefing;
-                    emitDesktopDebug("app_context.status", "execution", { runId }, {
-                        source: "cli_context_flag",
-                        contextPath: result.contextPath,
-                        budget: headlessConfig.appContextBudget,
-                        outputTokens: result.outputTokens,
-                        status: appContextBriefing.trim().length > 0 ? "loaded" : "empty"
-                    });
-                    if (appContextBriefing) {
-                        emitDesktopDebug("app_context.briefing.full", "execution", { runId }, {
-                            source: "cli_context_flag",
-                            contextPath: result.contextPath,
-                            budget: headlessConfig.appContextBudget,
-                            outputTokens: result.outputTokens,
-                            briefing: appContextBriefing
-                        });
-                        console.log(`Using app context briefing from: ${result.contextPath}`);
-                    }
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : "Unknown app context error";
-                    emitDesktopDebug("app_context.status", "execution", { runId }, {
-                        source: "cli_context_flag",
-                        contextPath: headlessConfig.appContextPath,
-                        budget: headlessConfig.appContextBudget,
-                        status: "failed",
-                        message
-                    });
-                    console.warn(`Warning: could not load app context from ${headlessConfig.appContextPath}. Running without briefing.`);
+                if (appContextText) {
+                    console.log(`Using app context from: ${appContext.contextPath}`);
                 }
             }
+            else if (appContext.status === "failed") {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
+                    source: "cli_context_flag",
+                    contextPath: appContext.contextPath,
+                    status: "failed",
+                    message: appContext.message
+                });
+                console.warn(`Warning: could not load app context from ${appContext.contextPath}. Running without it.`);
+            }
             else {
-                emitDesktopDebug("app_context.status", "execution", { runId }, {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
                     source: "cli_context_flag",
-                    contextPath: null,
-                    budget: headlessConfig.appContextBudget,
-                    status: "missing"
+                    contextPath: appContext.contextPath,
+                    status: appContext.status
                 });
-                if (isBrowserTarget && deviceInfo.currentUrl) {
-                    appContextBriefing = `Starting URL: ${deviceInfo.currentUrl}`;
-                }
             }
-            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextBriefing, { strictMode: headlessConfig.strictMode });
+            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextText, { aimAssistMode: headlessConfig.aimAssistMode });
             session.setSystemPrompt(executionPrompt);
             const screenshotRecorder = headlessDebug.createExecutionScreenshotRecorder({
                 runId,
@@ -177,12 +179,22 @@ async function main() {
                 ? {
                     recordScreenshots: true,
                     screenshotRecorder,
-                    strictMode: headlessConfig.strictMode
+                    stepDelayMs: runtimeContext.config.stepDelayMs,
+                    sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
+                        ...requestArgs,
+                        aimAssistMode: headlessConfig.aimAssistMode,
+                    }),
+                    reviseTestScript: runtimeContext.openAi.reviseTestScript,
                 }
                 : {
                     recordScreenshots,
                     screenshotDir,
-                    strictMode: headlessConfig.strictMode
+                    stepDelayMs: runtimeContext.config.stepDelayMs,
+                    sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
+                        ...requestArgs,
+                        aimAssistMode: headlessConfig.aimAssistMode,
+                    }),
+                    reviseTestScript: runtimeContext.openAi.reviseTestScript,
                 };
             if (isBrowserTarget) {
                 engineOptions.getScreenshotAsBase64 = (browserSessionId, browserInfo) => getBrowserScreenshotAsBase64(browserSessionId, browserInfo);
@@ -193,7 +205,10 @@ async function main() {
             executionMode = new ExecutionMode(session, engine, instructions, true);
             const result = await executionMode.execute({
                 runId,
-                addOutput: printCliOutput
+                addOutput: printCliOutput,
+                openAiClient: runtimeContext.openAiClient,
+                loadmillClient: runtimeContext.loadmillClient,
+                runtimeCredentials: runtimeContext.credentials,
             });
             const stats = executionMode.stats || {};
             const durationMs = stats.startTime ? Math.max(0, Date.now() - stats.startTime) : 0;
@@ -238,15 +253,18 @@ async function main() {
             throw error;
         }
     }
+    const runtimeContext = createCliRuntimeContext();
     const engine = new ExecutionEngine(session, {
         recordScreenshots,
         screenshotDir,
-        strictMode: strictFlag,
+        stepDelayMs: runtimeContext.config.stepDelayMs,
+        sendCUARequest: runtimeContext.openAi.sendCUARequest,
+        reviseTestScript: runtimeContext.openAi.reviseTestScript,
     });
     // Otherwise, start interactive Ink shell
     await startInkShell(session, engine, {
         appContextPath: appContextPath ? path.resolve(appContextPath) : null,
-        appContextBudget: DEFAULT_APP_CONTEXT_BUDGET,
+        runtimeContext,
     });
 }
 main().catch((error) => {

package/build/src/brand/loadmill-mark.js

@@ -0,0 +1,20 @@
+export const LOADMILL_MARK_PATHS = [
+    {
+        d: `M808.982 297.016 644.14 29.3c-1.484-2.012-5.587-8.153-11.234-8.488-7.747-.46-9.872 3.935-11.428
+7.151l-.029.06-111.354 457.775c-1.141 5.191.769 9.126 4.5 12.835 3.731 3.709 10.086 1.879
+12.796.5l275.123-180.566c2.845-1.478 8.763-5.472 9.675-9.625.912-4.153-1.758-9.681-3.207-11.926ZM221.403
+695.361l265.91-167.74c2.219-1.152 8.607-4.858 13.825-2.672 7.156 3 7.129 7.881 7.109 11.453v.067L406.583
+996.493c-1.262 5.167-4.71 7.857-9.694 9.537-4.983 1.69-9.882-2.75-11.708-5.18L217.718 717.557c-1.903-2.58-5.457-8.772-4.447-12.902
+1.01-4.131 5.843-7.917 8.132-9.294Z`,
+        fill: "#52BAD3"
+    },
+    {
+        d: `M282.079 171.043 8.876 355.76c-1.948 1.568-7.91 5.926-8.008 11.582-.133 7.758 4.346 9.697 7.625
+11.116l.062.027 452.431 99.593c5.234.922 9.086-1.152 12.634-5.036 3.549-3.884 1.453-10.156-.039-12.806L303.882
+176.598c-1.596-2.78-5.835-8.525-10.023-9.261-4.188-.737-9.598 2.163-11.78 3.706ZM769.31 811.501
+554.939 562.32c-1.503-1.998-6.214-7.686-4.919-13.193 1.775-7.554 6.594-8.334 10.12-8.904l.066-.011
+462.134 22.113c5.3.392 8.52 3.347 11.01 7.984 2.49 4.636-1.08 10.201-3.18 12.405L791.81 811.468c-2.23
+2.303-7.75 6.832-11.99 6.518-4.241-.314-8.774-4.454-10.51-6.485Z`,
+        fill: "#5691E2"
+    }
+];

package/build/src/browser/playwright/connection.js

@@ -6,10 +6,23 @@ import { emitDesktopDebug } from "../../utils/desktop-debug.js";
 import { requireInstalledBrowser } from "./installed-browser.js";
 import { clearActiveBrowserSession, getActiveBrowserSession, setActiveBrowserSession } from "./session-state.js";
 import { normalizeAutomationUrl, normalizeOptionalAutomationUrl } from "./url.js";
+import { getWelcomePageUrl, isWelcomePageUrl } from "./welcome-page.js";
 const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
 let browserConnectionTestHooks = null;
+let pendingBrowserSessionShutdown = null;
+async function gotoWithTimeoutTolerance(page, url) {
+    try {
+        await page.goto(url, { waitUntil: "load" });
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.name !== "TimeoutError") {
+            throw error;
+        }
+        console.warn(`Page load did not finish within the timeout for ${url}. Continuing with the current page state.`);
+    }
+}
 function normalizeKnownPageUrl(url) {
-    if (typeof url !== "string" || url.trim().length === 0 || url.trim() === "about:blank") {
+    if (typeof url !== "string" || url.trim().length === 0 || url.trim() === "about:blank" || isWelcomePageUrl(url.trim())) {
         return null;
     }
     try {
@@ -19,6 +32,125 @@ function normalizeKnownPageUrl(url) {
         return null;
     }
 }
+async function closeExtraPages(context, primaryPage) {
+    for (const page of context.pages()) {
+        if (page === primaryPage) {
+            continue;
+        }
+        try {
+            await page.close();
+        }
+        catch {
+            // Best-effort cleanup for restored tabs.
+        }
+    }
+}
+async function cleanupClosedSession(session) {
+    if (!session.cleanupOnDisconnect) {
+        return;
+    }
+    try {
+        await rm(session.userDataDir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup when the browser disappears outside normal disconnect flow.
+    }
+}
+function isBenignCloseError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = `${error.name} ${error.message}`.toLowerCase();
+    return (message.includes("target page, context or browser has been closed") ||
+        message.includes("browser has been closed") ||
+        message.includes("context closed") ||
+        message.includes("target closed") ||
+        message.includes("session closed") ||
+        message.includes("closed") ||
+        message.includes("disconnected"));
+}
+function isCurrentSession(session) {
+    try {
+        return getActiveBrowserSession().sessionId === session.sessionId;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPendingBrowserSessionShutdown() {
+    if (!pendingBrowserSessionShutdown) {
+        return;
+    }
+    try {
+        await pendingBrowserSessionShutdown;
+    }
+    catch {
+        // Ignore teardown failures here. A follow-up launch attempt can surface the next actionable error.
+    }
+}
+async function closeBrowserSession(session, options = {}) {
+    if (session.shutdownPromise) {
+        return await session.shutdownPromise;
+    }
+    const { externalReason = null, clearActive = true } = options;
+    session.disconnecting = true;
+    const shutdownPromise = (async () => {
+        try {
+            await session.context.close();
+        }
+        catch (error) {
+            if (!isBenignCloseError(error)) {
+                throw error;
+            }
+        }
+        finally {
+            if (clearActive && isCurrentSession(session)) {
+                clearActiveBrowserSession();
+            }
+            await cleanupClosedSession(session);
+        }
+        if (externalReason && !session.externalDisconnectNotified && typeof session.onDisconnected === "function") {
+            session.externalDisconnectNotified = true;
+            await session.onDisconnected({
+                sessionId: session.sessionId,
+                browserName: session.installedBrowser?.browserName || "Browser",
+                browserFamily: session.installedBrowser?.browserFamily || null,
+                reason: externalReason,
+            });
+        }
+    })();
+    session.shutdownPromise = shutdownPromise;
+    pendingBrowserSessionShutdown = shutdownPromise.finally(() => {
+        if (pendingBrowserSessionShutdown === session.shutdownPromise) {
+            pendingBrowserSessionShutdown = null;
+        }
+    });
+    return await session.shutdownPromise;
+}
+function handleExternalSessionClosed(session, reason) {
+    if (session.disconnecting) {
+        return;
+    }
+    void closeBrowserSession(session, {
+        externalReason: reason,
+        clearActive: true,
+    });
+}
+async function launchPersistentContextWithRetry(chromium, userDataDir, launchOptions, sessionMode) {
+    try {
+        return await chromium.launchPersistentContext(userDataDir, launchOptions);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const isProfileLockError = sessionMode === "persistent" && message.includes("ProcessSingleton");
+        if (!isProfileLockError) {
+            throw error;
+        }
+        await waitForPendingBrowserSessionShutdown();
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        return await chromium.launchPersistentContext(userDataDir, launchOptions);
+    }
+}
 function buildSessionBrowserInfo(url, installedBrowser) {
     const currentUrl = normalizeKnownPageUrl(url);
     const browserInfo = {
@@ -52,6 +184,7 @@ function normalizeConnectOptions(targetOrOptions) {
         url: normalizeOptionalAutomationUrl(options.url),
         headless: options.headless === true,
         sessionMode: options.sessionMode === "persistent" ? "persistent" : "fresh",
+        onDisconnected: typeof options.onDisconnected === "function" ? options.onDisconnected : null,
         persistentProfileDir: typeof options.persistentProfileDir === "string" && options.persistentProfileDir.trim().length > 0
             ? path.resolve(options.persistentProfileDir)
             : null,
@@ -104,6 +237,7 @@ export async function connectToBrowser(targetOrOptions) {
     const options = normalizeConnectOptions(targetOrOptions);
     const installedBrowser = await resolveInstalledBrowserForLaunch();
     const chromium = await loadChromium();
+    await waitForPendingBrowserSessionShutdown();
     try {
         getActiveBrowserSession();
         await disconnect();
@@ -112,16 +246,20 @@ export async function connectToBrowser(targetOrOptions) {
         // no active session to close
     }
     const { userDataDir, cleanupOnDisconnect } = await buildUserDataDir(options);
-    const context = await chromium.launchPersistentContext(userDataDir, {
+    const launchOptions = {
         executablePath: installedBrowser.executablePath,
         headless: options.headless,
         viewport: DEFAULT_VIEWPORT,
         screen: DEFAULT_VIEWPORT,
         acceptDownloads: false,
-    });
+    };
+    const context = await launchPersistentContextWithRetry(chromium, userDataDir, launchOptions, options.sessionMode);
     const primaryPage = context.pages()[0] ?? (await context.newPage());
     const sessionId = `browser-${randomUUID()}`;
     const normalizedUrl = options.url;
+    const welcomePageUrl = await getWelcomePageUrl();
+    const initialUrl = normalizedUrl || welcomePageUrl;
+    await closeExtraPages(context, primaryPage);
     context.on("page", (page) => {
         if (page === primaryPage) {
             return;
@@ -132,18 +270,28 @@ export async function connectToBrowser(targetOrOptions) {
             url: page.url() || null,
         });
     });
-    if (normalizedUrl) {
-        await primaryPage.goto(normalizedUrl, { waitUntil: "load" });
-    }
-    setActiveBrowserSession({
+    await gotoWithTimeoutTolerance(primaryPage, initialUrl);
+    const session = {
         sessionId,
         context,
         page: primaryPage,
         url: normalizedUrl,
+        welcomePageUrl,
         sessionMode: options.sessionMode,
         userDataDir,
         cleanupOnDisconnect,
         installedBrowser,
+        onDisconnected: options.onDisconnected,
+        disconnecting: false,
+        externalDisconnectNotified: false,
+        shutdownPromise: null,
+    };
+    setActiveBrowserSession(session);
+    primaryPage.on?.("close", () => {
+        handleExternalSessionClosed(session, "page_closed");
+    });
+    context.on?.("close", () => {
+        handleExternalSessionClosed(session, "context_closed");
     });
     emitDesktopDebug("browser.connect", "device", {}, {
         platform: "browser",
@@ -169,7 +317,7 @@ export async function getScreenshotAsBase64(browserSessionId) {
 export async function navigateToUrl(browserSessionId, url) {
     const session = getActiveBrowserSession(browserSessionId);
     const normalizedUrl = normalizeAutomationUrl(url);
-    await session.page.goto(normalizedUrl, { waitUntil: "load" });
+    await gotoWithTimeoutTolerance(session.page, normalizedUrl);
     session.url = normalizedUrl;
     emitDesktopDebug("browser.navigate", "device", { browserSessionId }, {
         platform: "browser",
@@ -183,13 +331,13 @@ export async function disconnect() {
         session = getActiveBrowserSession();
     }
     catch {
+        await waitForPendingBrowserSessionShutdown();
         return;
     }
     clearActiveBrowserSession();
-    await session.context.close();
-    if (session.cleanupOnDisconnect) {
-        await rm(session.userDataDir, { recursive: true, force: true });
-    }
+    await closeBrowserSession(session, {
+        clearActive: false,
+    });
 }
 export function __setBrowserConnectionTestHooks(hooks = null) {
     browserConnectionTestHooks = hooks;