@loadmill/droid-cua 2.7.0 → 2.9.0

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

@@ -0,0 +1,199 @@
+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 { 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,
+    });
+}
+export async function handleModelAction(browserSessionId, action, scale = 1, context = null) {
+    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    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: typeof action?.text === "string" ? truncateForDebug(action.text, 300) : undefined,
+            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: `Typing text: ${text}`, ...buildMeta(context, 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;
+            }
+            default:
+                addOutput({ type: "info", text: `Unknown action: ${JSON.stringify(action)}` });
+        }
+    }
+    catch (error) {
+        logger.error("Action execution error", {
+            action,
+            message: error.message,
+            stack: 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: error.message,
+        });
+        addOutput({
+            type: "error",
+            text: `Error executing action: ${error.message}`,
+            eventType: "error",
+            actionType: action?.type,
+            runId: context?.runId,
+            stepId: context?.stepId,
+            instructionIndex: context?.instructionIndex,
+            payload: {
+                message: error.message,
+                platform: "browser",
+            },
+        });
+        addOutput({ type: "info", text: "Full error details have been logged to the debug log." });
+    }
+}

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

@@ -0,0 +1,207 @@
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+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";
+const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
+let browserConnectionTestHooks = 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") {
+        return null;
+    }
+    try {
+        return normalizeOptionalAutomationUrl(url);
+    }
+    catch {
+        return null;
+    }
+}
+function buildSessionBrowserInfo(url, installedBrowser) {
+    const currentUrl = normalizeKnownPageUrl(url);
+    const browserInfo = {
+        viewportWidth: DEFAULT_VIEWPORT.width,
+        viewportHeight: DEFAULT_VIEWPORT.height,
+        scaledWidth: DEFAULT_VIEWPORT.width,
+        scaledHeight: DEFAULT_VIEWPORT.height,
+        scale: 1,
+        platform: "browser",
+        browserName: installedBrowser?.browserName || "Browser",
+        browserFamily: installedBrowser?.browserFamily || null,
+        model: installedBrowser?.browserName || "Browser",
+    };
+    if (currentUrl) {
+        browserInfo.currentUrl = currentUrl;
+    }
+    return browserInfo;
+}
+function normalizeConnectOptions(targetOrOptions) {
+    if (typeof targetOrOptions === "string") {
+        return {
+            url: normalizeOptionalAutomationUrl(targetOrOptions),
+            headless: false,
+            sessionMode: "fresh",
+            persistentProfileDir: null,
+            freshProfileDir: null,
+        };
+    }
+    const options = targetOrOptions && typeof targetOrOptions === "object" ? targetOrOptions : {};
+    return {
+        url: normalizeOptionalAutomationUrl(options.url),
+        headless: options.headless === true,
+        sessionMode: options.sessionMode === "persistent" ? "persistent" : "fresh",
+        persistentProfileDir: typeof options.persistentProfileDir === "string" && options.persistentProfileDir.trim().length > 0
+            ? path.resolve(options.persistentProfileDir)
+            : null,
+        freshProfileDir: typeof options.freshProfileDir === "string" && options.freshProfileDir.trim().length > 0
+            ? path.resolve(options.freshProfileDir)
+            : null,
+    };
+}
+async function buildUserDataDir(options) {
+    if (options.sessionMode === "persistent") {
+        if (!options.persistentProfileDir) {
+            throw new Error("Persistent browser sessions require a profile directory.");
+        }
+        return {
+            userDataDir: options.persistentProfileDir,
+            cleanupOnDisconnect: false,
+        };
+    }
+    if (options.freshProfileDir) {
+        return {
+            userDataDir: options.freshProfileDir,
+            cleanupOnDisconnect: true,
+        };
+    }
+    return {
+        userDataDir: await mkdtemp(path.join(os.tmpdir(), "droid-cua-browser-profile-")),
+        cleanupOnDisconnect: true,
+    };
+}
+async function loadChromium() {
+    if (typeof browserConnectionTestHooks?.loadChromium === "function") {
+        return await browserConnectionTestHooks.loadChromium();
+    }
+    try {
+        const playwright = await import("playwright-core");
+        return playwright.chromium;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "playwright-core is unavailable";
+        throw new Error(`Browser automation requires the optional playwright-core dependency. Install project dependencies and try again. (${message})`);
+    }
+}
+async function resolveInstalledBrowserForLaunch() {
+    if (typeof browserConnectionTestHooks?.resolveInstalledBrowser === "function") {
+        return await browserConnectionTestHooks.resolveInstalledBrowser();
+    }
+    return await requireInstalledBrowser();
+}
+export async function connectToBrowser(targetOrOptions) {
+    const options = normalizeConnectOptions(targetOrOptions);
+    const installedBrowser = await resolveInstalledBrowserForLaunch();
+    const chromium = await loadChromium();
+    try {
+        getActiveBrowserSession();
+        await disconnect();
+    }
+    catch {
+        // no active session to close
+    }
+    const { userDataDir, cleanupOnDisconnect } = await buildUserDataDir(options);
+    const context = await chromium.launchPersistentContext(userDataDir, {
+        executablePath: installedBrowser.executablePath,
+        headless: options.headless,
+        viewport: DEFAULT_VIEWPORT,
+        screen: DEFAULT_VIEWPORT,
+        acceptDownloads: false,
+    });
+    const primaryPage = context.pages()[0] ?? (await context.newPage());
+    const sessionId = `browser-${randomUUID()}`;
+    const normalizedUrl = options.url;
+    context.on("page", (page) => {
+        if (page === primaryPage) {
+            return;
+        }
+        console.warn("New tab or popup opened. Automation will remain attached to the original page only.");
+        emitDesktopDebug("browser.popup", "device", { sessionId }, {
+            stage: "opened",
+            url: page.url() || null,
+        });
+    });
+    if (normalizedUrl) {
+        await gotoWithTimeoutTolerance(primaryPage, normalizedUrl);
+    }
+    setActiveBrowserSession({
+        sessionId,
+        context,
+        page: primaryPage,
+        url: normalizedUrl,
+        sessionMode: options.sessionMode,
+        userDataDir,
+        cleanupOnDisconnect,
+        installedBrowser,
+    });
+    emitDesktopDebug("browser.connect", "device", {}, {
+        platform: "browser",
+        stage: "success",
+        browserSessionId: sessionId,
+        browserFamily: installedBrowser.browserFamily,
+        browserName: installedBrowser.browserName,
+        url: normalizedUrl ?? undefined,
+        sessionMode: options.sessionMode,
+    });
+    return sessionId;
+}
+export async function getBrowserInfo(browserSessionId) {
+    const session = getActiveBrowserSession(browserSessionId);
+    const currentUrl = normalizeKnownPageUrl(session.page.url()) || session.url || null;
+    return buildSessionBrowserInfo(currentUrl, session.installedBrowser);
+}
+export async function getScreenshotAsBase64(browserSessionId) {
+    const session = getActiveBrowserSession(browserSessionId);
+    const imageBuffer = await session.page.screenshot({ type: "png" });
+    return imageBuffer.toString("base64");
+}
+export async function navigateToUrl(browserSessionId, url) {
+    const session = getActiveBrowserSession(browserSessionId);
+    const normalizedUrl = normalizeAutomationUrl(url);
+    await gotoWithTimeoutTolerance(session.page, normalizedUrl);
+    session.url = normalizedUrl;
+    emitDesktopDebug("browser.navigate", "device", { browserSessionId }, {
+        platform: "browser",
+        url: normalizedUrl,
+    });
+    return normalizedUrl;
+}
+export async function disconnect() {
+    let session;
+    try {
+        session = getActiveBrowserSession();
+    }
+    catch {
+        return;
+    }
+    clearActiveBrowserSession();
+    await session.context.close();
+    if (session.cleanupOnDisconnect) {
+        await rm(session.userDataDir, { recursive: true, force: true });
+    }
+}
+export function __setBrowserConnectionTestHooks(hooks = null) {
+    browserConnectionTestHooks = hooks;
+}

