playwright-repl 0.19.0 → 0.21.2

package/README.md

@@ -1,6 +1,6 @@
-# playwright-repl (CLI)
+# playwright-repl
 
-Interactive terminal REPL for browser automation powered by Playwright. Type a command, see the result instantly — no code, no boilerplate.
+Interactive terminal REPL for browser automation powered by Playwright. Type a command, see the result — no code, no boilerplate.
 
 ```bash
 npm install -g playwright-repl
@@ -9,9 +9,9 @@ playwright-repl --headed
 
 ```
 pw> goto https://demo.playwright.dev/todomvc/
-pw> fill "What needs to be done?" "Buy groceries"
+pw> fill "What needs to be done?" Buy groceries
 pw> press Enter
-pw> verify-text "1 item left"
+pw> verify text 1 item left
 pw> screenshot
 ```
 
@@ -26,10 +26,10 @@ npx playwright install
 
 ## Connection Modes
 
-| Mode | Flag | Browser Source | Use Case |
-|------|------|---------------|----------|
-| **Standalone** | *(default)* | Launches new Chromium via Playwright | General automation, CI |
-| **Bridge** | `--bridge` | Your real Chrome (via extension) | Drive your existing session — cookies and logins intact |
+| Mode | Flag | How it works |
+|------|------|--------------|
+| **Standalone** | *(default)* | Launches Chromium via Playwright |
+| **Bridge** | `--bridge` | Connects to your real Chrome via Dramaturg extension — cookies and logins intact |
 
 ### Standalone
 
@@ -44,18 +44,18 @@ playwright-repl --persistent   # keeps profile between sessions
 
 ### Bridge
 
-The bridge mode starts an interactive REPL that acts as a **remote console for the Chrome extension** — your terminal becomes the command input for the extension's browser session. Commands run inside your real Chrome with your existing cookies and logins.
+The bridge mode turns your terminal into a remote console for the Chrome extension. Commands run inside your real Chrome with your existing cookies and logins.
 
 ```bash
-playwright-repl --bridge                      # start bridge server, wait for extension to connect
+playwright-repl --bridge                      # start bridge server, wait for extension
 playwright-repl --bridge --replay script.pw   # replay a script via bridge
 playwright-repl --bridge --replay examples/   # replay all .pw files
 playwright-repl --bridge --bridge-port 9877   # custom port (default 9876)
 ```
 
-The extension connects automatically — no need to open the side panel. Once connected, all commands run against the active tab in your real browser.
+The extension connects automatically — no need to open the side panel.
 
-> Requires the playwright-repl Chrome extension — see [packages/extension/README.md](../extension/README.md) for setup.
+> Requires the [Dramaturg Chrome extension](../extension/README.md).
 
 ## Usage
 
@@ -86,10 +86,10 @@ echo -e "goto https://example.com\nsnapshot" | playwright-repl
 
 | Mode | Standalone | Bridge |
 |------|:---:|:---:|
-| **Keyword** — `click "Sign in"`, `goto https://...` | ✅ | ✅ |
-| **Playwright API / JS** — `await page.title()`, `1 + 1` | ❌ | ✅ auto-detected |
+| **Keyword** — `click "Sign in"`, `goto https://...` | Yes | Yes |
+| **Playwright API / JS** — `await page.title()`, `1 + 1` | No | Yes (auto-detected) |
 
