@guanzhu.me/pw-cli 0.0.15 → 0.0.16

package/bin/pw-cli.js

@@ -771,6 +771,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.16",
   "description": "Persistent Playwright browser CLI with headed defaults, profile support, queueing, and script execution",
   "bin": {
     "pw-cli": "./bin/pw-cli.js"

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 };