@loadmill/droid-cua 2.29.0 → 2.30.0

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

@@ -1,272 +1,6 @@
-import { logger } from "../../utils/logger.js";
-import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
-import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
-import { buildActionEventMeta } from "../../device/action-event-meta.js";
-import { actionForErrorLog, buildActionErrorOutput, buildDebugTextField, buildSensitiveDebugFields, buildTypeActionPayload, buildTypeActionText, isSensitiveAction, } from "../../device/sensitive-action.js";
-import { normalizeAutomationUrl } from "./url.js";
+import { createGestureDispatch } from "../gesture-dispatch.js";
 import { getActiveBrowserSession, getActiveBrowserPage } from "./session-state.js";
-const KEY_ALIASES = {
-    CTRL: "Control",
-    CONTROL: "Control",
-    CMD: "Meta",
-    COMMAND: "Meta",
-    META: "Meta",
-    ALT: "Alt",
-    OPTION: "Alt",
-    SHIFT: "Shift",
-    ENTER: "Enter",
-    RETURN: "Enter",
-    ESC: "Escape",
-    ESCAPE: "Escape",
-    BACKSPACE: "Backspace",
-    DELETE: "Delete",
-    TAB: "Tab",
-    SPACE: "Space",
-    HOME: "Home",
-    END: "End",
-    PAGEUP: "PageUp",
-    PAGEDOWN: "PageDown",
-    ARROWUP: "ArrowUp",
-    ARROWDOWN: "ArrowDown",
-    ARROWLEFT: "ArrowLeft",
-    ARROWRIGHT: "ArrowRight",
-};
-function normalizeKeyEntry(key) {
-    const raw = String(key ?? "").trim();
-    if (!raw) {
-        throw new Error("Keypress action is missing keys.");
-    }
-    const normalized = KEY_ALIASES[raw.toUpperCase()];
-    if (normalized) {
-        return normalized;
-    }
-    if (raw.length === 1) {
-        return raw;
-    }
-    return raw[0].toUpperCase() + raw.slice(1);
-}
-function normalizeShortcut(keys = []) {
-    if (!Array.isArray(keys) || keys.length === 0) {
-        throw new Error("Keypress action is missing keys.");
-    }
-    return keys.map(normalizeKeyEntry).join("+");
-}
-function buildMeta(context, action, payload = {}) {
-    return buildActionEventMeta({
-        context,
-        action,
-        platform: "browser",
-        payload,
-    });
-}
-function handleNavigationTimeout(error, description) {
-    if (!(error instanceof Error) || error.name !== "TimeoutError") {
-        throw error;
-    }
-    console.warn(`Page load did not finish within the timeout for ${description}. Continuing with the current page state.`);
-}
-async function gotoWithTimeoutTolerance(page, url) {
-    try {
-        await page.goto(url, { waitUntil: "load" });
-    }
-    catch (error) {
-        handleNavigationTimeout(error, url);
-    }
-}
-async function goBackWithTimeoutTolerance(page) {
-    try {
-        await page.goBack({ waitUntil: "load" });
-    }
-    catch (error) {
-        handleNavigationTimeout(error, "browser history back");
-    }
-}
-async function goForwardWithTimeoutTolerance(page) {
-    try {
-        await page.goForward({ waitUntil: "load" });
-    }
-    catch (error) {
-        handleNavigationTimeout(error, "browser history forward");
-    }
-}
-function updateSessionUrlFromPage(session, page) {
-    const currentUrl = typeof page.url === "function" ? page.url() : null;
-    if (!currentUrl) {
-        return;
-    }
-    session.pageUrls?.set?.(page, currentUrl);
-    session.url = currentUrl;
-}
-export async function handleModelAction(browserSessionId, action, scale = 1, context = null) {
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
-    const session = getActiveBrowserSession(browserSessionId);
-    const page = getActiveBrowserPage(browserSessionId);
-    try {
-        emitDesktopDebug("browser.action.execute", "device", {
-            runId: context?.runId,
-            sessionId: context?.sessionId,
-            stepId: context?.stepId,
-            instructionIndex: context?.instructionIndex,
-        }, {
-            platform: "browser",
-            browserSessionId,
-            actionType: action?.type,
-            scale,
-            x: action?.x,
-            y: action?.y,
-            x1: action?.x1,
-            y1: action?.y1,
-            x2: action?.x2,
-            y2: action?.y2,
-            text: buildDebugTextField(action, truncateForDebug),
-            ...buildSensitiveDebugFields(action),
-            keyCount: Array.isArray(action?.keys) ? action.keys.length : 0,
-            pathPoints: Array.isArray(action?.path) ? action.path.length : 0,
-        });
-        switch (action.type) {
-            case "click": {
-                const x = Math.round(action.x / scale);
-                const y = Math.round(action.y / scale);
-                addOutput({ type: "action", text: "Click", ...buildMeta(context, action, { x, y, unit: "px" }) });
-                await page.mouse.click(x, y);
-                break;
-            }
-            case "double_click": {
-                const x = Math.round(action.x / scale);
-                const y = Math.round(action.y / scale);
-                addOutput({ type: "action", text: `Double-clicking at (${x}, ${y})`, ...buildMeta(context, action, { x, y, unit: "px" }) });
-                await page.mouse.dblclick(x, y);
-                break;
-            }
-            case "move": {
-                const x = Math.round(action.x / scale);
-                const y = Math.round(action.y / scale);
-                addOutput({ type: "action", text: `Moving mouse to (${x}, ${y})`, ...buildMeta(context, action, { x, y, unit: "px" }) });
-                await page.mouse.move(x, y);
-                break;
-            }
-            case "scroll": {
-                const scrollX = Math.round((action.scroll_x ?? 0) / scale);
-                const scrollY = Math.round((action.scroll_y ?? 0) / scale);
-                addOutput({
-                    type: "action",
-                    text: `Scrolling by (${scrollX}, ${scrollY})`,
-                    ...buildMeta(context, action, { scrollX, scrollY, unit: "px" }),
-                });
-                await page.mouse.wheel(scrollX, scrollY);
-                break;
-            }
-            case "drag": {
-                const dragPath = Array.isArray(action.path) ? action.path : [];
-                if (dragPath.length < 2) {
-                    throw new Error("Drag action requires a path with at least two points.");
-                }
-                const [start] = dragPath;
-                const end = dragPath[dragPath.length - 1];
-                const scaledStart = { x: Math.round(start.x / scale), y: Math.round(start.y / scale) };
-                const scaledEnd = { x: Math.round(end.x / scale), y: Math.round(end.y / scale) };
-                addOutput({
-                    type: "action",
-                    text: `Dragging from (${scaledStart.x}, ${scaledStart.y}) to (${scaledEnd.x}, ${scaledEnd.y})`,
-                    ...buildMeta(context, action, { pathStart: scaledStart, pathEnd: scaledEnd, unit: "px" }),
-                });
-                await page.mouse.move(scaledStart.x, scaledStart.y);
-                await page.mouse.down();
-                for (const point of dragPath.slice(1)) {
-                    await page.mouse.move(Math.round(point.x / scale), Math.round(point.y / scale));
-                }
-                await page.mouse.up();
-                break;
-            }
-            case "type": {
-                const text = typeof action.text === "string" ? action.text : "";
-                addOutput({
-                    type: "action",
-                    text: buildTypeActionText(action, text),
-                    ...buildMeta(context, action, buildTypeActionPayload(action, text))
-                });
-                await page.keyboard.type(text);
-                break;
-            }
-            case "keypress": {
-                const shortcut = normalizeShortcut(action.keys);
-                addOutput({
-                    type: "action",
-                    text: `Pressing key: ${shortcut}`,
-                    ...buildMeta(context, action, { keys: action.keys, shortcut }),
-                });
-                await page.keyboard.press(shortcut);
-                break;
-            }
-            case "wait": {
-                addOutput({ type: "action", text: "Waiting...", ...buildMeta(context, action) });
-                const timeoutMs = typeof action.ms === "number" && Number.isFinite(action.ms) && action.ms >= 0
-                    ? Math.round(action.ms)
-                    : getConfiguredStepDelayMs();
-                await page.waitForTimeout(timeoutMs);
-                break;
-            }
-            case "goto": {
-                const normalizedUrl = normalizeAutomationUrl(action.url);
-                addOutput({
-                    type: "action",
-                    text: `Navigating to ${normalizedUrl}`,
-                    ...buildMeta(context, action, { url: normalizedUrl }),
-                });
-                await gotoWithTimeoutTolerance(page, normalizedUrl);
-                session.pageUrls?.set?.(page, normalizedUrl);
-                session.url = normalizedUrl;
-                break;
-            }
-            case "back": {
-                addOutput({ type: "action", text: "Going back", ...buildMeta(context, action) });
-                await goBackWithTimeoutTolerance(page);
-                updateSessionUrlFromPage(session, page);
-                break;
-            }
-            case "forward": {
-                addOutput({ type: "action", text: "Going forward", ...buildMeta(context, action) });
-                await goForwardWithTimeoutTolerance(page);
-                updateSessionUrlFromPage(session, page);
-                break;
-            }
-            default:
-                addOutput({ type: "info", text: `Unknown action: ${JSON.stringify(action)}` });
-        }
-        return { success: true };
-    }
-    catch (error) {
-        const outputError = buildActionErrorOutput(action, error);
-        logger.error("Action execution error", {
-            action: actionForErrorLog(action),
-            message: outputError.message,
-            stack: isSensitiveAction(action) ? undefined : error.stack,
-        });
-        emitDesktopDebug("browser.error", "device", {
-            runId: context?.runId,
-            sessionId: context?.sessionId,
-            stepId: context?.stepId,
-            instructionIndex: context?.instructionIndex,
-        }, {
-            platform: "browser",
-            operation: "action.execute",
-            actionType: action?.type,
-            message: outputError.message,
-        });
-        addOutput({
-            type: "error",
-            text: outputError.text,
-            eventType: "error",
-            actionType: action?.type,
-            runId: context?.runId,
-            stepId: context?.stepId,
-            instructionIndex: context?.instructionIndex,
-            payload: {
-                message: outputError.message,
-                platform: "browser",
-            },
-        });
-        addOutput({ type: "info", text: "Full error details have been logged to the debug log." });
-        return { success: false, error: outputError.message };
-    }
-}
+export const handleModelAction = createGestureDispatch({
+    getSession: getActiveBrowserSession,
+    getPage: getActiveBrowserPage,
+});

