@guanzhu.me/pw-cli 0.0.9 → 0.0.11

package/bin/pw-cli.js

@@ -603,17 +603,32 @@ EXAMPLES
 // run-script — delegates to our CDP-based executor
 // ---------------------------------------------------------------------------
 async function handleRunScript(rawArgv) {
-  const { getConnection, killBrowser } = require('../src/browser-manager');
+  const { getConnection } = require('../src/browser-manager');
   const { execScript } = require('../src/executor');
 
   // parse: pw-cli [global-opts] run-script <file> [script-args...]
   const rsIdx = rawArgv.indexOf('run-script');
   const afterRs = rawArgv.slice(rsIdx + 1);
   const globalBefore = rawArgv.slice(0, rsIdx);
+  const options = parsePwCliGlobalOptions(globalBefore);
+
+  // Separate flags (before script path) from script path + script args
+  const flags = [];
+  let restIdx = 0;
+  for (let i = 0; i < afterRs.length; i++) {
+    if (afterRs[i].startsWith('-')) {
+      flags.push(afterRs[i]);
+    } else {
+      restIdx = i;
+      break;
+    }
+  }
+  // Merge any flags after run-script into options
+  const afterOptions = parsePwCliGlobalOptions(flags);
+  Object.assign(options, afterOptions);
 
-  // extract --headless from global opts
-  const headless = hasFlag(globalBefore, '--headless');
-  const [scriptPath, ...scriptArgs] = afterRs;
+  const positionals = afterRs.slice(restIdx);
+  const [scriptPath, ...scriptArgs] = positionals;
 
   if (!scriptPath) {
     process.stderr.write('pw-cli: run-script requires a script path\n\nUsage: pw-cli run-script <file.js> [args...]\n');
@@ -624,12 +639,12 @@ async function handleRunScript(rawArgv) {
     process.exit(3);
   }
 
-  const conn = await getConnection({ headless, profile: 'default', port: 9223 });
+  const conn = await getConnection(options);
   try {
     const result = await execScript(scriptPath, scriptArgs, conn);
     if (result !== undefined) console.log(result);
   } catch (err) {
-    process.stderr.write(`pw-cli: ${err.message}\n`);
+    process.stderr.write(`pw-cli: ${err.message || err}\n`);
     process.exit(1);
   } finally {
     await conn.browser.close();
@@ -693,6 +708,12 @@ async function main() {
   const rawArgv = process.argv.slice(2);
   const { command, session } = getCommandAndSession(rawArgv);
 
+  if (hasFlag(rawArgv, '--version', '-V')) {
+    const pkg = require('../package.json');
+    console.log(`${pkg.name}@${pkg.version}`);
+    return;
+  }
+
   if (!command || command === 'help' || (rawArgv.length === 1 && hasFlag(rawArgv, '--help', '-h'))) {
     printMainHelp();
     return;
@@ -724,14 +745,15 @@ async function main() {
   }
 
   // Ensures a browser is reachable via CDP; if not, spawns playwright-cli open first.
+  // Returns the CDP port number.
   async function ensureBrowserRunning() {
     const { getPlaywrightCliCdpPort } = require('../src/browser-manager');
     const { probeCDP } = require('../src/utils');
     const { readState } = require('../src/state');
     const cliPort = getPlaywrightCliCdpPort();
-    if (cliPort && await probeCDP(cliPort, 2000)) return;
+    if (cliPort && await probeCDP(cliPort, 2000)) return cliPort;
     const state = readState();
-    if (state && await probeCDP(state.port, 2000)) return;
+    if (state && await probeCDP(state.port, 2000)) return state.port;
     // No browser reachable — start one via playwright-cli
     const { spawnSync } = require('child_process');
     const res = spawnSync(process.execPath, [cliPath, 'open', '--headed', '--persistent', '--profile', DEFAULT_PROFILE], {
@@ -742,30 +764,31 @@ async function main() {
       process.stderr.write('pw-cli: failed to open browser\n');
       process.exit(res.status || 1);
     }
+    // After spawning, re-detect the port
+    const newCliPort = getPlaywrightCliCdpPort();
+    if (newCliPort) return newCliPort;
+    const newState = readState();
+    return newState ? newState.port : null;
   }
 
-  // ── goto: navigate the tracked active tab ────────────────────────────────
+  // ── goto: navigate the active tab (detected via CDP /json/list) ──────────
   if (command === 'goto') {
     const gotoIdx = rawArgv.indexOf('goto');
     const afterGoto = rawArgv.slice(gotoIdx + 1);
     const rawUrl = afterGoto.find(a => !a.startsWith('-'));
     if (rawUrl) {
       const fullUrl = /^https?:\/\//.test(rawUrl) ? rawUrl : `https://${rawUrl}`;
-      const activeTabFile = JSON.stringify(path.join(PW_CLI_DIR, 'active-tab.json'));
+      const cdpPort = await ensureBrowserRunning();
+      const { fetchActivePageUrl } = require('../src/utils');
+      const activeUrl = await fetchActivePageUrl(cdpPort);
       const navCode = `async (page, context) => {
         const pages = context.pages();
         let target = pages[pages.length - 1] || page;
-        try {
-          const saved = JSON.parse(require('fs').readFileSync(${activeTabFile}, 'utf8'));
-          const match = pages.find(p => p.url() === saved.url);
-          if (match) target = match;
-        } catch {}
+        ${activeUrl ? `const match = pages.find(p => p.url() === ${JSON.stringify(activeUrl)});
+        if (match) target = match;` : ''}
         await target.goto(${JSON.stringify(fullUrl)}, { waitUntil: 'domcontentloaded', timeout: 0 });
-        const resultUrl = target.url();
-        try { require('fs').writeFileSync(${activeTabFile}, JSON.stringify({ url: resultUrl })); } catch {}
-        return resultUrl;
+        return target.url();
       }`;
-      await ensureBrowserRunning();
       await handleRunCode(['run-code', navCode]);
       return;
     }
@@ -812,13 +835,10 @@ async function main() {
     const rawUrlArg = afterOpen.find(a => !a.startsWith('-') && /^(https?:\/\/|[a-zA-Z0-9]([a-zA-Z0-9-]*\.)+[a-zA-Z]{2,})/.test(a));
     const urlArg = rawUrlArg && !/^https?:\/\//.test(rawUrlArg) ? `https://${rawUrlArg}` : rawUrlArg;
     if (urlArg) {
-      const activeTabFile = JSON.stringify(path.join(PW_CLI_DIR, 'active-tab.json'));
       const navCode = `async page => {
         const newPage = await page.context().newPage();
         await newPage.goto(${JSON.stringify(urlArg)}, { waitUntil: 'domcontentloaded', timeout: 0 });
-        const resultUrl = newPage.url();
-        try { require('fs').writeFileSync(${activeTabFile}, JSON.stringify({ url: resultUrl })); } catch {}
-        return resultUrl;
+        return newPage.url();
       }`;
       await ensureBrowserRunning();
       await handleRunCode(['run-code', navCode]);

package/package.json

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

package/src/utils.js

@@ -52,4 +52,27 @@ function sleep(ms) {
   return new Promise(r => setTimeout(r, ms));
 }
 
-module.exports = { readStdin, die, probeCDP, findFreePort, sleep };
+/**
+ * Fetch the URL of the most recently active page tab via Chrome's /json/list endpoint.
+ * Chrome returns targets ordered by most-recently-activated first.
+ * Returns the URL string, or null if no page target found.
+ */
+function fetchActivePageUrl(port) {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${port}/json/list`, { timeout: 3000 }, res => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const targets = JSON.parse(data);
+          const page = targets.find(t => t.type === 'page');
+          resolve(page ? page.url : null);
+        } catch { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+module.exports = { readStdin, die, probeCDP, findFreePort, sleep, fetchActivePageUrl };