-Bridge mode auto-detects Playwright API and JavaScript expressions — just type them directly. For DOM access use `await page.evaluate(() => document.title)`. For the full keyword command list, see [Command Reference](#command-reference).
+Bridge mode auto-detects Playwright API and JavaScript expressions. For DOM access use `await page.evaluate(() => document.title)`. For keyword commands, see [Command Reference](#command-reference).
 
 ## CLI Options
 
@@ -127,7 +127,7 @@ Bridge mode auto-detects Playwright API and JavaScript expressions — just type
 
 ## Recording & Replay
 
-Record your browser interactions and replay them later — great for regression tests, onboarding demos, or CI smoke tests.
+Record browser interactions and replay them later — great for regression tests, onboarding demos, or CI smoke tests.
 
 ### Record
 
@@ -139,9 +139,9 @@ playwright-repl --record my-test.pw --headed
 pw> .record my-test
 ⏺ Recording to my-test.pw
 pw> goto https://demo.playwright.dev/todomvc/
-pw> fill "What needs to be done?" "Buy groceries"
+pw> fill "What needs to be done?" Buy groceries
 pw> press Enter
-pw> verify-text "1 item left"
+pw> verify text 1 item left
 pw> .save
 ✓ Saved 4 commands to my-test.pw
 ```
@@ -162,7 +162,7 @@ playwright-repl --replay examples/ --silent
 pw> .replay my-test.pw
 ```
 
-Multi-file replay runs all files sequentially, writes a `replay-<timestamp>.log` with per-command results, and prints a pass/fail summary. Exit code 0 if all pass, 1 if any fail.
+Multi-file replay runs all files sequentially, writes a `replay-<timestamp>.log`, and prints a pass/fail summary. Exit code 0 if all pass, 1 if any fail.
 
 ### .pw File Format
 
@@ -173,10 +173,10 @@ Plain text — human-readable, diffable, version-controllable:
 # App: https://demo.playwright.dev/todomvc/
 
 goto https://demo.playwright.dev/todomvc/
-fill "What needs to be done?" "Buy groceries"
+fill "What needs to be done?" Buy groceries
 press Enter
-verify-text "Buy groceries"
-verify-text "1 item left"
+verify text Buy groceries
+verify text 1 item left
 ```
 
 ## Examples
@@ -200,7 +200,7 @@ playwright-repl --replay examples/ --silent
 ## Requirements
 
 - Node.js >= 20
-- `playwright` >= 1.59.0-alpha (browser binaries only needed for standalone mode)
+- `playwright` >= 1.59
 
 ---
 
@@ -273,11 +273,11 @@ pw> highlight --clear                # dismiss the highlight overlay
 
 | Command | Alias | Description |
 |---------|-------|-------------|
-| `verify-text <text>` | `vt` | Verify text is visible on page |
-| `verify-no-text <text>` | `vnt` | Verify text is not visible |
-| `verify-element <role> <name>` | `ve` | Verify element exists by role and name |
-| `verify-value <ref> <value>` | `vv` | Verify input/select/checkbox value |
-| `verify-list <ref> <items>` | `vl` | Verify list contains expected items |
+| `verify text <text>` | `vt` | Verify text is visible on page |
+| `verify no-text <text>` | `vnt` | Verify text is not visible |
+| `verify element <role> <name>` | `ve` | Verify element exists by role and name |
+| `verify value <ref> <value>` | `vv` | Verify input/select/checkbox value |
+| `verify list <ref> <items>` | `vl` | Verify list contains expected items |
 
 ### Tabs
 

package/dist/engine.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Engine — in-process Playwright backend.
+ *
+ * Wraps BrowserServerBackend directly, eliminating the daemon process.
+ * Provides the same interface as DaemonConnection: run(args), connected, close().
+ *
+ * Three connection modes:
+ *   - launch:    new browser via Playwright (default)
+ *   - connect:   existing Chrome via CDP port (--connect [port])
+ *   - extension: DevTools extension CDP relay (--extension)
+ */
+import type { EngineOpts, EngineResult, ParsedArgs } from '@playwright-repl/core';
+export type { EngineOpts, EngineResult, ParsedArgs };
+interface PlaywrightDeps {
+    BrowserServerBackend: new (config: any, factory: any, opts: any) => any;
+    contextFactory: (config: any) => {
+        createContext: (info: any, signal: AbortSignal, opts: any) => Promise<{
+            browserContext: any;
+            close: () => Promise<void>;
+        }>;
+    };
+    playwright: any;
+    registry: {
+        findExecutable: (name: string) => {
+            executablePath: () => string | undefined;
+        } | undefined;
+    };
+    resolveConfig: (config: any) => Promise<any> | any;
+    commands: Record<string, any>;
+    parseCommand: (command: any, args: any) => {
+        toolName: string;
+        toolParams: Record<string, any>;
+    };
+}
+export declare class Engine {
+    private _deps;
+    private _backend;
+    private _browserContext;
+    private _close;
+    private _connected;
+    private _commandServer;
+    private _chromeProc;
+    private _isReconnecting;
+    private _reconnectInfo;
+    constructor(deps?: PlaywrightDeps);
+    get connected(): boolean;
+    /**
+     * Start the engine with given options.
+     */
+    start(opts?: EngineOpts): Promise<void>;
+    /**
+     * Run a command given minimist-parsed args.
+     * Returns { text, isError } matching DaemonConnection.run() shape.
+     */
+    run(args: ParsedArgs): Promise<EngineResult>;
+    /**
+     * Select the Playwright page matching the given URL.
+     * Uses backend.callTool('browser_tabs') to properly update the tab tracker.
+     */
+    selectPageByUrl(targetUrl: string): Promise<void>;
+    /**
+     * Shut down the browser and backend.
+     */
+    close(): Promise<void>;
+    private _connectToCdp;
+    private _scheduleReconnect;
+    private _doReconnect;
+    private _buildConfig;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAElF,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC;AAGrD,UAAU,cAAc;IACtB,oBAAoB,EAAE,KAAK,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;IACxE,cAAc,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK;QAAE,aAAa,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC;YAAE,cAAc,EAAE,GAAG,CAAC;YAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC;IAChK,UAAU,EAAE,GAAG,CAAC;IAChB,QAAQ,EAAE;QAAE,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;YAAE,cAAc,EAAE,MAAM,MAAM,GAAG,SAAS,CAAA;SAAE,GAAG,SAAS,CAAA;KAAE,CAAC;IACzG,aAAa,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IACnD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,YAAY,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;CAClG;AA6BD,qBAAa,MAAM;IAEjB,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,WAAW,CAAwD;IAC3E,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,cAAc,CAAmE;gBAG7E,IAAI,CAAC,EAAE,cAAc;IAIjC,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACG,KAAK,CAAC,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAsGjD;;;OAGG;IACG,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAiFlD;;;OAGG;IACG,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBvD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAuBd,aAAa;IAuC3B,OAAO,CAAC,kBAAkB;YAQZ,YAAY;YAsDZ,YAAY;CA0D3B"}

package/dist/engine.js

@@ -0,0 +1,458 @@
+/**
+ * Engine — in-process Playwright backend.
+ *
+ * Wraps BrowserServerBackend directly, eliminating the daemon process.
+ * Provides the same interface as DaemonConnection: run(args), connected, close().
+ *
+ * Three connection modes:
+ *   - launch:    new browser via Playwright (default)
+ *   - connect:   existing Chrome via CDP port (--connect [port])
+ *   - extension: DevTools extension CDP relay (--extension)
+ */
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import url from 'node:url';
+import { replVersion } from '@playwright-repl/core';
+/* eslint-enable @typescript-eslint/no-explicit-any */
+// ─── Lazy-loaded Playwright dependencies ────────────────────────────────────
+let _deps;
+function loadDeps() {
+    if (_deps)
+        return _deps;
+    const require = createRequire(import.meta.url);
+    // Resolve absolute paths to bypass Playwright's exports map.
+    const pwDir = path.dirname(require.resolve('playwright/package.json'));
+    const pwReq = (sub) => require(path.join(pwDir, sub));
+    const pwCoreDir = path.dirname(require.resolve('playwright-core/package.json'));
+    const pwCoreReq = (sub) => require(path.join(pwCoreDir, sub));
+    _deps = {
+        BrowserServerBackend: pwReq('lib/mcp/browser/browserServerBackend.js').BrowserServerBackend,
+        contextFactory: pwReq('lib/mcp/browser/browserContextFactory.js').contextFactory,
+        playwright: require('playwright-core'),
+        registry: pwCoreReq('lib/server/registry/index.js').registry,
+        resolveConfig: pwReq('lib/mcp/browser/config.js').resolveConfig,
+        commands: pwReq('lib/cli/daemon/commands.js').commands,
+        parseCommand: pwReq('lib/cli/daemon/command.js').parseCommand,
+    };
+    return _deps;
+}
+// ─── Engine ─────────────────────────────────────────────────────────────────
+export class Engine {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    _deps;
+    _backend = null;
+    _browserContext = null;
+    _close = null;
+    _connected = false;
+    _commandServer = null;
+    _chromeProc = null;
+    _isReconnecting = false;
+    _reconnectInfo = null;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    constructor(deps) {
+        this._deps = deps;
+    }
+    get connected() {
+        return this._connected;
+    }
+    /**
+     * Start the engine with given options.
+     */
+    async start(opts = {}) {
+        const deps = this._deps || loadDeps();
+        const config = await this._buildConfig(opts, deps);
+        const cwd = url.pathToFileURL(process.cwd()).href;
+        const clientInfo = {
+            name: 'playwright-repl',
+            version: replVersion,
+            roots: [{ uri: cwd, name: 'cwd' }],
+            timestamp: Date.now(),
+        };
+        // Choose context factory based on mode.
+        if (opts.extension) {
+            const serverPort = opts.port || 6781;
+            const cdpPort = opts.cdpPort || 9222;
+            // 1. Start CommandServer for panel HTTP commands.
+            const { CommandServer } = await import('@playwright-repl/core');
+            const cmdServer = new CommandServer(this);
+            await cmdServer.start(serverPort);
+            this._commandServer = cmdServer;
+            console.log(`CommandServer listening on http://localhost:${serverPort}`);
+            // 2. Spawn Chrome (only with --spawn).
+            if (opts.spawn) {
+                const extPath = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '../../extension/dist');
+                const execInfo = deps.registry.findExecutable(opts.browser || 'chrome');
+                const execPath = execInfo?.executablePath();
+                if (!execPath)
+                    throw new Error('Chrome executable not found. Make sure Chrome is installed.');
+                // Chrome 136+ requires --user-data-dir for CDP. Use a dedicated profile dir.
+                const os = await import('node:os');
+                const fs = await import('node:fs');
+                const userDataDir = opts.profile || path.join(os.default.homedir(), '.playwright-repl', 'chrome-profile');
+                fs.default.mkdirSync(userDataDir, { recursive: true });
+                const chromeArgs = [
+                    `--remote-debugging-port=${cdpPort}`,
+                    `--user-data-dir=${userDataDir}`,
+                    `--load-extension=${extPath}`,
+                    '--no-first-run',
+                    '--no-default-browser-check',
+                ];
+                const { spawn } = await import('node:child_process');
+                const chromeProc = spawn(execPath, chromeArgs, {
+                    detached: true, stdio: 'ignore',
+                });
+                chromeProc.unref();
+                this._chromeProc = chromeProc;
+                console.log(`Chrome profile: ${userDataDir}`);
+            }
+            else {
+                console.log('Connecting to existing Chrome on port ' + cdpPort + ' (use --spawn to launch Chrome automatically)');
+            }
+            // 3. Wait for Chrome CDP to be ready (30s timeout).
+            console.log('Waiting for Chrome CDP...');
+            const cdpUrl = `http://localhost:${cdpPort}`;
+            const cdpTimeout = 30_000;
+            const cdpStart = Date.now();
+            while (true) {
+                if (Date.now() - cdpStart > cdpTimeout) {
+                    throw new Error(`Timeout: Chrome CDP not available at ${cdpUrl} after ${cdpTimeout / 1000}s`);
+                }
+                try {
+                    const res = await fetch(`${cdpUrl}/json/version`);
+                    if (res.ok)
+                        break;
+                }
+                catch { /* retry */ }
+                await new Promise(r => setTimeout(r, 500));
+            }
+            console.log('Chrome CDP ready. Connecting Playwright...');
+            // 4. Connect Playwright via CDP.
+            config.browser.cdpEndpoint = cdpUrl;
+            this._reconnectInfo = { opts, config, clientInfo };
+            await this._connectToCdp(deps, config, clientInfo);
+            console.log('Ready! Side panel can send commands.');
+        }
+        else {
+            // Launch/connect mode: eagerly create context for immediate feedback.
+            const factory = deps.contextFactory(config);
+            const { browserContext, close } = await factory.createContext(clientInfo, new AbortController().signal, {});
+            this._browserContext = browserContext;
+            this._close = close;
+            const existingContextFactory = {
+                createContext: () => Promise.resolve({ browserContext, close }),
+            };
+            this._backend = new deps.BrowserServerBackend(config, existingContextFactory, { allTools: true });
+            await this._backend.initialize?.(clientInfo);
+            this._connected = true;
+            browserContext.on('close', () => {
+                this._connected = false;
+            });
+        }
+    }
+    /**
+     * Run a command given minimist-parsed args.
+     * Returns { text, isError } matching DaemonConnection.run() shape.
+     */
+    async run(args) {
+        if (!this._backend)
+            throw new Error('Engine not started');
+        // ── highlight → run-code translation ──
+        if (args._[0] === 'highlight') {
+            if (args.clear) {
+                args = { _: ['run-code', `async (page) => { await page.locator('#__pw_clear__').highlight().catch(() => {}); return "Cleared"; }`] };
+            }
+            else {
+                const parts = args._.slice(1);
+                if (!parts.length)
+                    return { text: 'Usage: highlight <locator>', isError: true };
+                // highlight <ref> → use aria-ref selector
+                if (parts.length === 1 && /^e\d+$/.test(parts[0])) {
+                    args = { _: ['run-code', `async (page) => { await page.locator('aria-ref=${parts[0]}').highlight(); return "Highlighted"; }`] };
+                }
+                else {
+                    const nth = args.nth !== undefined ? parseInt(String(args.nth), 10) : undefined;
+                    let locExpr;
+                    // highlight <role> "<name>" → getByRole(role, { name })
+                    if (parts.length >= 2 && /^[a-z]+$/.test(parts[0])) {
+                        const role = parts[0];
+                        const name = parts.slice(1).join(' ');
+                        locExpr = `page.getByRole(${JSON.stringify(role)}, { name: ${JSON.stringify(name)}, exact: true })`;
+                    }
+                    else {
+                        const loc = parts.join(' ');
+                        const isSelector = /[.#\[\]>:=]/.test(loc);
+                        locExpr = isSelector
+                            ? `page.locator(${JSON.stringify(loc)})`
+                            : `page.getByText(${JSON.stringify(loc)})`;
+                    }
+                    if (nth !== undefined)
+                        locExpr += `.nth(${nth})`;
+                    args = { _: ['run-code', `async (page) => { await ${locExpr}.highlight(); return "Highlighted"; }`] };
+                }
+            }
+        }
+        // ── >> chaining → run-code translation ──
+        const LOCATOR_ACTIONS = {
+            click: 'click', dblclick: 'dblclick', hover: 'hover',
+            check: 'check', uncheck: 'uncheck',
+            fill: 'fill', select: 'selectOption',
+        };
+        if (LOCATOR_ACTIONS[args._[0]] && args._.some(a => a.includes('>>'))) {
+            const action = LOCATOR_ACTIONS[args._[0]];
+            const positional = args._.slice(1);
+            // Find last >> — everything up to the token after it is the selector,
+            // everything after that is the action argument (e.g., value for fill).
+            let lastChainIdx = -1;
+            for (let i = 0; i < positional.length; i++) {
+                if (positional[i] === '>>' || positional[i].includes('>>'))
+                    lastChainIdx = i;
+            }
+            const selectorEnd = positional[lastChainIdx] !== '>>' && positional[lastChainIdx]?.includes('>>')
+                ? lastChainIdx // >> inside quoted token like ".nav >> button"
+                : lastChainIdx + 1;
+            const selector = positional.slice(0, selectorEnd + 1).join(' ');
+            const rest = positional.slice(selectorEnd + 1).join(' ');
+            const locExpr = `page.locator(${JSON.stringify(selector)})`;
+            const actionCall = rest
+                ? `${locExpr}.${action}(${JSON.stringify(rest)})`
+                : `${locExpr}.${action}()`;
+            args = { _: ['run-code', `async (page) => { await ${actionCall}; return "Done"; }`] };
+        }
+        const deps = this._deps || loadDeps();
+        const command = deps.commands[args._[0]];
+        if (!command)
+            throw new Error(`Unknown command: ${args._[0]}`);
+        const { toolName, toolParams } = deps.parseCommand(command, args);
+        // Commands like "close", "list", "kill-all" have empty toolName.
+        if (!toolName)
+            return { text: `Command "${args._[0]}" is not supported in engine mode.`, isError: true };
+        toolParams._meta = { cwd: args.cwd || process.cwd() };
+        const response = await this._backend.callTool(toolName, toolParams);
+        return formatResult(response);
+    }
+    /**
+     * Select the Playwright page matching the given URL.
+     * Uses backend.callTool('browser_tabs') to properly update the tab tracker.
+     */
+    async selectPageByUrl(targetUrl) {
+        if (!this._browserContext || !this._backend || !targetUrl)
+            return;
+        const pages = this._browserContext.pages();
+        const normalize = (u) => {
+            try {
+                const p = new URL(u);
+                return (p.origin + p.pathname).replace(/\/+$/, '');
+            }
+            catch {
+                return u.replace(/\/+$/, '');
+            }
+        };
+        const target = normalize(targetUrl);
+        for (let i = 0; i < pages.length; i++) {
+            if (normalize(pages[i].url()) === target) {
+                try {
+                    await this._backend.callTool('browser_tabs', { action: 'select', index: i });
+                }
+                catch { /* ignore */ }
+                return;
+            }
+        }
+    }
+    /**
+     * Shut down the browser and backend.
+     */
+    async close() {
+        this._connected = false;
+        if (this._commandServer) {
+            await this._commandServer.close();
+            this._commandServer = null;
+        }
+        if (this._backend) {
+            this._backend.serverClosed();
+            this._backend = null;
+        }
+        if (this._close) {
+            await this._close();
+            this._close = null;
+        }
+        if (this._chromeProc) {
+            try {
+                this._chromeProc.kill();
+            }
+            catch { /* ignore */ }
+            this._chromeProc = null;
+        }
+    }
+    // ─── CDP connect / reconnect ─────────────────────────────────────────────
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    async _connectToCdp(deps, config, clientInfo) {
+        const factory = deps.contextFactory(config);
+        const { browserContext, close } = await factory.createContext(clientInfo, new AbortController().signal, {});
+        this._browserContext = browserContext;
+        this._close = close;
+        const existingContextFactory = {
+            createContext: () => Promise.resolve({ browserContext, close }),
+        };
+        this._backend = new deps.BrowserServerBackend(config, existingContextFactory, { allTools: true });
+        await this._backend.initialize?.(clientInfo);
+        this._connected = true;
+        // Auto-select the first visible web page.
+        const pages = browserContext.pages();
+        const INTERNAL = /^(chrome|devtools|chrome-extension|about):/;
+        let selectedIdx = -1;
+        for (let i = 0; i < pages.length; i++) {
+            const pageUrl = pages[i].url();
+            if (!pageUrl || INTERNAL.test(pageUrl))
+                continue;
+            try {
+                const state = await pages[i].evaluate(() => document.visibilityState);
+                if (state === 'visible' && selectedIdx === -1) {
+                    selectedIdx = i;
+                }
+            }
+            catch { /* skip */ }
+        }
+        if (selectedIdx > 0) {
+            await this._backend.callTool('browser_tabs', { action: 'select', index: selectedIdx });
+        }
+        browserContext.on('close', () => {
+            this._connected = false;
+            if (this._reconnectInfo)
+                this._scheduleReconnect();
+        });
+    }
+    _scheduleReconnect() {
+        if (this._isReconnecting)
+            return;
+        this._isReconnecting = true;
+        this._doReconnect().catch((e) => {
+            console.warn('Reconnection failed:', e instanceof Error ? e.message : String(e));
+        });
+    }
+    async _doReconnect() {
+        if (!this._reconnectInfo)
+            return;
+        const { opts, config, clientInfo } = this._reconnectInfo;
+        const deps = this._deps || loadDeps();
+        const cdpPort = opts.cdpPort || 9222;
+        const cdpUrl = `http://localhost:${cdpPort}`;
+        console.log('Browser context closed. Waiting for Chrome to reconnect...');
+        let attempt = 0;
+        while (!this._connected) {
+            attempt++;
+            await new Promise(r => setTimeout(r, 1500));
+            // Check if engine was closed during reconnect
+            if (!this._reconnectInfo) {
+                console.log('Reconnection cancelled (engine closed).');
+                break;
+            }
+            try {
+                const res = await fetch(`${cdpUrl}/json/version`);
+                if (!res.ok) {
+                    console.warn(`Reconnect attempt ${attempt}: CDP responded with status ${res.status}`);
+                    continue;
+                }
+            }
+            catch (e) {
+                console.warn(`Reconnect attempt ${attempt}: CDP not available (${e instanceof Error ? e.message : String(e)})`);
+                continue;
+            }
+            // CDP is responding — reconnect
+            try {
+                // Clean up old backend before reconnecting
+                if (this._backend) {
+                    try {
+                        this._backend.serverClosed();
+                    }
+                    catch { /* ignore */ }
+                }
+                if (this._close) {
+                    try {
+                        await this._close();
+                    }
+                    catch { /* ignore */ }
+                }
+                this._backend = null;
+                this._browserContext = null;
+                this._close = null;
+                config.browser.cdpEndpoint = cdpUrl;
+                await this._connectToCdp(deps, config, clientInfo);
+                console.log(`Reconnected to Chrome CDP after ${attempt} attempt(s).`);
+            }
+            catch (e) {
+                console.warn(`Reconnect attempt ${attempt}: connection failed (${e instanceof Error ? e.message : String(e)})`);
+            }
+        }
+        this._isReconnecting = false;
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    // ─── Config builder ───────────────────────────────────────────────────────
+    async _buildConfig(opts, deps) {
+        const config = {
+            browser: {
+                browserName: 'chromium',
+                launchOptions: {
+                    channel: 'chrome',
+                    headless: !opts.headed,
+                },
+                contextOptions: {
+                    viewport: null,
+                },
+                isolated: false,
+                userDataDir: undefined,
+                cdpEndpoint: undefined,
+            },
+            server: {},
+            network: {},
+            timeouts: {
+                action: 5000,
+                navigation: 15000,
+            },
+        };
+        // Browser selection
+        if (opts.browser) {
+            switch (opts.browser) {
+                case 'firefox':
+                    config.browser.browserName = 'firefox';
+                    config.browser.launchOptions.channel = undefined;
+                    break;
+                case 'webkit':
+                    config.browser.browserName = 'webkit';
+                    config.browser.launchOptions.channel = undefined;
+                    break;
+                default:
+                    // chrome, msedge, chrome-beta, etc.
+                    config.browser.browserName = 'chromium';
+                    config.browser.launchOptions.channel = opts.browser;
+                    break;
+            }
+        }
+        // Persistent profile
+        if (opts.persistent || opts.profile) {
+            config.browser.userDataDir = opts.profile || undefined;
+        }
+        else if (!opts.extension) {
+            config.browser.isolated = true;
+        }
+        // CDP connect mode
+        if (opts.connect) {
+            const port = typeof opts.connect === 'number' ? opts.connect : 9222;
+            config.browser.cdpEndpoint = `http://localhost:${port}`;
+            config.browser.isolated = false;
+        }
+        return await deps.resolveConfig(config);
+    }
+}
+function formatResult(result) {
+    const isError = result.isError;
+    let text;
+    let image;
+    for (const item of result.content) {
+        if (item.type === 'text' && !text)
+            text = item.text;
+        if (item.type === 'image' && !image)
+            image = `data:${item.mimeType || 'image/png'};base64,${item.data}`;
+    }
+    return { isError, text, image };
+}
+//# sourceMappingURL=engine.js.map