playwright-repl 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # 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**
@@ -9,7 +43,6 @@
 - **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
-  - **Tab on empty line** cycles through all commands
 - Aliases excluded from ghost suggestions (still work when typed)
 
 ### Removed
@@ -118,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-repl",
-  "version": "0.2.1",
+  "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

@@ -1,12 +1,10 @@
 /**
- * Completion data — builds the list of items for dropdown autocomplete.
+ * Completion data — builds the list of items for ghost completion.
  *
- * Sources: COMMANDS from resolve.mjs, ALIASES from parser.mjs,
- * plus REPL meta-commands (.help, .exit, etc.).
+ * Sources: COMMANDS from resolve.mjs plus REPL meta-commands (.help, .exit, etc.).
  */
 
 import { COMMANDS } from './resolve.mjs';
-import { ALIASES } from './parser.mjs';
 
 // ─── Meta-commands ───────────────────────────────────────────────────────────
 
@@ -23,11 +21,18 @@ const META_COMMANDS = [
   { 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, aliases (with "→ target" description), and meta-commands.
+ * commands and meta-commands.
  */
 export function buildCompletionItems() {
   const items = [];
@@ -37,10 +42,8 @@ export function buildCompletionItems() {
     items.push({ cmd: name, desc: info.desc });
   }
 
-  // Aliases — show "→ target" as description
-  for (const [alias, target] of Object.entries(ALIASES)) {
-    items.push({ cmd: alias, desc: `→ ${target}` });
-  }
+  // Extra commands (not in COMMANDS but handled by REPL)
+  items.push(...EXTRA_COMMANDS);
 
   // Meta-commands
   items.push(...META_COMMANDS);

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

@@ -15,124 +15,12 @@ import { socketPath, daemonProfilesDir, isDaemonRunning, startDaemon } from './w
 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) {
@@ -143,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;
@@ -374,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 {
@@ -386,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();
@@ -531,21 +451,28 @@ export function promptStr(ctx) {
  * @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;
+  }
+  return [];
+}
+
 function attachGhostCompletion(rl, items) {
   if (!process.stdin.isTTY) return;  // no ghost text for piped input
 
-  const cmds = items.filter(i => !i.desc.startsWith('→')).map(i => i.cmd);
+  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 getMatches(input) {
-    if (input.length > 0 && !input.includes(' ')) {
-      return cmds.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`);
@@ -553,28 +480,20 @@ function attachGhostCompletion(rl, items) {
 
   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;
+    // 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 = '';
-        matches = [];
-        rl._insertString(text);
-        return;
-      }
-
-      // Tab cycles through matches
-      if (key.name === 'tab' && matches.length > 1) {
-        rl.output.write('\x1b[K');
         matchIdx = (matchIdx + 1) % matches.length;
         const input = rl.line || '';
-        renderGhost(matches[matchIdx].slice(input.length));
+        const suffix = matches[matchIdx].slice(input.length);
+        if (suffix) renderGhost(suffix);
         return;
       }
-
-      // Tab with single match accepts it
-      if (key.name === 'tab' && matches.length === 1) {
+      // Single match — accept it
+      if (ghost && matches.length === 1) {
         const text = ghost;
         rl.output.write('\x1b[K');
         ghost = '';
@@ -582,16 +501,19 @@ function attachGhostCompletion(rl, items) {
         rl._insertString(text);
         return;
       }
+      return;
     }
 
-    // Tab on empty input — show all commands as ghost suggestions
-    if (key && key.name === 'tab') {
-      if ((rl.line || '') === '') {
-        matches = cmds;
-        matchIdx = 0;
-        renderGhost(matches[0]);
+    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;
       }
-      return;
     }
 
     // Clear existing ghost text before readline processes the key
@@ -605,7 +527,7 @@ function attachGhostCompletion(rl, items) {
 
     // Render new ghost text if cursor is at end of line
     const input = rl.line || '';
-    matches = getMatches(input);
+    matches = getGhostMatches(cmds, input);
     matchIdx = 0;
     if (matches.length > 0 && rl.cursor === rl.line.length) {
       renderGhost(matches[0].slice(input.length));