@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

package/dist/worker/console/chat/browser-automation.js

@@ -1,363 +1,523 @@
 /**
- * Server-side implementation for the model-callable sidebar browser tools.
- *
- * Navigation is delivered to the visible BrowserPanel through a small pending
- * command queue. Page inspection uses the same http(s) URL loaded by that
- * panel and parses the server-visible HTML. Static GET forms are submitted as
- * real navigations; dynamic scripts and POST forms are intentionally refused.
+ * Workspace-scoped Playwright browser used by both Operator Chat tools and
+ * the Browser panel. The browser profile lives outside the repository and is
+ * reused across Console restarts, so login state and downloads remain
+ * isolated from the user's normal browser without contaminating the repo.
  */
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { chromium, } from "playwright-core";
 import { normalizeBrowserUrl } from "./browser-policy.js";
+export const BROWSER_VIEWPORT_WIDTH = 1280;
+export const BROWSER_VIEWPORT_HEIGHT = 900;
+const SEARCH_INPUT_SELECTORS = [
+    "input[name='wd']",
+    "input[name='q']",
+    "input[name='query']",
+    "input[type='search']",
+    "input[type='text']",
+];
+const SEARCH_SUBMIT_SELECTORS = [
+    "button[type='submit']",
+    "input[type='submit']",
+    "button:not([type])",
+];
+const DEFAULT_SEARCH_ENGINE_URL = "https://www.baidu.com/";
+const SEARCH_TYPING_DELAY_MS = 45;
+const DEFAULT_ACTION_TIMEOUT_MS = 15_000;
+const MAX_SNAPSHOT_CHARS = 24_000;
+const MAX_SCREENSHOT_BYTES = 4 * 1024 * 1024;
 export class BrowserAutomationService {
-    fetchImpl;
-    pending = [];
-    sequence = 0;
-    constructor(fetchImpl = fetch) {
-        this.fetchImpl = fetchImpl;
+    options;
+    browserPromise;
+    activePage;
+    tabs = new Map();
+    nextTabId = 1;
+    disposed = false;
+    dialogQueue = [];
+    downloadQueue = [];
+    constructor(options) {
+        this.options = options;
     }
-    async navigate(rawUrl, options) {
+    async navigate(rawUrl) {
         const normalized = normalizeBrowserUrl(rawUrl);
         if (normalized.kind !== "ok") {
             return {
                 ok: false,
-                error: normalized.kind === "invalid"
-                    ? "invalid browser url"
-                    : "browser urls must use http(s)",
+                code: normalized.kind === "blocked" ? "BAD_SCHEME" : "INVALID_URL",
+                error: normalized.kind === "blocked"
+                    ? "browser urls must use http(s)"
+                    : "invalid browser url",
             };
         }
-        let snapshot;
-        const snapshotSource = rewriteBaiduSearchUrlForSnapshot(normalized.url);
-        if (options?.includeSnapshot) {
-            try {
-                snapshot = await this.inspect(snapshotSource);
-            }
-            catch {
-                // Navigation itself can still succeed when the panel cannot
-                // fetch the page server-side; the iframe remains the fallback.
-            }
-        }
-        const displayUrl = snapshotSource === normalized.url ? normalized.url : snapshotSource;
-        const command = {
-            kind: "navigate",
-            id: this.nextId(),
-            url: displayUrl,
-            ...(snapshot ? { snapshot } : {}),
-            createdAt: new Date().toISOString(),
-        };
-        this.pending = [command];
-        return { ok: true, command };
-    }
-    reload() {
-        const command = {
-            kind: "reload",
-            id: this.nextId(),
-            createdAt: new Date().toISOString(),
-        };
-        this.pending = [command];
-        return { ok: true, command };
-    }
-    take() {
-        const commands = this.pending;
-        this.pending = [];
-        return commands;
-    }
-    async inspect(rawUrl) {
-        const normalized = normalizeBrowserUrl(rawUrl);
-        if (normalized.kind !== "ok")
-            throw new BrowserAutomationError("INVALID_URL", "invalid browser url");
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 12_000);
         try {
-            const response = await this.fetchImpl(normalized.url, {
-                redirect: "follow",
-                signal: controller.signal,
-                headers: { accept: "text/html,application/xhtml+xml" },
-            });
-            const contentType = response.headers.get("content-type") ?? "";
-            if (!contentType.includes("html")) {
-                throw new BrowserAutomationError("NOT_HTML", "the browser page did not return an HTML document");
-            }
-            const html = await response.text();
-            if (html.length > 3_000_000) {
-                throw new BrowserAutomationError("PAGE_TOO_LARGE", "page exceeds 3MB");
-            }
-            return parseBrowserPage(html, response.url || normalized.url);
+            const page = await this.page();
+            await page.goto(normalized.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+            const snapshot = await this.snapshot({ screenshot: false });
+            return { ok: true, page: snapshot };
         }
         catch (error) {
-            if (error instanceof BrowserAutomationError)
-                throw error;
-            throw new BrowserAutomationError("FETCH_FAILED", "could not load the page", {
-                cause: error,
-            });
+            return { ok: false, code: "NAVIGATION_FAILED", error: errorMessage(error) };
         }
-        finally {
-            clearTimeout(timer);
+    }
+    async reload() {
+        const page = await this.page();
+        await page.reload({ waitUntil: "domcontentloaded", timeout: 30_000 });
+        return this.snapshot({ screenshot: false });
+    }
+    async goBack() {
+        const page = await this.page();
+        await page.goBack({ waitUntil: "domcontentloaded", timeout: 30_000 });
+        return this.snapshot({ screenshot: false });
+    }
+    async goForward() {
+        const page = await this.page();
+        await page.goForward({ waitUntil: "domcontentloaded", timeout: 30_000 });
+        return this.snapshot({ screenshot: false });
+    }
+    async snapshot(options) {
+        const page = await this.page();
+        const dialog = this.dialogFor(page);
+        if (dialog) {
+            return {
+                url: page.url(),
+                title: "浏览器弹窗",
+                tabs: await this.tabSummaries(),
+                dialog,
+                ariaSnapshot: "",
+                ...(options?.screenshot === false
+                    ? {}
+                    : { screenshot: await this.captureScreenshot(page) }),
+            };
         }
+        const [title, aria] = await Promise.all([
+            page.title(),
+            page.ariaSnapshot({ mode: "ai", timeout: 10_000 }),
+        ]);
+        const download = await this.nextDownloadResult();
+        const screenshot = options?.screenshot === false
+            ? undefined
+            : await this.captureScreenshot(page);
+        return {
+            url: page.url(),
+            title,
+            tabs: await this.tabSummaries(),
+            dialog,
+            ariaSnapshot: truncateText(aria, MAX_SNAPSHOT_CHARS),
+            ...(screenshot ? { screenshot } : {}),
+            ...(download ? { download } : {}),
+        };
+    }
+    /**
+     * Lightweight state for iframe-driven UI. Avoids aria capture and PNG
+     * encoding on every panel poll.
+     */
+    async state() {
+        if (!this.browserPromise && !this.disposed)
+            return emptyBrowserState();
+        const page = await this.page();
+        const state = {
+            running: true,
+            url: page.url(),
+            title: await page.title().catch(() => ""),
+            tabs: await this.tabSummaries(),
+            dialog: this.dialogFor(page),
+            ariaSnapshot: "",
+        };
+        return state;
     }
     async search(rawQuery, rawUrl) {
         const query = rawQuery.trim();
         if (!query)
             throw new BrowserAutomationError("EMPTY_QUERY", "search query is empty");
-        let target = rawUrl?.trim() ? rawUrl.trim() : "https://m.baidu.com/s?wd=";
+        const target = rawUrl?.trim() || DEFAULT_SEARCH_ENGINE_URL;
         const normalized = normalizeBrowserUrl(target);
         if (normalized.kind !== "ok") {
             throw new BrowserAutomationError("INVALID_URL", "search engine url must use http(s)");
         }
-        const url = new URL(normalized.url);
-        url.searchParams.set(url.searchParams.has("q") ? "q" : "wd", query);
-        const result = await this.navigate(url.href, { includeSnapshot: true });
-        if (!result.ok)
-            throw new BrowserAutomationError("INVALID_URL", result.error);
-        return result.command.kind === "navigate" && result.command.snapshot
-            ? result.command.snapshot
-            : await this.inspect(url.href);
-    }
-    async act(rawUrl, request) {
-        const snapshot = await this.inspect(rawUrl);
-        const element = selectBrowserElement(snapshot, request);
-        if (!element) {
-            throw new BrowserAutomationError("ELEMENT_NOT_FOUND", "selector did not match a clickable element or form field");
+        const page = await this.page();
+        await page.bringToFront();
+        await page.goto(normalized.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+        const input = await findSearchInput(page);
+        if (!input) {
+            throw new BrowserAutomationError("SEARCH_INPUT_NOT_FOUND", "the search page did not expose a recognizable search input");
+        }
+        await input.fill("", { timeout: DEFAULT_ACTION_TIMEOUT_MS });
+        await input.pressSequentially(query, {
+            delay: SEARCH_TYPING_DELAY_MS,
+            timeout: DEFAULT_ACTION_TIMEOUT_MS,
+        });
+        await Promise.all([
+            page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 30_000 }),
+            submitSearchForm(page, input),
+        ]);
+        return this.snapshot({ screenshot: false });
+    }
+    async act(request) {
+        const page = await this.page();
+        const ref = request.ref.trim();
+        if (!/^(f\d+)?e\d+$/.test(ref)) {
+            throw new BrowserAutomationError("INVALID_REF", "element ref must come from a fresh browser snapshot");
         }
-        if (request.type === "fill") {
-            if (element.tag !== "input" && element.tag !== "textarea") {
-                throw new BrowserAutomationError("NOT_FILLABLE", "matched element is not fillable");
+        const locator = page.locator(`aria-ref=${ref}`);
+        try {
+            if (request.type === "click") {
+                await locator.click({ timeout: DEFAULT_ACTION_TIMEOUT_MS });
+            }
+            else if (request.type === "fill") {
+                await locator.fill(request.value, { timeout: DEFAULT_ACTION_TIMEOUT_MS });
+            }
+            else if (request.type === "press") {
+                await locator.press(request.key, { timeout: DEFAULT_ACTION_TIMEOUT_MS });
+            }
+            else {
+                await locator.hover({ timeout: DEFAULT_ACTION_TIMEOUT_MS });
             }
-            const submitted = this.submitForm(snapshot, element, request.value);
-            const submittedSnapshot = await this.inspect(submitted.url);
-            const navigation = await this.navigate(submitted.url, { includeSnapshot: true });
-            if (!navigation.ok)
-                throw new BrowserAutomationError("INVALID_URL", navigation.error);
-            return {
-                ...submittedSnapshot,
-                action: { type: "fill", selector: request.selector, value: request.value, url: submitted.url },
-            };
         }
-        const formSubmit = element.clickable && element.formIndex !== undefined && !element.href
-            ? this.submitForm(snapshot, element)
-            : undefined;
-        const targetUrl = formSubmit?.url ?? element.href;
-        if (targetUrl === undefined) {
-            throw new BrowserAutomationError("NOT_CLICKABLE", "matched element has no safe click target");
+        catch (error) {
+            if (error instanceof Error && /ref .* not found/i.test(error.message)) {
+                throw new BrowserAutomationError("STALE_REF", "element ref is stale; take a fresh browser snapshot", { cause: error });
+            }
+            throw new BrowserAutomationError("ACTION_FAILED", errorMessage(error), { cause: error });
         }
-        const navigation = await this.navigate(targetUrl, { includeSnapshot: true });
-        if (!navigation.ok)
-            throw new BrowserAutomationError("INVALID_URL", navigation.error);
-        return {
-            ...snapshot,
-            action: {
-                type: "click",
-                selector: request.selector,
-                url: targetUrl,
-            },
-        };
+        await page.waitForLoadState("domcontentloaded", { timeout: 3_000 }).catch(() => undefined);
+        return { action: request.type, ref, page: await this.snapshot({ screenshot: false }) };
+    }
+    async scroll(input) {
+        const page = await this.page();
+        const amount = clamp(input.amount ?? 600, 50, 3000);
+        await page.mouse.wheel(0, input.direction === "down" ? amount : -amount);
+        await page.waitForTimeout(150);
+        return this.snapshot({ screenshot: false });
+    }
+    async pressKey(key) {
+        const page = await this.page();
+        await page.keyboard.press(key);
+        await page.waitForLoadState("domcontentloaded", { timeout: 3_000 }).catch(() => undefined);
+        return this.snapshot({ screenshot: false });
+    }
+    async selectTab(tabId) {
+        const page = this.tabs.get(tabId);
+        if (!page)
+            throw new BrowserAutomationError("TAB_NOT_FOUND", `tab ${tabId} does not exist`);
+        this.activePage = page;
+        await page.bringToFront();
+        return this.snapshot({ screenshot: false });
+    }
+    async newTab(rawUrl) {
+        const context = await this.context();
+        const page = await context.newPage();
+        this.trackPage(page);
+        this.activePage = page;
+        if (rawUrl) {
+            const result = await this.navigate(rawUrl);
+            if (!result.ok)
+                throw new BrowserAutomationError(result.code, result.error);
+            return result.page;
+        }
+        return this.snapshot({ screenshot: false });
+    }
+    async closeTab(tabId) {
+        const page = tabId === undefined ? await this.page() : this.tabs.get(tabId);
+        if (!page)
+            throw new BrowserAutomationError("TAB_NOT_FOUND", `tab ${tabId} does not exist`);
+        this.tabs.delete(tabIdForValue(this.tabs, page) ?? 0);
+        await page.close();
+        if (this.activePage === page)
+            this.activePage = undefined;
+        return this.snapshot({ screenshot: false });
+    }
+    async handleDialog(action, promptText) {
+        const page = await this.page();
+        const index = this.dialogQueue.findIndex((entry) => entry.page === page);
+        const entry = index >= 0 ? this.dialogQueue[index] : undefined;
+        if (!entry)
+            throw new BrowserAutomationError("NO_DIALOG", "the active page has no pending dialog");
+        this.dialogQueue.splice(index, 1);
+        if (action === "accept")
+            await entry.dialog.accept(promptText);
+        else
+            await entry.dialog.dismiss();
+        return this.snapshot({ screenshot: false });
+    }
+    async dispatchPointer(input) {
+        const page = await this.page();
+        if (input.type === "mousemove")
+            await page.mouse.move(input.x, input.y);
+        else if (input.type === "wheel")
+            await page.mouse.wheel(input.deltaX, input.deltaY);
+        else if (input.type === "mousedown")
+            await page.mouse.down({ button: input.button ?? "left" });
+        else if (input.type === "mouseup")
+            await page.mouse.up({ button: input.button ?? "left" });
+        return { ok: true };
+    }
+    async dispatchKeyboard(input) {
+        const page = await this.page();
+        if (input.type === "keydown")
+            await page.keyboard.down(input.key);
+        else
+            await page.keyboard.up(input.key);
+        return { ok: true };
+    }
+    async inputText(text) {
+        const page = await this.page();
+        await page.keyboard.type(text);
+        return { ok: true };
+    }
+    async screenshot() {
+        return this.snapshot({ screenshot: true });
+    }
+    async focus() {
+        const page = await this.page();
+        await page.bringToFront();
+        return { ok: true };
+    }
+    async waitFor(ms) {
+        const page = await this.page();
+        await page.waitForTimeout(clamp(ms, 0, 10_000));
+        return this.snapshot({ screenshot: false });
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const pending = this.browserPromise;
+        this.browserPromise = undefined;
+        this.tabs.clear();
+        this.activePage = undefined;
+        if (!pending)
+            return;
+        const context = await pending.catch(() => undefined);
+        await context?.close().catch(() => undefined);
     }
-    submitForm(snapshot, target, valueOverride) {
-        if (target.formIndex === undefined) {
-            throw new BrowserAutomationError("FORM_NOT_FOUND", "matched field is not inside a form");
+    async page() {
+        const context = await this.context();
+        if (this.activePage && !this.activePage.isClosed())
+            return this.activePage;
+        const existing = context.pages().find((page) => this.tabs.has(tabIdForValue(this.tabs, page) ?? -1));
+        if (existing) {
+            this.activePage = existing;
+            return existing;
         }
-        if ((target.formMethod ?? "get") !== "get") {
-            throw new BrowserAutomationError("FORM_METHOD_NOT_SUPPORTED", "only GET forms can be automated without browser scripts");
+        const page = await context.newPage();
+        this.trackPage(page);
+        this.activePage = page;
+        return page;
+    }
+    async context() {
+        if (this.disposed)
+            throw new BrowserAutomationError("BROWSER_CLOSED", "browser service is disposed");
+        this.browserPromise ??= (async () => {
+            await Promise.all([
+                mkdir(this.options.profileDir, { recursive: true }),
+                mkdir(this.options.downloadsDir, { recursive: true }),
+                mkdir(this.options.screenshotsDir, { recursive: true }),
+            ]);
+            const browser = await this.launchBrowser();
+            this.wireContext(browser);
+            const page = browser.pages()[0] ?? await browser.newPage();
+            this.trackPage(page);
+            this.activePage = page;
+            return browser;
+        })();
+        try {
+            return await this.browserPromise;
         }
-        const url = new URL(target.formAction ?? snapshot.url);
-        for (const element of snapshot.elements) {
-            if (element.formIndex !== target.formIndex || !element.name)
-                continue;
-            if (element.tag === "button")
-                continue;
-            if (element.tag === "input" && ["submit", "button", "reset", "image"].includes(element.type ?? "")) {
-                continue;
+        catch (error) {
+            this.browserPromise = undefined;
+            throw new BrowserAutomationError("BROWSER_START_FAILED", errorMessage(error), {
+                cause: error,
+            });
+        }
+    }
+    wireContext(context) {
+        context.on("page", (page) => {
+            this.trackPage(page);
+            if (!this.activePage || this.activePage.isClosed())
+                this.activePage = page;
+        });
+        context.on("close", () => {
+            if (this.browserPromise) {
+                void this.browserPromise.then((current) => {
+                    if (current === context) {
+                        this.browserPromise = undefined;
+                        this.activePage = undefined;
+                        this.tabs.clear();
+                    }
+                });
             }
-            const value = element.selector === target.selector && valueOverride !== undefined
-                ? valueOverride
-                : element.value ?? "";
-            url.searchParams.set(element.name, value);
+        });
+        context.on("dialog", (dialog) => {
+            const page = dialog.page();
+            if (page)
+                this.dialogQueue.push({ page, dialog });
+        });
+        context.on("download", (download) => {
+            this.downloadQueue.push({ download, consumed: false });
+        });
+    }
+    async launchBrowser() {
+        const candidates = chromiumLaunchCandidates();
+        const launchOptions = chromiumLaunchOptions(this.options.headless);
+        let lastError;
+        for (const candidate of candidates) {
+            try {
+                return await chromium.launchPersistentContext(this.options.profileDir, { ...launchOptions, ...candidate });
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (candidates.length === 0) {
+            return await chromium.launchPersistentContext(this.options.profileDir, launchOptions);
         }
-        return { url: url.href };
+        throw lastError instanceof Error
+            ? lastError
+            : new Error("no Chromium executable was available");
     }
-    nextId() {
-        this.sequence += 1;
-        return `browser-${Date.now().toString(36)}-${this.sequence}`;
+    trackPage(page) {
+        for (const [id, existing] of this.tabs) {
+            if (existing === page)
+                return id;
+        }
+        const id = this.nextTabId;
+        this.nextTabId += 1;
+        this.tabs.set(id, page);
+        page.on("close", () => {
+            this.tabs.delete(id);
+            if (this.activePage === page)
+                this.activePage = undefined;
+        });
+        return id;
     }
-}
-export class BrowserAutomationError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-        this.name = "BrowserAutomationError";
+    dialogFor(page) {
+        const index = this.dialogQueue.findIndex((entry) => entry.page === page);
+        const dialog = index >= 0 ? this.dialogQueue[index]?.dialog : undefined;
+        if (!dialog)
+            return null;
+        return {
+            type: dialog.type(),
+            message: dialog.message(),
+            ...(dialog.defaultValue() ? { defaultText: dialog.defaultValue() } : {}),
+        };
     }
-}
-export function rewriteBaiduSearchUrlForSnapshot(rawUrl) {
-    try {
-        const url = new URL(rawUrl);
-        if (url.protocol !== "https:" || url.hostname !== "www.baidu.com")
-            return rawUrl;
-        if (url.pathname.replace(/\/+$/, "") !== "/s")
-            return rawUrl;
-        const query = url.searchParams.get("wd") ?? url.searchParams.get("word");
-        if (query === null)
-            return rawUrl;
-        const mobile = new URL("https://m.baidu.com/s");
-        mobile.searchParams.set("wd", query);
-        return mobile.href;
-    }
-    catch {
-        return rawUrl;
+    async tabSummaries() {
+        return Promise.all([...this.tabs.entries()].map(async ([id, page]) => ({
+            id,
+            url: page.url(),
+            title: page.isClosed() ? "" : await page.title().catch(() => ""),
+            active: !page.isClosed() && page === this.activePage,
+        })));
     }
-}
-const SKIP_TAGS = new Set(["script", "style", "template", "noscript"]);
-const INTERACTIVE_TAGS = new Set(["a", "button", "input", "select", "textarea"]);
-export function parseBrowserPage(html, baseUrl) {
-    const state = { snapshot: { url: baseUrl, title: "", elements: [] }, nextFormIndex: 0 };
-    const tokenizer = /<!--[\s\S]*?-->|<\/?([a-zA-Z][a-zA-Z0-9:-]*)([^>]*)>/g;
-    const openTags = [];
-    let cursor = 0;
-    let match;
-    while ((match = tokenizer.exec(html)) !== null) {
-        const text = decodeEntities(html.slice(cursor, match.index)).replace(/\s+/g, " ").trim();
-        const parent = openTags[openTags.length - 1];
-        if (parent && !SKIP_TAGS.has(parent.tag))
-            appendText(parent, text);
-        cursor = match.index + match[0].length;
-        if (match[0].startsWith("<!--"))
-            continue;
-        const tag = match[1]?.toLowerCase() ?? "";
-        const attrs = parseAttributes(match[2] ?? "");
-        if (match[0].startsWith("</")) {
-            const index = findOpenTag(openTags, tag);
-            if (index >= 0) {
-                const closed = openTags[index];
-                openTags.length = index;
-                closeElement(state, closed, baseUrl);
-            }
-            continue;
-        }
-        const parentForForm = openTags[openTags.length - 1];
-        let form = parentForForm?.form;
-        if (tag === "form" && !form) {
-            form = {
-                index: state.nextFormIndex,
-                action: attrs.action,
-                method: attrs.method?.toLowerCase(),
+    async captureScreenshot(page) {
+        const buffer = await page.screenshot({
+            type: "png",
+            fullPage: false,
+            timeout: 15_000,
+        });
+        if (buffer.byteLength > MAX_SCREENSHOT_BYTES)
+            return undefined;
+        return `data:image/png;base64,${buffer.toString("base64")}`;
+    }
+    async nextDownloadResult() {
+        const index = this.downloadQueue.findIndex((entry) => !entry.consumed);
+        if (index < 0)
+            return undefined;
+        const entry = this.downloadQueue[index];
+        if (!entry)
+            return undefined;
+        entry.consumed = true;
+        const download = entry.download;
+        const target = path.join(this.options.downloadsDir, `${randomUUID()}-${sanitizeFilename(download.suggestedFilename())}`);
+        try {
+            await download.saveAs(target);
+            this.downloadQueue.splice(index, 1);
+            return {
+                url: download.url(),
+                suggestedFilename: download.suggestedFilename(),
+                path: target,
             };
-            state.nextFormIndex += 1;
-        }
-        const element = { tag, attrs, text: "", form };
-        if (/\/>$/.test(match[0]) || isVoidTag(tag)) {
-            closeElement(state, element, baseUrl);
         }
-        else {
-            openTags.push(element);
+        catch (error) {
+            this.downloadQueue.splice(index, 1);
+            throw error;
         }
     }
-    if (state.snapshot.elements.length > 300)
-        state.snapshot.elements.length = 300;
-    return state.snapshot;
 }
-function parseAttributes(raw) {
-    const attrs = {};
-    const pattern = /([:@a-zA-Z_#][^\s"'<>`=]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
-    let match;
-    while ((match = pattern.exec(raw)) !== null) {
-        attrs[match[1]?.toLowerCase() ?? ""] = decodeEntities(match[2] ?? match[3] ?? match[4] ?? "");
-    }
-    return attrs;
+function emptyBrowserState() {
+    return {
+        running: false,
+        url: "about:blank",
+        title: "",
+        tabs: [],
+        dialog: null,
+        ariaSnapshot: "",
+    };
 }
-function isVoidTag(tag) {
-    return tag === "input" || tag === "img" || tag === "br" || tag === "hr" || tag === "meta" || tag === "link";
+function chromiumLaunchOptions(headless) {
+    return {
+        headless: headless ?? false,
+        viewport: undefined,
+        acceptDownloads: true,
+        locale: "zh-CN",
+        timezoneId: "Asia/Shanghai",
+        args: ["--start-maximized", "--disable-blink-features=AutomationControlled"],
+        ignoreDefaultArgs: ["--enable-automation"],
+    };
 }
-function findOpenTag(stack, tag) {
-    for (let index = stack.length - 1; index >= 0; index -= 1) {
-        if (stack[index]?.tag === tag)
-            return index;
+async function findSearchInput(page) {
+    for (const selector of SEARCH_INPUT_SELECTORS) {
+        const locator = page.locator(selector).first();
+        if (await locator.isVisible().catch(() => false))
+            return locator;
     }
-    return -1;
-}
-function appendText(target, text) {
-    target.text = target.text ? `${target.text} ${text}` : text;
+    return undefined;
 }
-function closeElement(state, element, baseUrl) {
-    const { tag, attrs, text } = element;
-    if (tag === "title") {
-        state.snapshot.title = text.slice(0, 300);
+async function submitSearchForm(page, input) {
+    for (const selector of SEARCH_SUBMIT_SELECTORS) {
+        const locator = page.locator(selector).first();
+        if (!await locator.isVisible().catch(() => false))
+            continue;
+        await locator.click({ timeout: DEFAULT_ACTION_TIMEOUT_MS });
         return;
     }
-    if (!INTERACTIVE_TAGS.has(tag))
-        return;
-    let href;
-    if (tag === "a" && attrs.href && !/^(javascript|mailto|tel):/i.test(attrs.href.trim())) {
-        try {
-            href = new URL(attrs.href, baseUrl).href;
-        }
-        catch {
-            href = undefined;
-        }
+    await input.press("Enter", { timeout: DEFAULT_ACTION_TIMEOUT_MS });
+}
+export class BrowserAutomationError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "BrowserAutomationError";
     }
-    const id = attrs.id;
-    const name = attrs.name;
-    const selector = buildSelector(tag, id, name, attrs.class, state.snapshot.elements.length);
-    const rawText = text || attrs.value || attrs.placeholder || attrs["aria-label"] || attrs.title || "";
-    state.snapshot.elements.push({
-        tag,
-        ...(id ? { id } : {}),
-        text: rawText.replace(/\s+/g, " ").trim().slice(0, 240),
-        ...(href ? { href } : {}),
-        ...(name ? { name } : {}),
-        ...(attrs.type ? { type: attrs.type } : {}),
-        ...(attrs.value ? { value: attrs.value } : {}),
-        ...(attrs.placeholder ? { placeholder: attrs.placeholder } : {}),
-        ...(element.form ? { formIndex: element.form.index } : {}),
-        ...(element.form ? {
-            formAction: element.form.action === undefined
-                ? baseUrl
-                : new URL(element.form.action, baseUrl).href,
-            formMethod: element.form.method ?? "get",
-        } : {}),
-        selector,
-        clickable: tag === "a" || tag === "button" || (tag === "input" && ["submit", "button", "radio", "checkbox"].includes(attrs.type ?? "")),
-    });
 }
-function buildSelector(tag, id, name, className, index) {
-    if (id)
-        return `#${escapeSelectorValue(id)}`;
-    if (name)
-        return `${tag}[name="${escapeSelectorValue(name)}"]`;
-    if (className?.trim()) {
-        const firstClass = className.trim().split(/\s+/)[0];
-        if (firstClass)
-            return `${tag}.${escapeSelectorValue(firstClass)}`;
-    }
-    return `${tag}:nth-of-type(${index + 1})`;
+export function chromiumLaunchCandidates(env = process.env, platform = process.platform) {
+    const executablePath = env.LOOP_BROWSER_CHROMIUM_PATH?.trim();
+    if (executablePath)
+        return [{ executablePath }];
+    if (platform === "win32")
+        return [{ channel: "chrome" }, { channel: "msedge" }];
+    if (platform === "darwin")
+        return [{ channel: "chrome" }];
+    return [];
 }
-function escapeSelectorValue(value) {
-    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+function tabIdForValue(map, page) {
+    for (const [id, value] of map)
+        if (value === page)
+            return id;
+    return undefined;
 }
-export function selectBrowserElement(snapshot, request) {
-    const selector = request.selector.trim();
-    if (!selector)
-        return undefined;
-    return snapshot.elements.find((element) => element.selector === selector)
-        ?? snapshot.elements.find((element) => element.id === selector.slice(1))
-        ?? snapshot.elements.find((element) => element.name === selector)
-        ?? snapshot.elements.find((element) => element.text.toLowerCase().includes(selector.toLowerCase()) && selector.length >= 2);
+function truncateText(value, max) {
+    return value.length <= max ? value : `${value.slice(0, max)}\n... [snapshot truncated]`;
 }
-const ENTITY_MAP = {
-    amp: "&",
-    lt: "<",
-    gt: ">",
-    quot: "\"",
-    apos: "'",
-    nbsp: " ",
-};
-function decodeEntities(value) {
-    return value.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (whole, entity) => {
-        if (entity.startsWith("#x") || entity.startsWith("#X")) {
-            const code = Number.parseInt(entity.slice(2), 16);
-            return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
-        }
-        if (entity.startsWith("#")) {
-            const code = Number.parseInt(entity.slice(1), 10);
-            return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
-        }
-        return ENTITY_MAP[entity.toLowerCase()] ?? whole;
-    });
+function clamp(value, min, max) {
+    return Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : min;
+}
+function sanitizeFilename(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_").slice(0, 180) || "download";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }