@guanzhu.me/pw-cli 0.0.1 → 0.0.3

package/README.md

@@ -21,6 +21,7 @@ Raw Playwright is excellent for test suites and scripted automation, but ad hoc
 - Named profile support
 - `run-code` for inline JavaScript or piped stdin
 - `run-script` for executing local JavaScript files
+- `run-script` supports CommonJS-style scripts that use `require`, `module`, `exports`, `__filename`, and `__dirname`
 - Queue management for multi-step flows
 - Automatic browser launch when needed
 - XPath command conversion for common actions
@@ -73,6 +74,13 @@ Run a local script:
 pw-cli run-script ./scrape.js --url https://example.com
 ```
 
+Reuse a page that was opened through `pw-cli open`:
+
+```bash
+pw-cli open https://www.amazon.com
+pw-cli run-script ./collect-rank-node.js "wireless earbuds" --pages 3
+```
+
 Use XPath with common commands:
 
 ```bash

package/bin/pw-cli.js

@@ -760,12 +760,19 @@ async function main() {
     const openIdx = argv.indexOf('open');
     const afterOpen = argv.slice(openIdx + 1);
 
-    // If a URL is provided with open, split into two steps to avoid goto timeout:
-    // 1) spawn open (no URL) to start the browser daemon
-    // 2) navigate via run-code with waitUntil:'domcontentloaded' + timeout:0
-    //    so redirects (login flows, SPA routing) never time out
+    // If a URL is provided with open:
+    // - If a session is already running: open a new tab directly via our CDP executor
+    // - Otherwise: spawn open (no URL) to start the browser, then navigate via playwright-cli run-code
+    //   (lenient wait strategy so redirects/login flows/SPA routing never time out)
     const urlArg = afterOpen.find(a => !a.startsWith('-') && /^https?:\/\//.test(a));
     if (urlArg) {
+      const navCode = `async page => { const newPage = await page.context().newPage(); await newPage.goto(${JSON.stringify(urlArg)}, { waitUntil: 'domcontentloaded', timeout: 0 }); return newPage.url(); }`;
+      const alive = await isSessionAlive(session);
+      if (alive) {
+        // Browser already running — create a new tab directly, skip playwright-cli open
+        await handleRunCode(['run-code', navCode]);
+        return;
+      }
       const { spawnSync } = require('child_process');
       const openOnlyArgs = injectOpenDefaults(afterOpen.filter(a => a !== urlArg));
       const res = spawnSync(process.execPath, [cliPath, 'open', ...openOnlyArgs], {
@@ -776,8 +783,6 @@ async function main() {
         process.stderr.write('pw-cli: failed to open browser\n');
         process.exit(res.status || 1);
       }
-      // Replace open+url with a run-code navigation (lenient wait strategy)
-      const navCode = `async page => { await page.goto(${JSON.stringify(urlArg)}, { waitUntil: 'domcontentloaded', timeout: 0 }); return page.url(); }`;
       argv = ['run-code', navCode];
     } else {
       const enhanced = injectOpenDefaults(afterOpen);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanzhu.me/pw-cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Persistent Playwright browser CLI with headed defaults, profile support, queueing, and script execution",
   "bin": {
     "pw-cli": "./bin/pw-cli.js"

package/src/executor.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const Module = require('module');
 
 function isFunctionExpression(code) {
   const text = code.trim();
@@ -32,11 +33,39 @@ async function runCode(code, globals) {
     return runFunctionExpression(code, globals);
   }
 
+  return runProgram(code, globals);
+}
+
+async function runProgram(code, globals) {
   const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
   const fn = new AsyncFunction(...Object.keys(globals), code);
   return fn.call(globals, ...Object.values(globals));
 }
 
+async function withTemporaryGlobals(globals, fn) {
+  const previous = new Map();
+  const keys = Object.keys(globals);
+
+  for (const key of keys) {
+    const existed = Object.prototype.hasOwnProperty.call(globalThis, key);
+    previous.set(key, { existed, value: globalThis[key] });
+    globalThis[key] = globals[key];
+  }
+
+  try {
+    return await fn();
+  } finally {
+    for (const key of keys) {
+      const entry = previous.get(key);
+      if (!entry.existed) {
+        delete globalThis[key];
+      } else {
+        globalThis[key] = entry.value;
+      }
+    }
+  }
+}
+
 async function execCode(code, { browser, context, page, playwright }) {
   const globals = {
     browser,
@@ -47,7 +76,7 @@ async function execCode(code, { browser, context, page, playwright }) {
     console,
     process,
   };
-  return runCode(code, globals);
+  return withTemporaryGlobals(globals, () => runCode(code, globals));
 }
 
 async function execScript(scriptPath, scriptArgs, { browser, context, page, playwright }) {
@@ -59,19 +88,58 @@ async function execScript(scriptPath, scriptArgs, { browser, context, page, play
   }
 
   const code = fs.readFileSync(absPath, 'utf8');
+  const moduleDir = path.dirname(absPath);
+  const scriptModule = {
+    id: absPath,
+    filename: absPath,
+    path: moduleDir,
+    exports: {},
+    loaded: false,
+    children: [],
+    parent: require.main || module,
+  };
+  const localRequire = Module.createRequire(absPath);
+  const scriptRequire = function scriptRequire(id) {
+    try {
+      return localRequire(id);
+    } catch (error) {
+      if (
+        error &&
+        error.code === 'MODULE_NOT_FOUND' &&
+        typeof id === 'string' &&
+        !id.startsWith('.') &&
+        !path.isAbsolute(id)
+      ) {
+        return require(id);
+      }
+      throw error;
+    }
+  };
+
+  scriptRequire.resolve = localRequire.resolve.bind(localRequire);
+  scriptRequire.cache = require.cache;
+  scriptRequire.extensions = require.extensions;
+  scriptRequire.main = scriptModule;
+
+  scriptModule.require = scriptRequire;
+
   const globals = {
     browser,
     context,
     page,
     playwright,
     args: scriptArgs,
-    require,
+    require: scriptRequire,
+    module: scriptModule,
+    exports: scriptModule.exports,
     console,
     process,
     __filename: absPath,
-    __dirname: path.dirname(absPath),
+    __dirname: moduleDir,
   };
-  return runCode(code, globals);
+  const result = await withTemporaryGlobals(globals, () => runProgram(code, globals));
+  scriptModule.loaded = true;
+  return result === undefined ? scriptModule.exports : result;
 }
 
 module.exports = { execCode, execScript };