playwright-repl 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## v0.3.0 — Page Scripts & run-code
+
+**2026-02-17**
+
+### Features
+
+- **`run-code` auto-wrap**: Type Playwright code directly — no boilerplate needed
+  - `run-code page.title()` → auto-wraps as `async (page) => { return await page.title() }`
+  - `run-code await page.click('a')` → wraps without `return` for statement keywords
+  - `run-code async (page) => ...` → pass-through for full function expressions
+- **Raw parsing for `run-code` / `eval`**: Expressions are preserved as a single raw string — parentheses, braces, quotes, and operators no longer get split by the tokenizer
+- **Red error messages**: Daemon errors (`### Error` sections) now display in red
+- **Verify commands**: `verify-text`, `verify-element`, `verify-value`, `verify-list` now use real functions via `buildRunCode` instead of template strings
+
+### Refactored
+
+- **Page scripts module** (`src/page-scripts.mjs`): Extracted all run-code templates into real async functions (`verifyText`, `actionByText`, `fillByText`, etc.) — testable, readable, no manual escaping
+- **`buildRunCode` helper**: Converts real functions to daemon-compatible code strings using `fn.toString()` + `JSON.stringify()`
+- **Consolidated `actionByText`**: Merged `clickByText`, `dblclickByText`, `hoverByText` into a single function with dynamic dispatch via `loc[action]()`
+- **Removed `esc()` helper and ~150 lines of template strings** from `repl.mjs`
+
+### Fixed
+
+- **Ghost completion for prefix commands**: Typing "close" now correctly cycles to both "close" and "close-all" (previously only showed "close-all")
+- **Removed Tab-on-empty-line**: No longer shows all commands when pressing Tab on empty input
+
+### Tests
+
+- 100 new tests (154 → 254 total across 13 test files)
+- New `test/page-scripts.test.mjs` — 21 tests for page-script functions and `buildRunCode`
+- Daemon-compatibility test: verifies generated code is a valid function expression
+
+---
+
+## v0.2.1 — Ghost Completion
+
+**2026-02-17**
+
+### Features
+
+- **Ghost completion**: Fish-shell style inline suggestions — type a prefix and see dimmed suggestion text after the cursor
+  - **Tab** cycles through matches (e.g., `go` → goto, go-back, go-forward)
+  - **Right Arrow** accepts the current suggestion
+- Aliases excluded from ghost suggestions (still work when typed)
+
+### Removed
+
+- Removed readline's built-in Tab completer (replaced entirely by ghost completion)
+
+---
+
 ## v0.2.0 — MCP Server
 
 **2026-02-16**
@@ -100,7 +151,7 @@ First public release of playwright-repl — an interactive REPL for Playwright b
 - Connects to Playwright's MCP terminal daemon over Unix socket / named pipe
 - Wire-compatible with `playwright-cli` — produces identical JSON messages
 - Requires `playwright >= 1.59.0-alpha` (daemon code in `lib/mcp/terminal/`)
-- 218 tests, 96% statement coverage
+- 218 tests at initial release
 
 ### Known Limitations
 

package/README.md

@@ -210,10 +210,10 @@ Or with a visible browser:
 |---------|-------|-------------|
 | `snapshot` | `s` | Accessibility tree with element refs |
 | `screenshot` | `ss` | Take a screenshot |
-| `eval <expr>` | `e` | Evaluate JavaScript |
+| `eval <expr>` | `e` | Evaluate JavaScript in browser context |
 | `console` | `con` | Browser console messages |
 | `network` | `net` | Network requests log |
-| `run-code <code>` | — | Run Playwright code directly |
+| `run-code <code>` | — | Run Playwright code with `page` object |
 
 ### Assertions
 