package/build/src/browser/webdriver/actions.js

@@ -0,0 +1,10 @@
+import { createGestureDispatch } from "../gesture-dispatch.js";
+import { getActiveWebDriverPage, getActiveWebDriverSession, reportRunningOnFirstUse, } from "./session-state.js";
+const dispatchModelAction = createGestureDispatch({
+    getSession: getActiveWebDriverSession,
+    getPage: getActiveWebDriverPage,
+});
+export async function handleModelAction(browserSessionId, action, scale = 1, context = null) {
+    reportRunningOnFirstUse(browserSessionId);
+    return dispatchModelAction(browserSessionId, action, scale, context);
+}

package/build/src/browser/webdriver/client.js

@@ -0,0 +1,83 @@
+/**
+ * Thin fetch wrapper over an already-attached W3C WebDriver session. The
+ * backend built on this client never issues `POST /session` or
+ * `DELETE /session/:id` — it only ever drives a session the Loadmill grid
+ * already created.
+ */
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export class WebDriverClient {
+    constructor({ url, sessionId, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS }) {
+        this.url = url;
+        this.sessionId = sessionId;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    async request(method, path, body = null) {
+        let response;
+        try {
+            response = await fetch(`${this.url}${path}`, {
+                method,
+                headers: body !== null ? { "Content-Type": "application/json" } : {},
+                body: body !== null ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(this.requestTimeoutMs),
+            });
+        }
+        catch (error) {
+            if (error?.name === "AbortError" || error?.name === "TimeoutError") {
+                throw new Error(`WebDriver request to session ${this.sessionId} timed out after ${this.requestTimeoutMs}ms; the grid is not responding.`);
+            }
+            throw error;
+        }
+        const text = await response.text();
+        const payload = text ? JSON.parse(text) : {};
+        if (!response.ok) {
+            const message = payload?.value?.message ||
+                payload?.message ||
+                `WebDriver request failed with status ${response.status}.`;
+            throw new Error(message);
+        }
+        return payload;
+    }
+    async navigateTo(url) {
+        await this.request("POST", `/session/${this.sessionId}/url`, { url });
+    }
+    async goBack() {
+        await this.request("POST", `/session/${this.sessionId}/back`, {});
+    }
+    async goForward() {
+        await this.request("POST", `/session/${this.sessionId}/forward`, {});
+    }
+    async getScreenshot() {
+        const response = await this.request("GET", `/session/${this.sessionId}/screenshot`);
+        return response.value;
+    }
+    async setWindowRect({ width, height }) {
+        await this.request("POST", `/session/${this.sessionId}/window/rect`, {
+            x: 0,
+            y: 0,
+            width,
+            height,
+        });
+    }
+    async getWindowHandle() {
+        const response = await this.request("GET", `/session/${this.sessionId}/window`);
+        return response.value;
+    }
+    async getWindowHandles() {
+        const response = await this.request("GET", `/session/${this.sessionId}/window/handles`);
+        return response.value;
+    }
+    async switchToWindow(handle) {
+        await this.request("POST", `/session/${this.sessionId}/window`, { handle });
+    }
+    async closeWindow() {
+        const response = await this.request("DELETE", `/session/${this.sessionId}/window`);
+        return response.value;
+    }
+    async performActions(actions) {
+        await this.request("POST", `/session/${this.sessionId}/actions`, { actions });
+    }
+    async executeScript(script, args = []) {
+        const response = await this.request("POST", `/session/${this.sessionId}/execute/sync`, { script, args });
+        return response.value;
+    }
+}

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

@@ -0,0 +1,300 @@
+import sharp from "sharp";
+import { normalizeAutomationUrl } from "../playwright/url.js";
+import { normalizeBrowserInfoForSession } from "../normalize.js";
+import { LoadmillCloudControlPlaneClient } from "../../device/cloud/loadmill-cloud/control-plane-client.js";
+import { fetchAndDownloadArtifacts } from "../../device/cloud/loadmill-cloud/adapter.js";
+import { ARTIFACT_READY_STATUSES, TERMINAL_STATUSES } from "../../device/cloud/loadmill-cloud/run-status.js";
+import { reportCloudPhase, reportCloudProgress } from "../../device/cloud/progress.js";
+import { emitDesktopDebug } from "../../utils/desktop-debug.js";
+import { WebDriverClient } from "./client.js";
+import { createWebDriverPageFacade } from "./page-facade.js";
+import { clearActiveWebDriverSession, getActiveWebDriverSession, reportRunningOnFirstUse, setActiveWebDriverSession, } from "./session-state.js";
+export { handleModelAction } from "./actions.js";
+const DEFAULT_VIEWPORT_WIDTH = 1440;
+const DEFAULT_VIEWPORT_HEIGHT = 900;
+const LOADMILL_CLOUD_VIEWPORT = { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT };
+const VIEWPORT_METRICS_SCRIPT = "return { innerWidth: window.innerWidth, innerHeight: window.innerHeight, devicePixelRatio: window.devicePixelRatio };";
+const SESSION_PROBE_SCRIPT = "return true;";
+const TEARDOWN_STOP_BUDGET_MS = 1_500;
+async function setCloudViewport(client) {
+    await client.setWindowRect(LOADMILL_CLOUD_VIEWPORT);
+    const metrics = await client.executeScript(VIEWPORT_METRICS_SCRIPT, []);
+    const viewportWidth = Number(metrics?.innerWidth) || LOADMILL_CLOUD_VIEWPORT.width;
+    const viewportHeight = Number(metrics?.innerHeight) || LOADMILL_CLOUD_VIEWPORT.height;
+    const adjustedWindowRect = {
+        width: LOADMILL_CLOUD_VIEWPORT.width + (LOADMILL_CLOUD_VIEWPORT.width - viewportWidth),
+        height: LOADMILL_CLOUD_VIEWPORT.height + (LOADMILL_CLOUD_VIEWPORT.height - viewportHeight),
+    };
+    if (adjustedWindowRect.width !== LOADMILL_CLOUD_VIEWPORT.width ||
+        adjustedWindowRect.height !== LOADMILL_CLOUD_VIEWPORT.height) {
+        await client.setWindowRect(adjustedWindowRect);
+    }
+}
+async function attachWebDriverSession({ webdriverEndpoint, webdriverSessionId, cloud = null }) {
+    const client = new WebDriverClient({ url: webdriverEndpoint, sessionId: webdriverSessionId });
+    if (cloud) {
+        await setCloudViewport(client);
+    }
+    const windowHandle = await client.getWindowHandle();
+    const page = createWebDriverPageFacade({ client });
+    const session = {
+        sessionId: webdriverSessionId,
+        client,
+        page,
+        pageUrls: new Map(),
+        url: null,
+        cloud,
+        windowStack: [windowHandle],
+        activeWindowHandle: windowHandle,
+    };
+    setActiveWebDriverSession(session);
+    return webdriverSessionId;
+}
+async function syncActiveWindow(session) {
+    const handles = await session.client.getWindowHandles();
+    const openHandles = new Set(handles);
+    session.windowStack = session.windowStack.filter((handle) => openHandles.has(handle));
+    const knownHandles = new Set(session.windowStack);
+    const newHandles = handles.filter((handle) => !knownHandles.has(handle));
+    session.windowStack.push(...newHandles);
+    const nextHandle = newHandles.at(-1) ?? (openHandles.has(session.activeWindowHandle) ? null : session.windowStack.at(-1));
+    if (nextHandle) {
+        await session.client.switchToWindow(nextHandle);
+        session.activeWindowHandle = nextHandle;
+    }
+}
+async function probeAttachedWebDriverSession({ webdriverEndpoint, webdriverSessionId }, cloudSessionId) {
+    const probeClient = new WebDriverClient({ url: webdriverEndpoint, sessionId: webdriverSessionId });
+    try {
+        await probeClient.executeScript(SESSION_PROBE_SCRIPT, []);
+    }
+    catch (error) {
+        throw new Error(`Loadmill Cloud web session expired: session ${cloudSessionId}'s attached browser is no longer reachable — ${error.message}`);
+    }
+}
+function formatQueueMessage(state) {
+    const parts = [];
+    if (typeof state.queuePosition === "number") {
+        parts.push(`queue position ${state.queuePosition}`);
+    }
+    if (typeof state.etaSeconds === "number") {
+        parts.push(`up to ${Math.max(1, Math.round(state.etaSeconds / 60))}m`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "waiting for a browser slot";
+}
+function waitForProvisionedWebDriverSession(client, sessionId, { signal } = {}) {
+    return new Promise((resolve, reject) => {
+        const watchAbort = new AbortController();
+        let lastStatus = null;
+        let settled = false;
+        const settle = (fn, value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            watchAbort.abort();
+            fn(value);
+        };
+        if (signal?.aborted) {
+            settle(reject, signal.reason ?? new Error("Provisioning cancelled."));
+            return;
+        }
+        signal?.addEventListener("abort", () => settle(reject, signal.reason ?? new Error("Provisioning cancelled.")), { once: true });
+        client
+            .watchRun(sessionId, (state) => {
+            if (!state || typeof state !== "object") {
+                return;
+            }
+            if (state.status && state.status !== lastStatus) {
+                lastStatus = state.status;
+                reportCloudPhase(state.status.toLowerCase());
+            }
+            if (state.status === "PENDING") {
+                reportCloudProgress(formatQueueMessage(state));
+            }
+            if (state.status === "PROVISIONED" && state.webdriverEndpoint) {
+                settle(resolve, {
+                    webdriverEndpoint: state.webdriverEndpoint,
+                    webdriverSessionId: state.webdriverSessionId,
+                });
+                return;
+            }
+            if (state.status === "ERROR") {
+                settle(reject, new Error(state.error?.message || "Loadmill Cloud web run failed while provisioning."));
+                return;
+            }
+            if (state.status === "CANCELLED") {
+                settle(reject, new Error("Loadmill Cloud web run was cancelled."));
+            }
+        }, { signal: watchAbort.signal })
+            .catch(() => { });
+    });
+}
+async function connectToBrowserViaLoadmillCloud({ credentials, browserFamily, browserVersion, cloudSessionId, artifacts, signal, }) {
+    const client = new LoadmillCloudControlPlaneClient({
+        bearerToken: credentials?.bearerToken,
+        baseUrl: credentials?.baseUrl,
+        pool: "web",
+    });
+    if (cloudSessionId) {
+        const state = await client.getRunState(cloudSessionId);
+        if (ARTIFACT_READY_STATUSES.has(state.status) && Array.isArray(artifacts) && artifacts.length > 0) {
+            await fetchAndDownloadArtifacts({ client, sessionId: cloudSessionId, kinds: artifacts });
+            const exitError = new Error("Loadmill Cloud artifact fetch complete.");
+            exitError.artifactsOnlyExit = true;
+            throw exitError;
+        }
+        if (TERMINAL_STATUSES.has(state.status)) {
+            throw new Error(`Loadmill Cloud web session ${cloudSessionId} is already terminal (${state.status}). ` +
+                `Fetch its recordings/logs instead with: droid-cua --target web --cloud-session-id ${cloudSessionId} --artifacts all`);
+        }
+        if (!state.webdriverEndpoint || !state.webdriverSessionId) {
+            throw new Error(`Loadmill Cloud web session ${cloudSessionId} is not yet ready to reconnect (status: ${state.status}).`);
+        }
+        await probeAttachedWebDriverSession(state, cloudSessionId);
+        if (state.status === "PROVISIONED") {
+            await client.reportStatus(cloudSessionId, "CONNECTED");
+        }
+        client.startHeartbeat(cloudSessionId);
+        try {
+            return await attachWebDriverSession({
+                webdriverEndpoint: state.webdriverEndpoint,
+                webdriverSessionId: state.webdriverSessionId,
+                cloud: { client, sessionId: cloudSessionId, runningReported: state.status === "RUNNING", artifacts },
+            });
+        }
+        catch (error) {
+            client.stopHeartbeat();
+            throw error;
+        }
+    }
+    reportCloudPhase("request browser");
+    const initState = await client.initRun({ platform: "web", deviceName: browserFamily, osVersion: browserVersion });
+    const sessionId = initState.sessionId;
+    // Server reaper kills runs that only heartbeat after CONNECTED, so start now.
+    client.startHeartbeat(sessionId);
+    try {
+        const { webdriverEndpoint, webdriverSessionId } = await waitForProvisionedWebDriverSession(client, sessionId, {
+            signal,
+        });
+        await client.reportStatus(sessionId, "CONNECTED");
+        return await attachWebDriverSession({
+            webdriverEndpoint,
+            webdriverSessionId,
+            cloud: { client, sessionId, runningReported: false, artifacts },
+        });
+    }
+    catch (error) {
+        client.stopHeartbeat();
+        await client.stopRun(sessionId, { signal: AbortSignal.timeout(TEARDOWN_STOP_BUDGET_MS) }).catch(() => { });
+        throw error;
+    }
+}
+export async function connectToBrowser(options = {}) {
+    if (options.source === "loadmill-cloud") {
+        return connectToBrowserViaLoadmillCloud(options);
+    }
+    const { url, sessionId } = options;
+    if (!url || !sessionId) {
+        throw new Error("Attaching to a WebDriver session requires a url and a sessionId.");
+    }
+    return attachWebDriverSession({ webdriverEndpoint: url, webdriverSessionId: sessionId, cloud: null });
+}
+export async function getBrowserInfo(browserSessionId) {
+    const session = getActiveWebDriverSession(browserSessionId);
+    reportRunningOnFirstUse(browserSessionId);
+    await syncActiveWindow(session);
+    const metrics = await session.client.executeScript(VIEWPORT_METRICS_SCRIPT, []);
+    const viewportWidth = Number(metrics?.innerWidth) || DEFAULT_VIEWPORT_WIDTH;
+    const viewportHeight = Number(metrics?.innerHeight) || DEFAULT_VIEWPORT_HEIGHT;
+    const devicePixelRatio = Number(metrics?.devicePixelRatio) || 1;
+    return normalizeBrowserInfoForSession({
+        viewportWidth,
+        viewportHeight,
+        scaledWidth: viewportWidth,
+        scaledHeight: viewportHeight,
+        scale: 1,
+        devicePixelRatio,
+        currentUrl: session.url,
+    });
+}
+export async function getScreenshotAsBase64(browserSessionId, browserInfo = {}) {
+    const session = getActiveWebDriverSession(browserSessionId);
+    const currentBrowserInfo = await getBrowserInfo(browserSessionId);
+    Object.assign(browserInfo, currentBrowserInfo);
+    const rawBase64 = await session.client.getScreenshot();
+    let buffer = Buffer.from(rawBase64, "base64");
+    if (currentBrowserInfo.scaledWidth && currentBrowserInfo.scaledHeight) {
+        buffer = await sharp(buffer)
+            .resize({
+            width: currentBrowserInfo.scaledWidth,
+            height: currentBrowserInfo.scaledHeight,
+            fit: "fill",
+        })
+            .png()
+            .toBuffer();
+    }
+    return buffer.toString("base64");
+}
+export async function navigateToUrl(browserSessionId, url) {
+    const session = getActiveWebDriverSession(browserSessionId);
+    reportRunningOnFirstUse(browserSessionId);
+    const normalizedUrl = normalizeAutomationUrl(url);
+    await session.page.goto(normalizedUrl, { waitUntil: "load" });
+    session.pageUrls.set(session.page, normalizedUrl);
+    session.url = normalizedUrl;
+    return normalizedUrl;
+}
+export async function closeCurrentTab(browserSessionId) {
+    const session = getActiveWebDriverSession(browserSessionId);
+    await syncActiveWindow(session);
+    if (session.windowStack.length <= 1) {
+        return {
+            closed: false,
+            restoredUrl: null,
+            message: "The primary browser tab cannot be closed.",
+        };
+    }
+    await session.client.closeWindow();
+    session.windowStack.pop();
+    session.activeWindowHandle = session.windowStack.at(-1);
+    await session.client.switchToWindow(session.activeWindowHandle);
+    const restoredUrl = await session.page.url();
+    session.url = restoredUrl;
+    const message = restoredUrl
+        ? `Closed current tab. Returned to ${restoredUrl}.`
+        : "Closed current tab. Returned to the previous browser tab.";
+    emitDesktopDebug("browser.tab.close_current", "device", { browserSessionId }, {
+        platform: "browser",
+        closed: true,
+        restoredUrl,
+        stackDepth: session.windowStack.length,
+    });
+    return {
+        closed: true,
+        restoredUrl,
+        message,
+    };
+}
+export async function disconnect() {
+    let session = null;
+    try {
+        session = getActiveWebDriverSession();
+    }
+    catch {
+        session = null;
+    }
+    clearActiveWebDriverSession();
+    if (session?.cloud) {
+        const { client, sessionId, artifacts } = session.cloud;
+        try {
+            await client.stopRun(sessionId);
+            if (Array.isArray(artifacts) && artifacts.length > 0) {
+                await fetchAndDownloadArtifacts({ client, sessionId, kinds: artifacts });
+            }
+        }
+        finally {
+            client.stopHeartbeat();
+        }
+    }
+}