package/build/src/browser/playwright/installed-browser.js

@@ -0,0 +1,131 @@
+import os from "node:os";
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+export const CHROME_INSTALL_URL = "https://www.google.com/chrome/";
+export const EDGE_INSTALL_URL = "https://www.microsoft.com/edge/download";
+function readEnvValue(env, ...keys) {
+    for (const key of keys) {
+        const value = env?.[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function normalizeWindowsBaseDirs(env, homeDir) {
+    const programFiles = readEnvValue(env, "PROGRAMFILES", "ProgramFiles") || "C:\\Program Files";
+    const programFilesX86 = readEnvValue(env, "PROGRAMFILES(X86)") || "C:\\Program Files (x86)";
+    const localAppData = readEnvValue(env, "LOCALAPPDATA")
+        || (homeDir ? path.join(homeDir, "AppData", "Local") : null)
+        || "C:\\Users\\Default\\AppData\\Local";
+    return { programFiles, programFilesX86, localAppData };
+}
+function uniquePaths(paths = []) {
+    return [...new Set(paths.filter((value) => typeof value === "string" && value.trim().length > 0))];
+}
+export function listInstalledBrowserCandidates({ platform = process.platform, env = process.env, homeDir = os.homedir(), } = {}) {
+    if (platform === "darwin") {
+        const appRoots = uniquePaths([
+            "/Applications",
+            homeDir ? path.join(homeDir, "Applications") : null,
+        ]);
+        return [
+            {
+                browserFamily: "chrome",
+                browserName: "Google Chrome",
+                candidates: appRoots.map((root) => path.join(root, "Google Chrome.app", "Contents", "MacOS", "Google Chrome")),
+            },
+            {
+                browserFamily: "edge",
+                browserName: "Microsoft Edge",
+                candidates: appRoots.map((root) => path.join(root, "Microsoft Edge.app", "Contents", "MacOS", "Microsoft Edge")),
+            },
+        ];
+    }
+    if (platform === "win32") {
+        const { programFiles, programFilesX86, localAppData } = normalizeWindowsBaseDirs(env, homeDir);
+        return [
+            {
+                browserFamily: "chrome",
+                browserName: "Google Chrome",
+                candidates: uniquePaths([
+                    path.win32.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+                    path.win32.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+                    path.win32.join(localAppData, "Google", "Chrome", "Application", "chrome.exe"),
+                ]),
+            },
+            {
+                browserFamily: "edge",
+                browserName: "Microsoft Edge",
+                candidates: uniquePaths([
+                    path.win32.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+                    path.win32.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"),
+                    path.win32.join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe"),
+                ]),
+            },
+        ];
+    }
+    return [];
+}
+async function pathExistsAndIsRunnable(filePath, platform, accessFn) {
+    const accessMode = platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK;
+    try {
+        await accessFn(filePath, accessMode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildMissingBrowserMessage(platform) {
+    if (platform !== "darwin" && platform !== "win32") {
+        return "Installed browser detection is currently supported only on macOS and Windows. Install Google Chrome or Microsoft Edge on a supported machine.";
+    }
+    return `No supported browser was found. Install Google Chrome or Microsoft Edge and try again. Chrome: ${CHROME_INSTALL_URL} Edge: ${EDGE_INSTALL_URL}`;
+}
+export async function resolveInstalledBrowser({ platform = process.platform, env = process.env, homeDir = os.homedir(), accessFn = access, } = {}) {
+    const browserGroups = listInstalledBrowserCandidates({ platform, env, homeDir });
+    for (const browser of browserGroups) {
+        for (const executablePath of browser.candidates) {
+            if (await pathExistsAndIsRunnable(executablePath, platform, accessFn)) {
+                return {
+                    browserFamily: browser.browserFamily,
+                    browserName: browser.browserName,
+                    executablePath,
+                };
+            }
+        }
+    }
+    return null;
+}
+export async function getInstalledBrowserAvailability(options = {}) {
+    const resolved = await resolveInstalledBrowser(options);
+    if (!resolved) {
+        return {
+            available: false,
+            browserFamily: null,
+            browserName: null,
+            executablePath: null,
+            message: buildMissingBrowserMessage(options.platform ?? process.platform),
+        };
+    }
+    return {
+        available: true,
+        browserFamily: resolved.browserFamily,
+        browserName: resolved.browserName,
+        executablePath: resolved.executablePath,
+        message: null,
+    };
+}
+export async function requireInstalledBrowser(options = {}) {
+    const availability = await getInstalledBrowserAvailability(options);
+    if (!availability.available || !availability.browserName || !availability.executablePath) {
+        throw new Error(availability.message || buildMissingBrowserMessage(options.platform ?? process.platform));
+    }
+    return {
+        browserFamily: availability.browserFamily,
+        browserName: availability.browserName,
+        executablePath: availability.executablePath,
+    };
+}

package/build/src/browser/playwright/session-state.js

@@ -0,0 +1,19 @@
+let activeSession = null;
+export function setActiveBrowserSession(session) {
+    activeSession = session;
+}
+export function clearActiveBrowserSession() {
+    activeSession = null;
+}
+export function getActiveBrowserSession(browserSessionId = null) {
+    if (!activeSession) {
+        throw new Error("Not connected to a browser session. Call connectToBrowser first.");
+    }
+    if (browserSessionId && activeSession.sessionId !== browserSessionId) {
+        throw new Error("Requested browser session is no longer active.");
+    }
+    return activeSession;
+}
+export function getActiveBrowserPage(browserSessionId = null) {
+    return getActiveBrowserSession(browserSessionId).page;
+}

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

@@ -0,0 +1,79 @@
+const HTTP_SCHEME_RE = /^https?:\/\//i;
+const SCHEME_RE = /^[a-z][a-z\d+\-.]*:\/\//i;
+const LOCAL_HOST_RE = /^(localhost|127\.0\.0\.1)(:\d+)?$/i;
+const EXPLICIT_PORT_RE = /^[^/]+:\d+$/;
+const URL_ERROR_MESSAGE = "Browser URL must be a valid host or http:// / https:// URL.";
+function hasUnsupportedBareScheme(rawValue) {
+    if (rawValue.includes("://")) {
+        return false;
+    }
+    const authority = rawValue.split(/[/?#]/, 1)[0]?.trim() || "";
+    const colonIndex = authority.indexOf(":");
+    if (colonIndex <= 0 || LOCAL_HOST_RE.test(authority) || EXPLICIT_PORT_RE.test(authority)) {
+        return false;
+    }
+    const prefix = authority.slice(0, colonIndex);
+    const suffix = authority.slice(colonIndex + 1);
+    return /^[a-z][a-z\d+\-.]*$/i.test(prefix) && !prefix.includes(".") && !/^\d+$/.test(suffix);
+}
+function inferDefaultScheme(rawValue) {
+    const authority = rawValue.split(/[/?#]/, 1)[0]?.trim() || "";
+    if (LOCAL_HOST_RE.test(authority) || EXPLICIT_PORT_RE.test(authority)) {
+        return "http://";
+    }
+    return "https://";
+}
+function parseUrlCandidate(rawValue) {
+    if (rawValue == null) {
+        return null;
+    }
+    if (typeof rawValue !== "string") {
+        throw new Error("Browser URL must be a string.");
+    }
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (hasUnsupportedBareScheme(trimmed)) {
+        throw new Error("Browser URL must use http:// or https://.");
+    }
+    if (SCHEME_RE.test(trimmed) && !HTTP_SCHEME_RE.test(trimmed)) {
+        throw new Error("Browser URL must use http:// or https://.");
+    }
+    const candidate = HTTP_SCHEME_RE.test(trimmed)
+        ? trimmed
+        : `${inferDefaultScheme(trimmed)}${trimmed}`;
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(candidate);
+    }
+    catch {
+        throw new Error(URL_ERROR_MESSAGE);
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        throw new Error("Browser URL must use http:// or https://.");
+    }
+    if (!parsedUrl.hostname) {
+        throw new Error(URL_ERROR_MESSAGE);
+    }
+    return parsedUrl;
+}
+export function normalizeOptionalAutomationUrl(rawValue) {
+    const parsedUrl = parseUrlCandidate(rawValue);
+    return parsedUrl ? parsedUrl.toString() : null;
+}
+export function normalizeAutomationUrl(rawValue) {
+    const normalizedUrl = normalizeOptionalAutomationUrl(rawValue);
+    if (!normalizedUrl) {
+        throw new Error("Browser URL is required.");
+    }
+    return normalizedUrl;
+}
+export function formatAutomationDisplayName(rawUrl) {
+    const normalizedUrl = normalizeOptionalAutomationUrl(rawUrl);
+    if (!normalizedUrl) {
+        return "Browser";
+    }
+    const parsedUrl = new URL(normalizedUrl);
+    return parsedUrl.host || parsedUrl.origin || normalizedUrl;
+}