@guanzhu.me/pw-cli 0.0.15 → 0.0.17

package/bin/pw-cli.js

@@ -305,6 +305,68 @@ Example:
 `;
 }
 
+const REQUIRED_POSITIONAL_ARGS = new Map([
+  ['goto', { count: 1, usage: 'pw-cli goto <url>' }],
+  ['type', { count: 1, usage: 'pw-cli type <text>' }],
+  ['click', { count: 1, usage: 'pw-cli click <ref> [button]' }],
+  ['dblclick', { count: 1, usage: 'pw-cli dblclick <ref> [button]' }],
+  ['fill', { count: 2, usage: 'pw-cli fill <ref> <text>' }],
+  ['drag', { count: 2, usage: 'pw-cli drag <startRef> <endRef>' }],
+  ['hover', { count: 1, usage: 'pw-cli hover <ref>' }],
+  ['select', { count: 2, usage: 'pw-cli select <ref> <value>' }],
+  ['upload', { count: 1, usage: 'pw-cli upload <file>' }],
+  ['check', { count: 1, usage: 'pw-cli check <ref>' }],
+  ['uncheck', { count: 1, usage: 'pw-cli uncheck <ref>' }],
+  ['eval', { count: 1, usage: 'pw-cli eval <func> [ref]' }],
+  ['resize', { count: 2, usage: 'pw-cli resize <width> <height>' }],
+  ['press', { count: 1, usage: 'pw-cli press <key>' }],
+  ['keydown', { count: 1, usage: 'pw-cli keydown <key>' }],
+  ['keyup', { count: 1, usage: 'pw-cli keyup <key>' }],
+  ['mousemove', { count: 2, usage: 'pw-cli mousemove <x> <y>' }],
+  ['mousewheel', { count: 2, usage: 'pw-cli mousewheel <dx> <dy>' }],
+  ['tab-select', { count: 1, usage: 'pw-cli tab-select <index>' }],
+  ['cookie-get', { count: 1, usage: 'pw-cli cookie-get <name>' }],
+  ['cookie-set', { count: 2, usage: 'pw-cli cookie-set <name> <value>' }],
+  ['cookie-delete', { count: 1, usage: 'pw-cli cookie-delete <name>' }],
+  ['localstorage-get', { count: 1, usage: 'pw-cli localstorage-get <key>' }],
+  ['localstorage-set', { count: 2, usage: 'pw-cli localstorage-set <key> <value>' }],
+  ['localstorage-delete', { count: 1, usage: 'pw-cli localstorage-delete <key>' }],
+  ['sessionstorage-get', { count: 1, usage: 'pw-cli sessionstorage-get <key>' }],
+  ['sessionstorage-set', { count: 2, usage: 'pw-cli sessionstorage-set <key> <value>' }],
+  ['sessionstorage-delete', { count: 1, usage: 'pw-cli sessionstorage-delete <key>' }],
+  ['route', { count: 1, usage: 'pw-cli route <pattern>' }],
+]);
+
+function getPositionalsAfterCommand(argv, command) {
+  const commandIdx = argv.indexOf(command);
+  if (commandIdx === -1) return [];
+
+  const positionals = [];
+  for (let i = commandIdx + 1; i < argv.length; i++) {
+    const arg = argv[i];
+    if (typeof arg !== 'string' || arg.length === 0) continue;
+    if (arg === '--') {
+      positionals.push(...argv.slice(i + 1).filter(Boolean));
+      break;
+    }
+    if (!arg.startsWith('-')) {
+      positionals.push(arg);
+    }
+  }
+  return positionals;
+}
+
+function validateRequiredArgs(argv, command) {
+  const rule = REQUIRED_POSITIONAL_ARGS.get(command);
+  if (!rule) return;
+
+  const positionals = getPositionalsAfterCommand(argv, command);
+  if (positionals.length >= rule.count) return;
+
+  process.stderr.write(`pw-cli: ${command} requires ${rule.count === 1 ? 'an argument' : `${rule.count} arguments`}\n\nUsage: ${rule.usage}\n`);
+  process.exit(1);
+}
+
 // Management commands that don't need a running browser
 const MGMT_COMMANDS = new Set([
   'open', 'close', 'list', 'kill-all', 'close-all', 'delete-data',
@@ -753,6 +815,8 @@ async function main() {
     process.exit(1);
   }
 
+  validateRequiredArgs(rawArgv, command);
+
   // ── queue: batch actions and run them together ────────────────────────────
   if (command === 'queue') {
     await handleQueue(rawArgv);
@@ -771,6 +835,43 @@ async function main() {
     return;
   }
 
+  // ── Fast path: send command directly to playwright-cli daemon socket ────
+  // Skip heavy setup (npm root -g, require playwright, CDP probes) entirely.
+  // Only for commands that the daemon handles AND don't need local preprocessing.
+  if (command && !MGMT_COMMANDS.has(command)) {
+    // Build the args array the daemon expects: strip session flags, keep command + args
+    let fastArgs = [...rawArgv];
+    // Remove session flags (-s xxx / --session xxx / --session=xxx)
+    fastArgs = fastArgs.filter((a, i, arr) => {
+      if (a === '-s' || a === '--session') { arr[i + 1] = undefined; return false; }
+      if (a === undefined) return false;
+      if (a.startsWith('-s=') || a.startsWith('--session=')) return false;
+      return true;
+    }).filter(Boolean);
+
+    // Apply XPath conversion if needed
+    fastArgs = convertXPathCommand(fastArgs);
+
+    // Handle run-code wrapping for XPath-converted commands
+    if (fastArgs[0] === 'run-code' && fastArgs.length > 1) {
+      const code = fastArgs.slice(1).join(' ');
+      fastArgs = ['run-code', wrapCodeIfNeeded(code)];
+    }
+
+    const { sendCommand } = require('../src/fast-send');
+    const result = await sendCommand(fastArgs, session);
+    if (result !== null) {
+      // Daemon responded — use its result
+      if (result.isError) {
+        process.stderr.write(`${result.text}\n`);
+        process.exit(1);
+      }
+      if (result.text) process.stdout.write(result.text + '\n');
+      return;
+    }
+    // result === null means daemon not running — fall through to full path
+  }
+
   // ── From here on: delegate to playwright-cli (with enhancements) ─────────
   const cliPath = findPlaywrightCli();
   if (!cliPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanzhu.me/pw-cli",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Persistent Playwright browser CLI with headed defaults, profile support, queueing, and script execution",
   "bin": {
     "pw-cli": "./bin/pw-cli.js"
@@ -34,5 +34,13 @@
     "chromium",
     "testing"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wn0x00/pw-cli.git"
+  },
+  "homepage": "https://github.com/wn0x00/pw-cli#readme",
+  "bugs": {
+    "url": "https://github.com/wn0x00/pw-cli/issues"
+  },
   "license": "MIT"
 }

package/src/fast-send.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const net = require('net');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const HOME_DIR = os.homedir();
+const PW_CLI_DIR = path.join(HOME_DIR, '.pw-cli');
+const WORKSPACE_HASH = crypto.createHash('sha1')
+  .update(PW_CLI_DIR)
+  .digest('hex')
+  .substring(0, 16);
+
+function getSocketPath(sessionName = 'default') {
+  const socketName = `${sessionName}.sock`;
+  if (os.platform() === 'win32')
+    return `\\\\.\\pipe\\${WORKSPACE_HASH}-${socketName}`;
+  const socketsDir = process.env.PLAYWRIGHT_DAEMON_SOCKETS_DIR || path.join(os.tmpdir(), 'playwright-cli');
+  return path.join(socketsDir, WORKSPACE_HASH, socketName);
+}
+
+function getVersion() {
+  // Read version from session file (already written by playwright-cli daemon)
+  const sessionFile = path.join(
+    os.platform() === 'win32'
+      ? path.join(process.env.LOCALAPPDATA || path.join(HOME_DIR, 'AppData', 'Local'), 'ms-playwright', 'daemon')
+      : os.platform() === 'darwin'
+        ? path.join(HOME_DIR, 'Library', 'Caches', 'ms-playwright', 'daemon')
+        : path.join(process.env.XDG_CACHE_HOME || path.join(HOME_DIR, '.cache'), 'ms-playwright', 'daemon'),
+    WORKSPACE_HASH,
+    'default.session'
+  );
+  try {
+    const session = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+    return session.version;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert a string array to minimist-style object.
+ * The daemon expects { _: [cmd, arg1, ...], flagName: value, ... }.
+ */
+function toMinimistArgs(argv) {
+  const result = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    } else if (arg.startsWith('-') && arg.length === 2) {
+      const key = arg.slice(1);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    } else {
+      result._.push(arg);
+    }
+  }
+  return result;
+}
+
+/**
+ * Send a command directly to the playwright-cli daemon socket.
+ * Returns { text, isError } or null (daemon not running).
+ */
+function sendCommand(args, sessionName = 'default') {
+  const socketPath = getSocketPath(sessionName);
+  const version = getVersion();
+  if (!version) return Promise.resolve(null);
+
+  const minimistArgs = toMinimistArgs(args);
+
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath, () => {
+      const message = JSON.stringify({
+        id: 1,
+        method: 'run',
+        params: { args: minimistArgs, cwd: process.cwd() },
+        version,
+      }) + '\n';
+      socket.write(message);
+    });
+
+    let buf = '';
+    socket.on('data', chunk => {
+      buf += chunk.toString();
+      const nlIdx = buf.indexOf('\n');
+      if (nlIdx === -1) return;
+      const line = buf.slice(0, nlIdx);
+      clearTimeout(timer);
+      socket.destroy();
+      try {
+        const resp = JSON.parse(line);
+        if (resp.error) {
+          reject(new Error(resp.error));
+        } else {
+          resolve(resp.result);
+        }
+      } catch (e) {
+        reject(new Error('Invalid daemon response'));
+      }
+    });
+
+    socket.on('error', () => { clearTimeout(timer); resolve(null); }); // connection failed = daemon not running
+    const timer = setTimeout(() => { socket.destroy(); resolve(null); }, 3000);
+  });
+}
+
+module.exports = { sendCommand, getSocketPath, getVersion };