playwright-repl 0.3.0 → 0.7.10

package/examples/ghost-completion-demo.mjs

@@ -1,122 +0,0 @@
-#!/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/src/colors.mjs

@@ -1,17 +0,0 @@
-/**
- * Terminal color helpers.
- * No dependency — just ANSI escape codes.
- */
-
-export const c = {
-  reset:   '\x1b[0m',
-  bold:    '\x1b[1m',
-  dim:     '\x1b[2m',
-  red:     '\x1b[31m',
-  green:   '\x1b[32m',
-  yellow:  '\x1b[33m',
-  blue:    '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan:    '\x1b[36m',
-  gray:    '\x1b[90m',
-};

package/src/completion-data.mjs

@@ -1,53 +0,0 @@
-/**
- * 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/connection.mjs

@@ -1,119 +0,0 @@
-/**
- * DaemonConnection — persistent Unix socket client.
- *
- * Wire protocol: newline-delimited JSON.
- *
- * Send:    {"id":1,"method":"run","params":{"args":{...},"cwd":"/"},"version":"0.1.0"}\n
- * Receive: {"id":1,"result":{"text":"..."},"version":"0.1.0"}\n
- */
-
-import net from 'node:net';
-
-export class DaemonConnection {
-  constructor(sockPath, version) {
-    this.sockPath = sockPath;
-    this.version = version;
-    this.socket = null;
-    this.nextId = 1;
-    this.callbacks = new Map();
-    this.pendingBuffers = [];
-  }
-
-  async connect() {
-    return new Promise((resolve, reject) => {
-      const sock = net.createConnection(this.sockPath, () => {
-        this.socket = sock;
-        resolve(true);
-      });
-      sock.on('data', (buf) => this._onData(buf));
-      sock.on('error', (err) => {
-        if (!this.socket) reject(err);
-        else this._handleError(err);
-      });
-      sock.on('close', () => {
-        this.socket = null;
-        for (const cb of this.callbacks.values()) {
-          cb.reject(new Error('Connection closed'));
-        }
-        this.callbacks.clear();
-      });
-    });
-  }
-
-  get connected() {
-    return this.socket !== null && !this.socket.destroyed;
-  }
-
-  /**
-   * Send a raw message to the daemon.
-   * Returns the result from the daemon response.
-   */
-  async send(method, params = {}) {
-    if (!this.connected) throw new Error('Not connected to daemon');
-    const id = this.nextId++;
-    const msg = { id, method, params, version: this.version };
-    return new Promise((resolve, reject) => {
-      this.callbacks.set(id, { resolve, reject });
-      this.socket.write(JSON.stringify(msg) + '\n', (err) => {
-        if (err) {
-          this.callbacks.delete(id);
-          reject(err);
-        }
-      });
-    });
-  }
-
-  /**
-   * Send a "run" command — the standard way to execute CLI commands.
-   * `minimistArgs` is a pre-parsed minimist object, e.g. { _: ["click", "e5"] }
-   */
-  async run(minimistArgs) {
-    return this.send('run', { args: minimistArgs, cwd: process.cwd() });
-  }
-
-  close() {
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = null;
-    }
-  }
-
-  // ─── Internal: newline-delimited JSON parsing ────────────────────────
-
-  _onData(buffer) {
-    let end = buffer.indexOf('\n');
-    if (end === -1) {
-      this.pendingBuffers.push(buffer);
-      return;
-    }
-    this.pendingBuffers.push(buffer.slice(0, end));
-    this._dispatch(Buffer.concat(this.pendingBuffers).toString());
-    let start = end + 1;
-    end = buffer.indexOf('\n', start);
-    while (end !== -1) {
-      this._dispatch(buffer.toString(undefined, start, end));
-      start = end + 1;
-      end = buffer.indexOf('\n', start);
-    }
-    this.pendingBuffers = [buffer.slice(start)];
-  }
-
-  _dispatch(message) {
-    try {
-      const obj = JSON.parse(message);
-      if (obj.id && this.callbacks.has(obj.id)) {
-        const cb = this.callbacks.get(obj.id);
-        this.callbacks.delete(obj.id);
-        if (obj.error) cb.reject(new Error(obj.error));
-        else cb.resolve(obj.result);
-      }
-    } catch {
-      // Ignore parse errors on partial messages
-    }
-  }
-
-  _handleError(err) {
-    if (err.code !== 'EPIPE')
-      console.error(`\n⚠️  Socket error: ${err.message}`);
-  }
-}

package/src/index.mjs

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,87 +0,0 @@
-/**
- * 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,151 +0,0 @@
-/**
- * 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;
-}