playwright-repl 0.26.0 → 0.27.0

package/dist/repl.js

@@ -8,9 +8,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
 import http from 'node:http';
-import { replVersion, parseInput, ALIASES, ALL_COMMANDS, buildCompletionItems, c, prettyJson, BridgeServer, COMMANDS, CATEGORIES, JS_CATEGORIES, filterResponse as filterResponseBase, resolveArgs, handleLocalCommand, } from '@playwright-repl/core';
-import { Engine } from './engine.js';
-import { SessionManager } from './recorder.js';
+import { replVersion, parseInput, ALIASES, ALL_COMMANDS, c, prettyJson, CDPRelayServer, COMMANDS, CATEGORIES, JS_CATEGORIES, filterResponse as filterResponseBase, resolveArgs, resolveCommand, } from '@playwright-repl/core';
 // ─── Response filtering ─────────────────────────────────────────────────────
 /** CLI wrapper: uses core filterResponse + ANSI-colors for error lines. */
 export function filterResponse(text, cmdName, opts) {
@@ -23,16 +21,14 @@ export function filterResponse(text, cmdName, opts) {
     return body.replace(/^(Error: .*)$/gm, `${c.red}$1${c.reset}`);
 }
 // ─── Meta-command handlers ──────────────────────────────────────────────────
-export function showHelp(bridge = false) {
+export function showHelp() {
     console.log(`\n${c.bold}Available commands:${c.reset}`);
     for (const [cat, cmds] of Object.entries(CATEGORIES)) {
         console.log(`  ${c.bold}${cat}:${c.reset} ${cmds.join(', ')}`);
     }
-    if (bridge) {
-        console.log(`\n${c.bold}JavaScript mode:${c.reset}`);
-        console.log(`  ${c.dim}Use Playwright API directly: await page.title(), page.locator('h1').click(), ...${c.reset}`);
-        console.log(`  ${c.dim}Type .help js for available Playwright methods${c.reset}`);
-    }
+    console.log(`\n${c.bold}JavaScript mode:${c.reset}`);
+    console.log(`  ${c.dim}Use Playwright API directly: await page.title(), page.locator('h1').click(), ...${c.reset}`);
+    console.log(`  ${c.dim}Type .help js for available Playwright methods${c.reset}`);
     console.log(`\n  ${c.dim}Type .help <command> for details, or .aliases for shortcuts${c.reset}`);
     console.log(`\n${c.bold}REPL meta-commands:${c.reset}`);
     console.log(`  .aliases              Show command aliases`);
@@ -48,12 +44,8 @@ export function showHelp(bridge = false) {
     console.log(`  .history clear        Clear command history`);
     console.log(`  .exit                 Exit REPL\n`);
 }
-export function showCommandHelp(cmd, bridge = false) {
+export function showCommandHelp(cmd) {
     if (cmd === 'js' || cmd === 'javascript') {
-        if (!bridge) {
-            console.log(`\n${c.dim}JavaScript mode is only available in bridge mode (--bridge).${c.reset}\n`);
-            return;
-        }
         console.log(`\n${c.bold}JavaScript mode — Playwright API:${c.reset}`);
         console.log(`  ${c.dim}Prefix with ${c.reset}await${c.dim} for async methods${c.reset}\n`);
         console.log(`  ${c.bold}Available globals:${c.reset}`);
@@ -127,6 +119,55 @@ export async function handleClose(ctx) {
         console.error(`${c.red}Error:${c.reset} ${err.message}`);
     }
 }
+// ─── Recording commands (start-recording, stop-recording, etc.) ────────────
+function handleRecordingCommand(ctx, cmdName, args) {
+    const { session } = ctx;
+    if (cmdName === 'start-recording') {
+        try {
+            const filename = args._[1] || undefined;
+            const file = session.startRecording(filename);
+            console.log(`${c.red}⏺${c.reset} Recording to ${c.bold}${file}${c.reset}`);
+            ctx.rl?.setPrompt(promptStr(ctx));
+        }
+        catch (err) {
+            console.log(`${c.yellow}${err.message}${c.reset}`);
+        }
+        return true;
+    }
+    if (cmdName === 'stop-recording') {
+        try {
+            const { filename, count } = session.save();
+            console.log(`${c.green}✓${c.reset} Saved ${count} commands to ${c.bold}${filename}${c.reset}`);
+            ctx.rl?.setPrompt(promptStr(ctx));
+        }
+        catch (err) {
+            console.log(`${c.yellow}${err.message}${c.reset}`);
+        }
+        return true;
+    }
+    if (cmdName === 'pause-recording') {
+        try {
+            const paused = session.togglePause();
+            console.log(paused ? `${c.yellow}⏸${c.reset} Recording paused` : `${c.red}⏺${c.reset} Recording resumed`);
+        }
+        catch (err) {
+            console.log(`${c.yellow}${err.message}${c.reset}`);
+        }
+        return true;
+    }
+    if (cmdName === 'discard-recording') {
+        try {
+            session.discard();
+            console.log(`${c.yellow}Recording discarded${c.reset}`);
+            ctx.rl?.setPrompt(promptStr(ctx));
+        }
+        catch (err) {
+            console.log(`${c.yellow}${err.message}${c.reset}`);
+        }
+        return true;
+    }
+    return false;
+}
 // ─── Session meta-commands (.record, .save, .pause, .discard, .replay) ──────
 export function handleSessionCommand(ctx, line) {
     const { session } = ctx;
@@ -213,13 +254,23 @@ export async function processLine(ctx, line) {
     }
     // ── Inline replay ──────────────────────────────────────────────
     if (line.startsWith('.replay')) {
-        const filename = line.split(/\s+/)[1];
+        const parts = line.split(/\s+/);
+        const filename = parts[1];
         if (!filename) {
-            console.log(`${c.yellow}Usage: .replay <filename>${c.reset}`);
+            console.log(`${c.yellow}Usage: .replay <filename> [--variable key=value ...]${c.reset}`);
             return;
         }
+        // Parse --variable key=value args
+        const variables = {};
+        for (let i = 2; i < parts.length; i++) {
+            if (parts[i] === '--variable' && parts[i + 1]) {
+                const [key, ...rest] = parts[++i].split('=');
+                if (key && rest.length > 0)
+                    variables[key] = rest.join('=');
+            }
+        }
         try {
-            const player = ctx.session.startReplay(filename);
+            const player = ctx.session.startReplay(filename, false, Object.keys(variables).length > 0 ? variables : undefined);
             console.log(`${c.blue}▶${c.reset} Replaying ${c.bold}${filename}${c.reset} (${player.commands.length} commands)\n`);
             while (!player.done) {
                 const cmd = player.next();
@@ -254,6 +305,9 @@ export async function processLine(ctx, line) {
         return handleKillAll(ctx);
     if (cmdName === 'close' || cmdName === 'close-all')
         return handleClose(ctx);
+    // ── Recording commands (start/stop/pause/discard-recording) ──
+    if (handleRecordingCommand(ctx, cmdName, args))
+        return;
     // ── Command transformations (verify, role-based, text, run-code) ──
     const resolved = resolveArgs(args);
     if (resolved._[0] === args._[0] && cmdName === 'verify') {
@@ -278,6 +332,10 @@ export async function processLine(ctx, line) {
             if (filtered !== null)
                 console.log(filtered);
         }
+        // Feed snapshot to recorder for ref-to-locator resolution
+        if (cmdName === 'snapshot' && result?.text && !result.isError) {
+            ctx.session.setSnapshot(result.text);
+        }
         if (result?.isError)
             ctx.errors++;
         ctx.commandCount++;
@@ -583,7 +641,7 @@ function attachGhostCompletion(rl, items) {
 // ─── Multi-line completion check ────────────────────────────────────────────
 /**
  * Returns true if the code string has balanced brackets/parens/braces.
- * Used to detect multi-line continuation in bridge mode.
+ * Used to detect multi-line continuation.
  */
 function isComplete(code) {
     let depth = 0;
@@ -610,8 +668,8 @@ function isComplete(code) {
     }
     return depth <= 0;
 }
-// ─── Bridge shared helpers ───────────────────────────────────────────────────
-function displayBridgeResult(result, silent) {
+// ─── Display helpers ────────────────────────────────────────────────────────
+function displayResult(result, silent) {
     if (result.image) {
         const isPdf = result.image.startsWith('data:application/pdf');
         const outDir = path.join(os.homedir(), isPdf ? 'pw-pdfs' : 'pw-screenshots');
@@ -621,8 +679,7 @@ function displayBridgeResult(result, silent) {
         const outPath = path.join(outDir, `${prefix}-${Date.now()}${ext}`);
         const b64 = result.image.replace(/^data:[^;]+;base64,/, '');
         fs.writeFileSync(outPath, Buffer.from(b64, 'base64'));
-        if (!silent)
-            console.log(`${isPdf ? 'PDF' : 'Screenshot'} saved to ${outPath}`);
+        console.log(`${isPdf ? 'PDF' : 'Screenshot'} saved to ${outPath}`);
     }
     else if (result.text) {
         const t = result.text.trim();
@@ -634,109 +691,148 @@ function displayBridgeResult(result, silent) {
         }
     }
 }
-// ─── Bridge replay mode ──────────────────────────────────────────────────────
-async function runSingleBridgeFile(srv, file, step, silent, prefixed = false) {
-    const log = (...args) => { if (!silent)
-        console.log(...args); };
-    const commands = loadReplayFile(file);
-    if (!prefixed) {
-        log(`${c.blue}▶${c.reset} Replaying ${c.bold}${file}${c.reset} (${commands.length} commands)\n`);
+// ─── Relay execution (keyword + JS) ─────────────────────────────────────────
+const AsyncFn = Object.getPrototypeOf(async function () { }).constructor;
+function isRelayExpression(code) {
+    const trimmed = code.trim();
+    if (trimmed.includes('\n'))
+        return false;
+    const withoutTrailing = trimmed.replace(/;$/, '');
+    if (withoutTrailing.includes(';'))
+        return false;
+    if (/^(const |let |var |if |for |while |switch |try |class |function )/.test(trimmed))
+        return false;
+    return true;
+}
+function formatRelayResult(value) {
+    if (value === undefined || value === null)
+        return 'Done';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    try {
+        return JSON.stringify(value, null, 2);
     }
-    let commandsRun = 0;
-    for (const cmd of commands) {
-        commandsRun++;
-        const indent = prefixed ? '  ' : '';
-        log(`${indent}${c.dim}[${commandsRun}/${commands.length}]${c.reset} ${cmd}`);
-        const startTime = performance.now();
-        // Local commands — handle in Node.js (e.g. video needs real filesystem)
-        const localResult = await handleLocalCommand(cmd, srv.context);
-        if (localResult) {
-            const elapsed = (performance.now() - startTime).toFixed(0);
-            log(localResult.isError ? `${c.red}${localResult.text}${c.reset}` : localResult.text);
-            log(`${c.dim}(${elapsed}ms)${c.reset}`);
-            if (localResult.isError) {
-                return { passed: false, commandsRun, errorMsg: `failed at [${commandsRun}/${commands.length}]: ${cmd}` };
-            }
-            continue;
-        }
-        const result = await srv.run(cmd);
-        const elapsed = (performance.now() - startTime).toFixed(0);
-        displayBridgeResult(result, silent);
-        log(`${c.dim}(${elapsed}ms)${c.reset}`);
-        if (result.isError) {
-            return { passed: false, commandsRun, errorMsg: `failed at [${commandsRun}/${commands.length}]: ${cmd}` };
+    catch {
+        return String(value);
+    }
+}
+async function relayExec(command, page, context, expect) {
+    const trimmed = command.trim();
+    // Keyword command → resolveCommand → jsExpr → direct execution
+    const resolved = resolveCommand(trimmed);
+    if (resolved) {
+        try {
+            const fn = new AsyncFn('page', 'context', 'expect', resolved.jsExpr);
+            const result = await fn(page, context, expect);
+            return { text: formatRelayResult(result), isError: false };
         }
-        if (step && commandsRun < commands.length) {
-            await new Promise((resolve) => {
-                process.stdout.write(`${c.dim}  Press Enter to continue...${c.reset}`);
-                process.stdin.once('data', () => { process.stdout.write('\r\x1b[K'); resolve(); });
-            });
+        catch (e) {
+            return { text: e instanceof Error ? e.message : String(e), isError: true };
         }
     }
-    if (!prefixed)
-        log(`\n${c.green}✓${c.reset} Replay complete`);
-    return { passed: true, commandsRun };
+    // JavaScript → AsyncFunction
+    const script = isRelayExpression(trimmed)
+        ? `return ${trimmed.replace(/;$/, '')}`
+        : trimmed;
+    try {
+        const fn = new AsyncFn('page', 'context', 'expect', script);
+        const result = await fn(page, context, expect);
+        return { text: formatRelayResult(result), isError: false };
+    }
+    catch (e) {
+        return { text: e instanceof Error ? e.message : String(e), isError: true };
+    }
 }
-async function runBridgeReplayMode(opts, srv) {
+// ─── Relay replay mode ──────────────────────────────────────────────────────
+async function runRelayReplayMode(opts, relay, browser, page, context, expect) {
     const silent = opts.silent || false;
     const log = (...args) => { if (!silent)
         console.log(...args); };
-    log('Waiting for extension to connect...');
-    try {
-        await srv.waitForConnection(30000);
-    }
-    catch (err) {
-        console.error(`${c.red}Error:${c.reset} ${err.message}`);
-        await srv.close();
-        process.exit(1);
-    }
-    log(`${c.green}✓${c.reset} Extension connected`);
     const files = resolveReplayFiles(opts.replay, ['.pw', '.js']);
     if (files.length === 0) {
         console.error(`${c.red}Error:${c.reset} No .pw or .js files found`);
-        await srv.close();
+        await browser.close().catch(() => { });
+        if (relay)
+            await relay.close();
         process.exit(1);
     }
-    if (files.length === 1) {
-        const { passed } = await runSingleBridgeFile(srv, files[0], opts.step || false, silent);
-        await srv.close();
-        process.exit(passed ? 0 : 1);
-    }
-    // Multi-file
-    log(`${c.blue}▶${c.reset} Running ${c.bold}${files.length}${c.reset} files\n`);
     const results = [];
     const totalStart = performance.now();
+    if (files.length > 1)
+        log(`${c.blue}▶${c.reset} Running ${c.bold}${files.length}${c.reset} files\n`);
     for (const file of files) {
         const basename = path.basename(file);
-        log(`${c.blue}▶${c.reset} ${c.bold}${basename}${c.reset}`);
+        const commands = loadReplayFile(file);
+        const prefixed = files.length > 1;
+        if (prefixed)
+            log(`${c.blue}▶${c.reset} ${c.bold}${basename}${c.reset}`);
+        else
+            log(`${c.blue}▶${c.reset} Replaying ${c.bold}${file}${c.reset} (${commands.length} commands)\n`);
         const fileStart = performance.now();
-        const { passed, commandsRun, errorMsg } = await runSingleBridgeFile(srv, file, opts.step || false, silent, true);
+        let commandsRun = 0;
+        let passed = true;
+        let errorMsg;
+        for (const cmd of commands) {
+            commandsRun++;
+            const indent = prefixed ? '  ' : '';
+            log(`${indent}${c.dim}[${commandsRun}/${commands.length}]${c.reset} ${cmd}`);
+            const startTime = performance.now();
+            const result = await relayExec(cmd, page, context, expect);
+            const elapsed = (performance.now() - startTime).toFixed(0);
+            if (result.text && result.text !== 'Done') {
+                log(`${indent}${result.isError ? `${c.red}${result.text}${c.reset}` : result.text}`);
+            }
+            log(`${indent}${c.dim}(${elapsed}ms)${c.reset}`);
+            if (result.isError) {
+                passed = false;
+                errorMsg = `failed at [${commandsRun}/${commands.length}]: ${cmd}`;
+                break;
+            }
+            if (opts.step && commandsRun < commands.length) {
+                await new Promise((resolve) => {
+                    process.stdout.write(`${c.dim}  Press Enter to continue...${c.reset}`);
+                    process.stdin.once('data', () => { process.stdout.write('\r\x1b[K'); resolve(); });
+                });
+            }
+        }
         const fileElapsed = ((performance.now() - fileStart) / 1000).toFixed(1);
-        const status = passed ? `${c.green}PASS${c.reset}` : `${c.red}FAIL${c.reset}`;
-        log(`  ${status} ${basename} ${c.dim}(${fileElapsed}s)${c.reset}\n`);
+        if (prefixed) {
+            const status = passed ? `${c.green}PASS${c.reset}` : `${c.red}FAIL${c.reset}`;
+            log(`  ${status} ${basename} ${c.dim}(${fileElapsed}s)${c.reset}\n`);
+        }
+        else if (passed) {
+            log(`\n${c.green}✓${c.reset} Replay complete`);
+        }
         results.push({ file: basename, passed, commands: commandsRun, error: errorMsg });
     }
-    const totalElapsed = ((performance.now() - totalStart) / 1000).toFixed(1);
-    const passCount = results.filter(r => r.passed).length;
-    const failCount = results.filter(r => !r.passed).length;
-    log(`${c.bold}─── Results ───${c.reset}`);
-    for (const r of results) {
-        const icon = r.passed ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
-        log(`  ${icon} ${r.file}${r.error ? ` — ${r.error}` : ''}`);
+    // Multi-file summary
+    if (files.length > 1) {
+        const totalElapsed = ((performance.now() - totalStart) / 1000).toFixed(1);
+        const passCount = results.filter(r => r.passed).length;
+        const failCount = results.filter(r => !r.passed).length;
+        log(`${c.bold}─── Results ───${c.reset}`);
+        for (const r of results) {
+            const icon = r.passed ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
+            log(`  ${icon} ${r.file}${r.error ? ` — ${r.error}` : ''}`);
+        }
+        log(`\n${passCount} passed, ${failCount} failed (${results.length} total, ${totalElapsed}s)`);
     }
-    log(`\n${passCount} passed, ${failCount} failed (${results.length} total, ${totalElapsed}s)`);
-    await srv.close();
+    await browser.close().catch(() => { });
+    if (relay)
+        await relay.close();
+    const failCount = results.filter(r => !r.passed).length;
     process.exit(failCount > 0 ? 1 : 0);
 }
-// ─── Bridge REPL loop ────────────────────────────────────────────────────────
-async function startBridgeLoop(opts, srv) {
+// ─── Relay REPL loop ────────────────────────────────────────────────────────
+async function startRelayLoop(opts, relay, browser, page, context, expect) {
     const silent = opts.silent || false;
     const log = (...args) => { if (!silent)
         console.log(...args); };
     const historyDir = path.join(os.homedir(), '.playwright-repl');
     const historyFile = path.join(historyDir, '.repl-history');
-    const sessionHistory = [];
-    const promptReady = `${c.cyan}pw>${c.reset} `;
+    const promptReady = `${c.cyan}relay>${c.reset} `;
     const promptCont = `${c.dim}...${c.reset} `;
     const rl = readline.createInterface({
         input: process.stdin,
@@ -750,12 +846,10 @@ async function startBridgeLoop(opts, srv) {
             rl.history.push(line);
     }
     catch { /* ignore */ }
-    attachGhostCompletion(rl, buildCompletionItems());
     let buffer = '';
     let processing = false;
     const commandQueue = [];
     async function handleLine(line) {
-        // Multi-line accumulation
         buffer = buffer ? buffer + '\n' + line : line;
         if (!isComplete(buffer)) {
             rl.setPrompt(promptCont);
@@ -768,58 +862,33 @@ async function startBridgeLoop(opts, srv) {
             return;
         // Meta-commands
         if (command === '.exit' || command === '.quit') {
-            await srv.close();
+            await browser.close().catch(() => { });
+            if (relay)
+                await relay.close();
             process.exit(0);
         }
         if (command === '.clear') {
             console.clear();
             return;
         }
-        if (command === '.history clear') {
-            sessionHistory.length = 0;
-            log('History cleared.');
-            return;
-        }
-        if (command === '.history') {
-            log(sessionHistory.length ? sessionHistory.join('\n') : '(no history)');
-            return;
-        }
-        if (command === '.help' || command === '?') {
-            showHelp(true);
-            return;
-        }
-        if (command.startsWith('.help ')) {
-            showCommandHelp(command.slice(6).trim(), true);
-            return;
-        }
-        if (command === '.aliases') {
-            showAliases();
-            return;
-        }
         // Record to history
-        sessionHistory.push(command);
         try {
             fs.mkdirSync(path.dirname(historyFile), { recursive: true });
             fs.appendFileSync(historyFile, command + '\n');
         }
-        catch (err) {
-            console.error(`${c.dim}Warning: could not write history: ${err.message}${c.reset}`);
-        }
-        // ── Local commands (video, etc. — need Node.js filesystem) ─────
-        const localResult = await handleLocalCommand(command, srv.context);
-        if (localResult) {
-            log(localResult.isError ? `${c.red}${localResult.text}${c.reset}` : localResult.text);
-            return;
-        }
-        if (!srv.connected) {
-            log(`${c.yellow}[not connected] Waiting for extension...${c.reset}`);
-            return;
-        }
+        catch { /* ignore */ }
         const startTime = performance.now();
-        const runOpts = opts.includeSnapshot ? { includeSnapshot: true } : undefined;
-        const result = await srv.run(command, runOpts);
+        const result = await relayExec(command, page, context, expect);
         const elapsed = (performance.now() - startTime).toFixed(0);
-        displayBridgeResult(result, silent);
+        if (result.text) {
+            // Pass command name so filterResponse keeps the right sections
+            const parsed = parseInput(command);
+            const cmdName = parsed?._[0];
+            const filtered = filterResponse(result.text, cmdName);
+            if (filtered !== null) {
+                log(result.isError ? `${c.red}${filtered}${c.reset}` : filtered);
+            }
+        }
         log(`${c.dim}(${elapsed}ms)${c.reset}`);
     }
     async function processQueue() {
@@ -832,23 +901,14 @@ async function startBridgeLoop(opts, srv) {
         processing = false;
         rl.prompt();
     }
-    // Print a status message above the current prompt line
-    function printStatus(msg) {
-        process.stdout.write('\r\x1b[K'); // clear current prompt line
-        console.log(msg);
-        rl.prompt(true);
-    }
-    if (!silent) {
-        srv.onConnect(() => printStatus(`${c.green}✓${c.reset} Extension connected`));
-        srv.onDisconnect(() => printStatus(`${c.yellow}Extension disconnected${c.reset}`));
-        srv.onEvent((event) => {
-            if (event.type === 'tab-attached' && event.url)
-                printStatus(`${c.green}✓${c.reset} Attached to tab: ${event.url}`);
-        });
-    }
     rl.prompt();
     rl.on('line', (line) => { commandQueue.push(line); processQueue(); });
-    rl.on('close', async () => { await srv.close(); process.exit(0); });
+    rl.on('close', async () => {
+        await browser.close().catch(() => { });
+        if (relay)
+            await relay.close();
+        process.exit(0);
+    });
     rl.on('SIGINT', () => {
         if (buffer) {
             buffer = '';
@@ -970,9 +1030,14 @@ async function tryHttpCommand(command, port) {
             req.write(body);
             req.end();
         });
-        const text = (result.text ?? '').replace(/^\s*\n+|\n+\s*$/g, '');
-        if (text)
-            process.stdout.write(text + '\n');
+        if (result.image) {
+            displayResult(result, false);
+        }
+        else {
+            const text = (result.text ?? '').replace(/^\s*\n+|\n+\s*$/g, '');
+            if (text)
+                process.stdout.write(text + '\n');
+        }
         process.exit(result.isError ? 1 : 0);
     }
     catch (e) {
@@ -1000,145 +1065,70 @@ export async function startRepl(opts = {}) {
         process.exit(1);
     }
     log(`${c.bold}${c.magenta}🎭 Playwright REPL${c.reset} ${c.dim}v${replVersion}${c.reset}`);
-    // ─── Standalone mode (new: serviceWorker.evaluate) ─────────────
-    if (!opts.bridge && !opts.connect && !opts.engine) {
-        const { EvaluateConnection, findExtensionPath } = await import('@playwright-repl/core');
-        const extPath = process.env.VITEST ? null : findExtensionPath(import.meta.url);
-        if (extPath) {
-            const conn = new EvaluateConnection();
-            log(`${c.dim}Launching Chromium with extension...${c.reset}`);
-            try {
-                const { chromium } = await import('playwright');
-                // Default to headed for evaluate mode (interactive REPL with extension)
-                await conn.start(extPath, { headed: opts.headed ?? true, chromium });
-                log(`${c.green}✓${c.reset} Browser ready (with extension)`);
-                if (opts.command) {
-                    const result = await conn.run(opts.command);
-                    process.stdout.write((result.text ?? '') + '\n');
-                    await conn.close();
-                    process.exit(result.isError ? 1 : 0);
-                }
-                // Start HTTP server if --http
-                if (opts.http) {
-                    try {
-                        await startHttpServer(opts.httpPort ?? DEFAULT_HTTP_PORT, conn, log);
-                    }
-                    catch (e) {
-                        log(`${c.yellow}⚠${c.reset} HTTP server failed: ${e.message}`);
-                    }
-                }
-                // --http runs as a console (no readline) unless --interactive is also set
-                if (opts.http && !opts.interactive && !(opts.replay && opts.replay.length > 0)) {
-                    log(`${c.dim}Console mode — send commands via HTTP. Ctrl+C to exit.${c.reset}\n`);
-                    await waitForShutdown(log);
-                    await conn.close();
-                    process.exit(0);
-                }
-                log(`${c.dim}Type .help for commands, JavaScript supported${c.reset}\n`);
-                if (opts.replay && opts.replay.length > 0) {
-                    await runBridgeReplayMode(opts, conn);
-                }
-                else {
-                    await startBridgeLoop(opts, conn);
-                }
-                return;
-            }
-            catch (err) {
-                log(`${c.yellow}⚠${c.reset} ${c.dim}Could not launch with extension: ${err.message}${c.reset}`);
-                log(`${c.dim}Falling back to standard engine...${c.reset}\n`);
+    // Default to standalone mode (launch own browser)
+    if (!opts.relay && !opts.connect) {
+        opts.relay = true;
+    }
+    // ─── Relay mode ───────────────────────────────────────────────────
+    if (opts.relay || opts.connect) {
+        const dynamicImport = Function('m', 'return import(m)');
+        const { chromium } = await dynamicImport('playwright');
+        const { expect: pwExpect } = await dynamicImport('@playwright/test').catch(() => ({ expect: undefined }));
+        let browser;
+        let relayCtx;
+        let relayPage;
+        let relay = null;
+        const headless = opts.headed === false; // explicit --headless
+        if (opts.connect) {
+            // Connect mode: attach to existing Chrome via extension + CDP relay
+            relay = new CDPRelayServer();
+            await relay.start();
+            log(`CDP relay listening on ${relay.cdpEndpoint()}`);
+            log(`Extension endpoint: ${relay.relayEndpoint()}`);
+            log('Waiting for extension to connect...');
+            await relay.waitForExtension(30000);
+            log(`${c.green}✓${c.reset} Extension connected`);
+            browser = await chromium.connectOverCDP(relay.cdpEndpoint());
+            relayCtx = browser.contexts()[0];
+            relayPage = relayCtx.pages()[0];
+            if (!relayPage) {
+                console.error(`${c.red}✗${c.reset} No page found — make sure a tab is open in Chrome`);
+                await relay.close();
+                process.exit(1);
             }
         }
-    }
-    // ─── Bridge mode ─────────────────────────────────────────────────
-    if (opts.bridge) {
-        const port = opts.bridgePort ?? 9876;
-        const srv = new BridgeServer();
-        await srv.start(port, { silent: !!opts.command });
-        log(`Bridge server listening on ws://localhost:${port}`);
+        else {
+            // Standalone mode (default): launch own browser
+            log(`${c.dim}Launching ${headless ? 'headless' : 'headed'} browser...${c.reset}`);
+            browser = await chromium.launch({
+                headless,
+                args: ['--no-first-run', '--no-default-browser-check'],
+            });
+            relayCtx = await browser.newContext();
+            relayPage = await relayCtx.newPage();
+        }
+        log(`${c.green}✓${c.reset} Connected to page: ${relayPage.url()}`);
+        const cleanup = async () => {
+            await browser.close().catch(() => { });
+            if (relay)
+                await relay.close();
+        };
         if (opts.command) {
-            await srv.waitForConnection(30000);
-            const result = await srv.run(opts.command);
-            process.stdout.write((result.text ?? '') + '\n');
-            srv.close();
+            const result = await relayExec(opts.command, relayPage, relayCtx, pwExpect);
+            if (result.text)
+                process.stdout.write(result.text + '\n');
+            await cleanup();
             process.exit(result.isError ? 1 : 0);
         }
-        // Start HTTP server if --http
-        if (opts.http) {
-            try {
-                await startHttpServer(opts.httpPort ?? DEFAULT_HTTP_PORT, srv, log);
-            }
-            catch (e) {
-                log(`${c.yellow}⚠${c.reset} HTTP server failed: ${e.message}`);
-            }
-        }
         if (opts.replay && opts.replay.length > 0) {
-            await runBridgeReplayMode(opts, srv);
-        }
-        else if (opts.http && !opts.interactive) {
-            log(`${c.dim}Console mode — send commands via HTTP. Ctrl+C to exit.${c.reset}\n`);
-            await waitForShutdown(log);
-            srv.close();
-            process.exit(0);
-        }
-        else {
-            log('Waiting for extension to connect...');
-            await startBridgeLoop(opts, srv);
+            await runRelayReplayMode(opts, relay, browser, relayPage, relayCtx, pwExpect);
+            return;
         }
+        log(`${c.dim}Type .help for commands, JavaScript supported${c.reset}\n`);
+        await startRelayLoop(opts, relay, browser, relayPage, relayCtx, pwExpect);
         return;
     }
-    // ─── Start engine (fallback) ────────────────────────────────────
-    log(`${c.dim}Type .help for commands${c.reset}\n`);
-    const conn = new Engine();
-    try {
-        await conn.start(opts);
-        log(`${c.green}✓${c.reset} Browser ready\n`);
-    }
-    catch (err) {
-        console.error(`${c.red}✗${c.reset} Failed to start: ${err.message}`);
-        process.exit(1);
-    }
-    if (opts.command) {
-        const parsed = parseInput(opts.command);
-        if (!parsed) {
-            process.stderr.write('Invalid command\n');
-            conn.close();
-            process.exit(1);
-            return; // unreachable, but satisfies TS control-flow
-        }
-        const result = await conn.run(parsed);
-        process.stdout.write((result.text ?? '') + '\n');
-        conn.close();
-        process.exit(result.isError ? 1 : 0);
-    }
-    // ─── Session + readline ──────────────────────────────────────────
-    const session = new SessionManager();
-    const historyDir = path.join(os.homedir(), '.playwright-repl');
-    const historyFile = path.join(historyDir, '.repl-history');
-    const ctx = { conn, session, rl: null, opts, log, historyFile, sessionHistory: [], commandCount: 0, errors: 0 };
-    // Auto-start recording if --record was passed
-    if (opts.record) {
-        const file = session.startRecording(opts.record);
-        log(`${c.red}⏺${c.reset} Recording to ${c.bold}${file}${c.reset}`);
-    }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: promptStr(ctx),
-        historySize: 500,
-    });
-    ctx.rl = rl;
-    try {
-        const hist = fs.readFileSync(historyFile, 'utf-8').split('\n').filter(Boolean).reverse();
-        for (const line of hist)
-            rl.history.push(line);
-    }
-    catch { /* ignore */ }
-    attachGhostCompletion(rl, buildCompletionItems());
-    // ─── Start ───────────────────────────────────────────────────────
-    if (opts.replay && opts.replay.length > 0) {
-        await runMultiReplayMode(ctx, opts.replay, opts.step || false);
-    }
-    else {
-        startCommandLoop(ctx);
-    }
+    // No mode matched — this shouldn't happen since relay is now the default
+    console.error(`${c.red}✗${c.reset} No execution mode selected. Use --relay or --connect.`);
+    process.exit(1);
 }