@@ -382,6 +382,54 @@ playwright-repl --replay examples/04-replay-session.pw --step --headed
 playwright-repl --replay examples/05-ci-pipe.pw --silent
 ```
 
+## eval & run-code
+
+Two ways to run custom code from the REPL:
+
+### eval — Browser Context
+
+Runs JavaScript inside the browser page (via `page.evaluate`). Use browser globals like `document`, `window`, `location`:
+
+```
+pw> eval document.title
+"Installation | Playwright"
+
+pw> eval window.location.href
+"https://playwright.dev/docs/intro"
+
+pw> eval document.querySelectorAll('a').length
+42
+```
+
+### run-code — Playwright API
+
+Runs code with full access to the Playwright `page` object. The REPL auto-wraps your code — just write the body:
+
+```
+pw> run-code page.url()
+→ async (page) => { return await page.url() }
+"https://playwright.dev/docs/intro"
+
+pw> run-code page.locator('h1').textContent()
+→ async (page) => { return await page.locator('h1').textContent() }
+"Installation"
+
+pw> run-code await page.locator('.nav a').allTextContents()
+→ async (page) => { await page.locator('.nav a').allTextContents() }
+```
+
+For multiple statements, use semicolons:
+
+```
+pw> run-code const u = await page.url(); const t = await page.title(); return {u, t}
+```
+
+Full function expressions also work:
+
+```
+pw> run-code async (page) => { await page.waitForSelector('.loaded'); return await page.title(); }
+```
+
 ## Architecture
 
 ![Architecture](architecture-diagram.png)

package/examples/ghost-completion-demo.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Ghost completion demo — standalone test for inline suggestions.
+ *
+ * Run:  node examples/ghost-completion-demo.mjs
+ *
+ * Type a prefix (e.g. "go") and see dimmed suggestion text.
+ * Tab cycles through matches, Right Arrow accepts.
+ */
+
+import readline from 'node:readline';
+
+const COMMANDS = [
+  'click', 'check', 'close', 'console', 'cookie-get', 'cookie-list',
+  'dblclick', 'drag', 'eval', 'fill', 'goto', 'go-back', 'go-forward',
+  'hover', 'network', 'open', 'press', 'reload', 'screenshot', 'select',
+  'snapshot', 'type', 'uncheck', 'upload',
+  '.help', '.aliases', '.status', '.exit',
+];
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: '\x1b[36mpw>\x1b[0m ',
+});
+
+// ─── Ghost completion via _ttyWrite ─────────────────────────────────────────
+
+let ghost = '';
+let matches = [];
+let matchIdx = 0;
+
+function getMatches(input) {
+  if (input.length > 0 && !input.includes(' ')) {
+    return COMMANDS.filter(cmd => cmd.startsWith(input) && cmd !== input);
+  }
+  return [];
+}
+
+function renderGhost(suffix) {
+  ghost = suffix;
+  rl.output.write(`\x1b[2m${ghost}\x1b[0m\x1b[${ghost.length}D`);
+}
+
+const origTtyWrite = rl._ttyWrite.bind(rl);
+rl._ttyWrite = function (s, key) {
+  if (ghost && key) {
+    // Right-arrow-at-end accepts ghost suggestion
+    if (key.name === 'right' && rl.cursor === rl.line.length) {
+      const text = ghost;
+      rl.output.write('\x1b[K');
+      ghost = '';
+      matches = [];
+      rl._insertString(text);
+      return;
+    }
+
+    // Tab cycles through matches (or accepts if only one)
+    if (key.name === 'tab') {
+      if (matches.length > 1) {
+        rl.output.write('\x1b[K');
+        matchIdx = (matchIdx + 1) % matches.length;
+        const input = rl.line || '';
+        renderGhost(matches[matchIdx].slice(input.length));
+        return;
+      }
+      // Single match — accept it
+      const text = ghost;
+      rl.output.write('\x1b[K');
+      ghost = '';
+      matches = [];
+      rl._insertString(text);
+      return;
+    }
+  }
+
+  // Tab on empty input — show all commands as ghost suggestions
+  if (key && key.name === 'tab') {
+    if ((rl.line || '') === '') {
+      matches = COMMANDS;
+      matchIdx = 0;
+      renderGhost(matches[0]);
+    }
+    return;
+  }
+
+  // Clear existing ghost text before readline processes the key
+  if (ghost) {
+    rl.output.write('\x1b[K');
+    ghost = '';
+  }
+
+  // Let readline handle the key normally
+  origTtyWrite(s, key);
+
+  // Render new ghost text if cursor is at end of line
+  const input = rl.line || '';
+  matches = getMatches(input);
+  matchIdx = 0;
+  if (matches.length > 0 && rl.cursor === rl.line.length) {
+    renderGhost(matches[0].slice(input.length));
+  }
+};
+
+// ─── REPL loop ──────────────────────────────────────────────────────────────
+
+console.log('Ghost completion demo — Tab cycles matches, Right Arrow accepts\n');
+rl.prompt();
+
+rl.on('line', (line) => {
+  if (line.trim() === '.exit') {
+    rl.close();
+    return;
+  }
+  console.log(`  → ${line.trim() || '(empty)'}`);
+  rl.prompt();
+});
+
+rl.on('close', () => {
+  console.log('\nBye!');
+  process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-repl",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Interactive REPL for Playwright browser automation — keyword-driven testing from your terminal",
   "type": "module",
   "bin": {

package/src/completion-data.mjs

@@ -0,0 +1,53 @@
+/**
+ * Completion data — builds the list of items for ghost completion.
+ *
+ * Sources: COMMANDS from resolve.mjs plus REPL meta-commands (.help, .exit, etc.).
+ */
+
+import { COMMANDS } from './resolve.mjs';
+
+// ─── Meta-commands ───────────────────────────────────────────────────────────
+
+const META_COMMANDS = [
+  { cmd: '.help',      desc: 'Show available commands' },
+  { cmd: '.aliases',   desc: 'Show command aliases' },
+  { cmd: '.status',    desc: 'Show connection status' },
+  { cmd: '.reconnect', desc: 'Reconnect to daemon' },
+  { cmd: '.record',    desc: 'Start recording commands' },
+  { cmd: '.save',      desc: 'Stop recording and save' },
+  { cmd: '.pause',     desc: 'Pause/resume recording' },
+  { cmd: '.discard',   desc: 'Discard current recording' },
+  { cmd: '.replay',    desc: 'Replay a recorded session' },
+  { cmd: '.exit',      desc: 'Exit REPL' },
+];
+
+const EXTRA_COMMANDS = [
+  { cmd: 'verify-text',    desc: 'Assert text is visible on page' },
+  { cmd: 'verify-element', desc: 'Assert element exists by role and name' },
+  { cmd: 'verify-value',   desc: 'Assert input/select/checkbox value' },
+  { cmd: 'verify-list',    desc: 'Assert list contains expected items' },
+];
+
+// ─── Build completion items ──────────────────────────────────────────────────
+
+/**
+ * Returns a sorted array of `{ cmd, desc }` for all completable items:
+ * commands and meta-commands.
+ */
+export function buildCompletionItems() {
+  const items = [];
+
+  // Primary commands
+  for (const [name, info] of Object.entries(COMMANDS)) {
+    items.push({ cmd: name, desc: info.desc });
+  }
+
+  // Extra commands (not in COMMANDS but handled by REPL)
+  items.push(...EXTRA_COMMANDS);
+
+  // Meta-commands
+  items.push(...META_COMMANDS);
+
+  items.sort((a, b) => a.cmd.localeCompare(b.cmd));
+  return items;
+}

package/src/index.mjs

@@ -1,15 +1,16 @@
-/**
- * playwright-repl — public API
- *
- * Usage as CLI:
- *   npx playwright-repl [options]
- *
- * Usage as library:
- *   import { DaemonConnection, parseInput, SessionRecorder } from 'playwright-repl';
- */
-
-export { DaemonConnection } from './connection.mjs';
-export { parseInput, ALIASES, ALL_COMMANDS } from './parser.mjs';
-export { SessionRecorder, SessionPlayer } from './recorder.mjs';
-export { socketPath, isDaemonRunning, startDaemon, findWorkspaceDir } from './workspace.mjs';
-export { startRepl } from './repl.mjs';
+/**
+ * playwright-repl — public API
+ *
+ * Usage as CLI:
+ *   npx playwright-repl [options]
+ *
+ * Usage as library:
+ *   import { DaemonConnection, parseInput, SessionRecorder } from 'playwright-repl';
+ */
+
+export { DaemonConnection } from './connection.mjs';
+export { parseInput, ALIASES, ALL_COMMANDS } from './parser.mjs';
+export { SessionRecorder, SessionPlayer } from './recorder.mjs';
+export { socketPath, isDaemonRunning, startDaemon, findWorkspaceDir } from './workspace.mjs';
+export { startRepl } from './repl.mjs';
+export { buildCompletionItems } from './completion-data.mjs';

package/src/page-scripts.mjs

@@ -0,0 +1,87 @@
+/**
+ * Page-context functions for run-code commands.
+ *
+ * Each function is a real, testable async function that takes (page, ...args).
+ * buildRunCode() converts them to code strings via Function.toString(),
+ * following the same pattern as playwright-repl-extension/lib/page-scripts.js.
+ */
+
+// ─── Helper ─────────────────────────────────────────────────────────────────
+
+/**
+ * Wraps a function into a run-code args object.
+ * Uses fn.toString() + JSON.stringify() — no manual escaping needed.
+ *
+ * The daemon's browser_run_code calls: `await (code)(page)`
+ * So `code` must be a function expression, not an IIFE.
+ */
+export function buildRunCode(fn, ...args) {
+  const serialized = args.map(a => JSON.stringify(a)).join(', ');
+  return { _: ['run-code', `async (page) => (${fn.toString()})(page, ${serialized})`] };
+}
+
+// ─── Verify functions ───────────────────────────────────────────────────────
+
+export async function verifyText(page, text) {
+  if (await page.getByText(text).filter({ visible: true }).count() === 0)
+    throw new Error('Text not found: ' + text);
+}
+
+export async function verifyElement(page, role, name) {
+  if (await page.getByRole(role, { name }).count() === 0)
+    throw new Error('Element not found: ' + role + ' "' + name + '"');
+}
+
+export async function verifyValue(page, ref, expected) {
+  const el = page.locator('[aria-ref="' + ref + '"]');
+  const v = await el.inputValue();
+  if (v !== expected)
+    throw new Error('Expected "' + expected + '", got "' + v + '"');
+}
+
+export async function verifyList(page, ref, items) {
+  const loc = page.locator('[aria-ref="' + ref + '"]');
+  for (const item of items) {
+    if (await loc.getByText(item).count() === 0)
+      throw new Error('Item not found: ' + item);
+  }
+}
+
+// ─── Text locator actions ───────────────────────────────────────────────────
+
+export async function actionByText(page, text, action) {
+  let loc = page.getByText(text, { exact: true });
+  if (await loc.count() === 0) loc = page.getByRole('button', { name: text });
+  if (await loc.count() === 0) loc = page.getByRole('link', { name: text });
+  if (await loc.count() === 0) loc = page.getByText(text);
+  await loc[action]();
+}
+
+export async function fillByText(page, text, value) {
+  let loc = page.getByLabel(text);
+  if (await loc.count() === 0) loc = page.getByPlaceholder(text);
+  if (await loc.count() === 0) loc = page.getByRole('textbox', { name: text });
+  await loc.fill(value);
+}
+
+export async function selectByText(page, text, value) {
+  let loc = page.getByLabel(text);
+  if (await loc.count() === 0) loc = page.getByRole('combobox', { name: text });
+  await loc.selectOption(value);
+}
+
+export async function checkByText(page, text) {
+  const item = page.getByRole('listitem').filter({ hasText: text });
+  if (await item.count() > 0) { await item.getByRole('checkbox').check(); return; }
+  let loc = page.getByLabel(text);
+  if (await loc.count() === 0) loc = page.getByRole('checkbox', { name: text });
+  await loc.check();
+}
+
+export async function uncheckByText(page, text) {
+  const item = page.getByRole('listitem').filter({ hasText: text });
+  if (await item.count() > 0) { await item.getByRole('checkbox').uncheck(); return; }
+  let loc = page.getByLabel(text);
+  if (await loc.count() === 0) loc = page.getByRole('checkbox', { name: text });
+  await loc.uncheck();
+}

package/src/parser.mjs

@@ -1,141 +1,151 @@
-/**
- * Input parser — transforms human input into minimist-style args.
- *
- * Flow: "c e5" → alias resolve → ["click", "e5"] → minimist → { _: ["click", "e5"] }
- *
- * The resulting object is sent to the daemon as-is. The daemon runs
- * parseCliCommand() which maps it to a tool call.
- */
-
-import { minimist, COMMANDS } from './resolve.mjs';
-
-// ─── Command aliases ─────────────────────────────────────────────────────────
-
-export const ALIASES = {
-  // Navigation
-  'o':    'open',
-  'g':    'goto',
-  'go':   'goto',
-  'back': 'go-back',
-  'fwd':  'go-forward',
-  'r':    'reload',
-
-  // Interaction
-  'c':    'click',
-  'dc':   'dblclick',
-  't':    'type',
-  'f':    'fill',
-  'h':    'hover',
-  'p':    'press',
-  'sel':  'select',
-  'chk':  'check',
-  'unchk':'uncheck',
-
-  // Inspection
-  's':    'snapshot',
-  'snap': 'snapshot',
-  'ss':   'screenshot',
-  'e':    'eval',
-  'con':  'console',
-  'net':  'network',
-
-  // Tabs
-  'tl':   'tab-list',
-  'tn':   'tab-new',
-  'tc':   'tab-close',
-  'ts':   'tab-select',
-
-  // Assertions (Phase 2 — mapped to daemon tools that exist but have no CLI keywords)
-  'vt':   'verify-text',
-  've':   'verify-element',
-  'vv':   'verify-value',
-  'vl':   'verify-list',
-
-  // Session
-  'q':    'close',
-  'ls':   'list',
-};
-
-// ─── Known boolean options ───────────────────────────────────────────────────
-
-export const booleanOptions = new Set([
-  'headed', 'persistent', 'extension', 'submit', 'clear',
-  'fullPage', 'includeStatic',
-]);
-
-// ─── All known commands ──────────────────────────────────────────────────────
-
-export const ALL_COMMANDS = Object.keys(COMMANDS);
-
-// ─── Tokenizer ───────────────────────────────────────────────────────────────
-
-/**
- * Tokenize input respecting quoted strings.
- * "fill e7 'hello world'" → ["fill", "e7", "hello world"]
- */
-function tokenize(line) {
-  const tokens = [];
-  let current = '';
-  let inQuote = null;
-
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if (inQuote) {
-      if (ch === inQuote) {
-        inQuote = null;
-      } else {
-        current += ch;
-      }
-    } else if (ch === '"' || ch === "'") {
-      inQuote = ch;
-    } else if (ch === ' ' || ch === '\t') {
-      if (current) {
-        tokens.push(current);
-        current = '';
-      }
-    } else {
-      current += ch;
-    }
-  }
-  if (current) tokens.push(current);
-  return tokens;
-}
-
-// ─── Main parse function ─────────────────────────────────────────────────────
-
-/**
- * Parse a REPL input line into a minimist args object ready for the daemon.
- * Returns null if the line is empty.
- */
-export function parseInput(line) {
-  const tokens = tokenize(line);
-  if (tokens.length === 0) return null;
-
-  // Resolve alias
-  const cmd = tokens[0].toLowerCase();
-  if (ALIASES[cmd]) tokens[0] = ALIASES[cmd];
-
-  // Parse with minimist (same lib and boolean set as playwright-cli)
-  const args = minimist(tokens, { boolean: [...booleanOptions] });
-
-  // Stringify non-boolean values (playwright-cli does this)
-  for (const key of Object.keys(args)) {
-    if (key === '_') continue;
-    if (typeof args[key] !== 'boolean')
-      args[key] = String(args[key]);
-  }
-  for (let i = 0; i < args._.length; i++)
-    args._[i] = String(args._[i]);
-
-  // Remove boolean options set to false that weren't explicitly passed.
-  // minimist sets all declared booleans to false by default, but the
-  // daemon rejects unknown options like --headed false.
-  for (const opt of booleanOptions) {
-    if (args[opt] === false) {
-      const hasExplicitNo = tokens.some(t => t === `--no-${opt}`);
-      if (!hasExplicitNo) delete args[opt];
-    }
-  }
-
-  return args;
-}
+/**
+ * Input parser — transforms human input into minimist-style args.
+ *
+ * Flow: "c e5" → alias resolve → ["click", "e5"] → minimist → { _: ["click", "e5"] }
+ *
+ * The resulting object is sent to the daemon as-is. The daemon runs
+ * parseCliCommand() which maps it to a tool call.
+ */
+
+import { minimist, COMMANDS } from './resolve.mjs';
+
+// ─── Command aliases ─────────────────────────────────────────────────────────
+
+export const ALIASES = {
+  // Navigation
+  'o':    'open',
+  'g':    'goto',
+  'go':   'goto',
+  'back': 'go-back',
+  'fwd':  'go-forward',
+  'r':    'reload',
+
+  // Interaction
+  'c':    'click',
+  'dc':   'dblclick',
+  't':    'type',
+  'f':    'fill',
+  'h':    'hover',
+  'p':    'press',
+  'sel':  'select',
+  'chk':  'check',
+  'unchk':'uncheck',
+
+  // Inspection
+  's':    'snapshot',
+  'snap': 'snapshot',
+  'ss':   'screenshot',
+  'e':    'eval',
+  'con':  'console',
+  'net':  'network',
+
+  // Tabs
+  'tl':   'tab-list',
+  'tn':   'tab-new',
+  'tc':   'tab-close',
+  'ts':   'tab-select',
+
+  // Assertions (Phase 2 — mapped to daemon tools that exist but have no CLI keywords)
+  'vt':   'verify-text',
+  've':   'verify-element',
+  'vv':   'verify-value',
+  'vl':   'verify-list',
+
+  // Session
+  'q':    'close',
+  'ls':   'list',
+};
+
+// ─── Known boolean options ───────────────────────────────────────────────────
+
+export const booleanOptions = new Set([
+  'headed', 'persistent', 'extension', 'submit', 'clear',
+  'fullPage', 'includeStatic',
+]);
+
+// ─── All known commands ──────────────────────────────────────────────────────
+
+export const ALL_COMMANDS = Object.keys(COMMANDS);
+
+// ─── Tokenizer ───────────────────────────────────────────────────────────────
+
+/**
+ * Tokenize input respecting quoted strings.
+ * "fill e7 'hello world'" → ["fill", "e7", "hello world"]
+ */
+function tokenize(line) {
+  const tokens = [];
+  let current = '';
+  let inQuote = null;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (ch === ' ' || ch === '\t') {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+// ─── Main parse function ─────────────────────────────────────────────────────
+
+/**
+ * Parse a REPL input line into a minimist args object ready for the daemon.
+ * Returns null if the line is empty.
+ */
+// Commands where everything after the keyword is a single raw argument
+const RAW_COMMANDS = new Set(['run-code', 'eval']);
+
+export function parseInput(line) {
+  const tokens = tokenize(line);
+  if (tokens.length === 0) return null;
+
+  // Resolve alias
+  const cmd = tokens[0].toLowerCase();
+  if (ALIASES[cmd]) tokens[0] = ALIASES[cmd];
+
+  // For run-code / eval, preserve the rest of the line as a single raw string
+  if (RAW_COMMANDS.has(tokens[0])) {
+    const cmdLen = line.match(/^\s*\S+/)[0].length;
+    const rest = line.slice(cmdLen).trim();
+    return rest ? { _: [tokens[0], rest] } : { _: [tokens[0]] };
+  }
+
+  // Parse with minimist (same lib and boolean set as playwright-cli)
+  const args = minimist(tokens, { boolean: [...booleanOptions] });
+
+  // Stringify non-boolean values (playwright-cli does this)
+  for (const key of Object.keys(args)) {
+    if (key === '_') continue;
+    if (typeof args[key] !== 'boolean')
+      args[key] = String(args[key]);
+  }
+  for (let i = 0; i < args._.length; i++)
+    args._[i] = String(args._[i]);
+
+  // Remove boolean options set to false that weren't explicitly passed.
+  // minimist sets all declared booleans to false by default, but the
+  // daemon rejects unknown options like --headed false.
+  for (const opt of booleanOptions) {
+    if (args[opt] === false) {
+      const hasExplicitNo = tokens.some(t => t === `--no-${opt}`);
+      if (!hasExplicitNo) delete args[opt];
+    }
+  }
+
+  return args;
+}

package/src/repl.mjs

@@ -9,129 +9,18 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { execSync } from 'node:child_process';
 
-import { replVersion, COMMANDS } from './resolve.mjs';
+import { replVersion } from './resolve.mjs';
 import { DaemonConnection } from './connection.mjs';
 import { socketPath, daemonProfilesDir, isDaemonRunning, startDaemon } from './workspace.mjs';
 import { parseInput, ALIASES, ALL_COMMANDS } from './parser.mjs';
 import { SessionManager } from './recorder.mjs';
+import { buildCompletionItems } from './completion-data.mjs';
+import {
+  buildRunCode, verifyText, verifyElement, verifyValue, verifyList,
+  actionByText, fillByText, selectByText, checkByText, uncheckByText,
+} from './page-scripts.mjs';
 import { c } from './colors.mjs';
 
-// ─── Verify commands → run-code translation ─────────────────────────────────
-
-/**
- * The daemon has browser_verify_* tools but no CLI keyword mappings.
- * We intercept verify-* commands here and translate them to run-code calls
- * that use the equivalent Playwright API.
- */
-export function verifyToRunCode(cmdName, positionalArgs) {
-  const esc = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-
-  switch (cmdName) {
-    case 'verify-text': {
-      const text = positionalArgs.join(' ');
-      if (!text) return null;
-      return { _: ['run-code', `async (page) => { if (await page.getByText('${esc(text)}').filter({ visible: true }).count() === 0) throw new Error('Text not found: ${esc(text)}'); }`] };
-    }
-    case 'verify-element': {
-      const [role, ...nameParts] = positionalArgs;
-      const name = nameParts.join(' ');
-      if (!role || !name) return null;
-      return { _: ['run-code', `async (page) => { if (await page.getByRole('${esc(role)}', { name: '${esc(name)}' }).count() === 0) throw new Error('Element not found: ${esc(role)} "${esc(name)}"'); }`] };
-    }
-    case 'verify-value': {
-      const [ref, ...valueParts] = positionalArgs;
-      const value = valueParts.join(' ');
-      if (!ref || !value) return null;
-      return { _: ['run-code', `async (page) => { const el = page.locator('[aria-ref="${esc(ref)}"]'); const v = await el.inputValue(); if (v !== '${esc(value)}') throw new Error('Expected "${esc(value)}", got "' + v + '"'); }`] };
-    }
-    case 'verify-list': {
-      const [ref, ...items] = positionalArgs;
-      if (!ref || items.length === 0) return null;
-      const checks = items.map(item => `if (await loc.getByText('${esc(item)}').count() === 0) throw new Error('Item not found: ${esc(item)}');`).join(' ');
-      return { _: ['run-code', `async (page) => { const loc = page.locator('[aria-ref="${esc(ref)}"]'); ${checks} }`] };
-    }
-    default:
-      return null;
-  }
-}
-
-// ─── Text-to-action via Playwright native locators ──────────────────────────
-
-/**
- * Build a run-code args object that uses Playwright's native text locators.
- * e.g. click "Active"       → page.getByText("Active").click()
- *      fill "Email" "test"  → page.getByLabel("Email").fill("test")
- *      check "Buy groceries" → listitem with text → checkbox.check()
- */
-export function textToRunCode(cmdName, textArg, extraArgs) {
-  const esc = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-  const text = esc(textArg);
-
-  switch (cmdName) {
-    case 'click':
-      return { _: ['run-code', `async (page) => {
-  let loc = page.getByText('${text}', { exact: true });
-  if (await loc.count() === 0) loc = page.getByRole('button', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByRole('link', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByText('${text}');
-  await loc.click();
-}`] };
-    case 'dblclick':
-      return { _: ['run-code', `async (page) => {
-  let loc = page.getByText('${text}', { exact: true });
-  if (await loc.count() === 0) loc = page.getByRole('button', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByRole('link', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByText('${text}');
-  await loc.dblclick();
-}`] };
-    case 'hover':
-      return { _: ['run-code', `async (page) => {
-  let loc = page.getByText('${text}', { exact: true });
-  if (await loc.count() === 0) loc = page.getByRole('button', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByRole('link', { name: '${text}' });
-  if (await loc.count() === 0) loc = page.getByText('${text}');
-  await loc.hover();
-}`] };
-    case 'fill': {
-      const value = esc(extraArgs[0] || '');
-      // Try getByLabel first, fall back to getByPlaceholder, then getByRole('textbox')
-      return { _: ['run-code', `async (page) => {
-  let loc = page.getByLabel('${text}');
-  if (await loc.count() === 0) loc = page.getByPlaceholder('${text}');
-  if (await loc.count() === 0) loc = page.getByRole('textbox', { name: '${text}' });
-  await loc.fill('${value}');
-}`] };
-    }
-    case 'select': {
-      const value = esc(extraArgs[0] || '');
-      return { _: ['run-code', `async (page) => {
-  let loc = page.getByLabel('${text}');
-  if (await loc.count() === 0) loc = page.getByRole('combobox', { name: '${text}' });
-  await loc.selectOption('${value}');
-}`] };
-    }
-    case 'check':
-      // Scope to listitem/group with matching text, then find checkbox inside
-      return { _: ['run-code', `async (page) => {
-  const item = page.getByRole('listitem').filter({ hasText: '${text}' });
-  if (await item.count() > 0) { await item.getByRole('checkbox').check(); return; }
-  let loc = page.getByLabel('${text}');
-  if (await loc.count() === 0) loc = page.getByRole('checkbox', { name: '${text}' });
-  await loc.check();
-}`] };
-    case 'uncheck':
-      return { _: ['run-code', `async (page) => {
-  const item = page.getByRole('listitem').filter({ hasText: '${text}' });
-  if (await item.count() > 0) { await item.getByRole('checkbox').uncheck(); return; }
-  let loc = page.getByLabel('${text}');
-  if (await loc.count() === 0) loc = page.getByRole('checkbox', { name: '${text}' });
-  await loc.uncheck();
-}`] };
-    default:
-      return null;
-  }
-}
-
 // ─── Response filtering ─────────────────────────────────────────────────────
 
 export function filterResponse(text) {
@@ -142,7 +31,9 @@ export function filterResponse(text) {
     if (newline === -1) continue;
     const title = section.substring(0, newline).trim();
     const content = section.substring(newline + 1).trim();
-    if (title === 'Result' || title === 'Error' || title === 'Modal state')
+    if (title === 'Error')
+      kept.push(`${c.red}${content}${c.reset}`);
+    else if (title === 'Result' || title === 'Modal state')
       kept.push(content);
   }
   return kept.length > 0 ? kept.join('\n') : null;
@@ -373,9 +264,23 @@ export async function processLine(ctx, line) {
   if (cmdName === 'close' || cmdName === 'close-all') return handleClose(ctx);
 
   // ── Verify commands → run-code translation ──────────────────
-  const verifyCommands = ['verify-text', 'verify-element', 'verify-value', 'verify-list'];
-  if (verifyCommands.includes(cmdName)) {
-    const translated = verifyToRunCode(cmdName, args._.slice(1));
+  const verifyFns = {
+    'verify-text': verifyText,
+    'verify-element': verifyElement,
+    'verify-value': verifyValue,
+    'verify-list': verifyList,
+  };
+  if (verifyFns[cmdName]) {
+    const pos = args._.slice(1);
+    const fn = verifyFns[cmdName];
+    let translated = null;
+    if (cmdName === 'verify-text') {
+      const text = pos.join(' ');
+      if (text) translated = buildRunCode(fn, text);
+    } else if (pos[0] && pos.length >= 2) {
+      const rest = cmdName === 'verify-list' ? pos.slice(1) : pos.slice(1).join(' ');
+      translated = buildRunCode(fn, pos[0], rest);
+    }
     if (translated) {
       args = translated;
     } else {
@@ -385,15 +290,31 @@ export async function processLine(ctx, line) {
   }
 
   // ── Auto-resolve text to native Playwright locator ─────────
-  const refCommands = ['click', 'dblclick', 'hover', 'fill', 'select', 'check', 'uncheck'];
-  if (refCommands.includes(cmdName) && args._[1] && !/^e\d+$/.test(args._[1])) {
+  const textFns = {
+    click: actionByText, dblclick: actionByText, hover: actionByText,
+    fill: fillByText, select: selectByText, check: checkByText, uncheck: uncheckByText,
+  };
+  if (textFns[cmdName] && args._[1] && !/^e\d+$/.test(args._[1])) {
     const textArg = args._[1];
     const extraArgs = args._.slice(2);
-    const runCodeArgs = textToRunCode(cmdName, textArg, extraArgs);
-    if (runCodeArgs) {
-      ctx.log(`${c.dim}→ ${runCodeArgs._[1]}${c.reset}`);
-      args = runCodeArgs;
-    }
+    const fn = textFns[cmdName];
+    let runCodeArgs;
+    if (fn === actionByText) runCodeArgs = buildRunCode(fn, textArg, cmdName);
+    else if (cmdName === 'fill' || cmdName === 'select') runCodeArgs = buildRunCode(fn, textArg, extraArgs[0] || '');
+    else runCodeArgs = buildRunCode(fn, textArg);
+    const argsHint = extraArgs.length > 0 ? ` ${extraArgs.join(' ')}` : '';
+    ctx.log(`${c.dim}→ ${cmdName} "${textArg}"${argsHint} (via run-code)${c.reset}`);
+    args = runCodeArgs;
+  }
+
+  // ── Auto-wrap run-code body with async (page) => { ... } ──
+  if (cmdName === 'run-code' && args._[1] && !args._[1].startsWith('async')) {
+    const STMT = /^(await|return|const|let|var|for|if|while|throw|try)\b/;
+    const body = !args._[1].includes(';') && !STMT.test(args._[1])
+      ? `return await ${args._[1]}`
+      : args._[1];
+    args = { _: ['run-code', `async (page) => { ${body} }`] };
+    ctx.log(`${c.dim}→ ${args._[1]}${c.reset}`);
   }
 
   const startTime = performance.now();
@@ -518,26 +439,100 @@ export function promptStr(ctx) {
   return `${prefix}${c.cyan}pw>${c.reset} `;
 }
 
-// ─── Tab completer ──────────────────────────────────────────────────────────
-
-export function completer(line) {
-  const parts = line.split(/\s+/);
-  if (parts.length <= 1) {
-    const prefix = parts[0] || '';
-    const allNames = [...ALL_COMMANDS, ...Object.keys(ALIASES)];
-    const metas = ['.help', '.aliases', '.status', '.reconnect', '.exit',
-                   '.record', '.save', '.replay', '.pause', '.discard'];
-    const hits = [...allNames, ...metas].filter(n => n.startsWith(prefix));
-    return [hits.length ? hits : allNames, prefix];
+// ─── Ghost completion (inline suggestion) ───────────────────────────────────
+
+/**
+ * Attaches ghost-text completion to a readline interface.
+ * Shows dimmed inline suggestion after the cursor; Tab or Right Arrow accepts it.
+ *
+ * Uses _ttyWrite wrapper instead of _writeToOutput because Node 22+ optimizes
+ * single-character appends and doesn't always trigger a full line refresh.
+ *
+ * @param {readline.Interface} rl
+ * @param {Array<{cmd: string, desc: string}>} items - from buildCompletionItems()
+ */
+/**
+ * Returns matching commands for ghost completion.
+ * When the input exactly matches a command AND there are longer matches,
+ * the exact match is included so the user can cycle through all options.
+ */
+export function getGhostMatches(cmds, input) {
+  if (input.length > 0 && !input.includes(' ')) {
+    const longer = cmds.filter(cmd => cmd.startsWith(input) && cmd !== input);
+    if (longer.length > 0 && cmds.includes(input)) longer.push(input);
+    return longer;
   }
-  const cmd = ALIASES[parts[0]] || parts[0];
-  const helpText = COMMANDS[cmd]?.options || [];
-  const lastPart = parts[parts.length - 1];
-  if (lastPart.startsWith('--')) {
-    const hits = helpText.filter(o => o.startsWith(lastPart));
-    return [hits, lastPart];
+  return [];
+}
+
+function attachGhostCompletion(rl, items) {
+  if (!process.stdin.isTTY) return;  // no ghost text for piped input
+
+  const cmds = items.map(i => i.cmd);
+  let ghost = '';
+  let matches = [];   // all matching commands for current input
+  let matchIdx = 0;   // which match is currently shown
+
+  function renderGhost(suffix) {
+    ghost = suffix;
+    rl.output.write(`\x1b[2m${ghost}\x1b[0m\x1b[${ghost.length}D`);
   }
-  return [[], line];
+
+  const origTtyWrite = rl._ttyWrite.bind(rl);
+  rl._ttyWrite = function (s, key) {
+    // Tab handling — based on matches, not ghost text
+    if (key && key.name === 'tab') {
+      // Cycle through multiple matches
+      if (matches.length > 1) {
+        rl.output.write('\x1b[K');
+        ghost = '';
+        matchIdx = (matchIdx + 1) % matches.length;
+        const input = rl.line || '';
+        const suffix = matches[matchIdx].slice(input.length);
+        if (suffix) renderGhost(suffix);
+        return;
+      }
+      // Single match — accept it
+      if (ghost && matches.length === 1) {
+        const text = ghost;
+        rl.output.write('\x1b[K');
+        ghost = '';
+        matches = [];
+        rl._insertString(text);
+        return;
+      }
+      return;
+    }
+
+    if (ghost && key) {
+      // Right-arrow-at-end accepts ghost suggestion
+      if (key.name === 'right' && rl.cursor === rl.line.length) {
+        const text = ghost;
+        rl.output.write('\x1b[K');
+        ghost = '';
+        matches = [];
+        rl._insertString(text);
+        return;
+      }
+    }
+
+    // Clear existing ghost text before readline processes the key
+    if (ghost) {
+      rl.output.write('\x1b[K');
+      ghost = '';
+    }
+
+    // Let readline handle the key normally
+    origTtyWrite(s, key);
+
+    // Render new ghost text if cursor is at end of line
+    const input = rl.line || '';
+    matches = getGhostMatches(cmds, input);
+    matchIdx = 0;
+    if (matches.length > 0 && rl.cursor === rl.line.length) {
+      renderGhost(matches[0].slice(input.length));
+    }
+  };
 }
 
 // ─── REPL ────────────────────────────────────────────────────────────────────
@@ -585,7 +580,6 @@ export async function startRepl(opts = {}) {
     output: process.stdout,
     prompt: promptStr(ctx),
     historySize: 500,
-    completer,
   });
   ctx.rl = rl;
 
@@ -594,6 +588,8 @@ export async function startRepl(opts = {}) {
     for (const line of hist) rl.history.push(line);
   } catch {}
 
+  attachGhostCompletion(rl, buildCompletionItems());
+
   // ─── Start ───────────────────────────────────────────────────────
 
   if (opts.replay) {