pw-repl 0.4.1 → 0.4.2

package/bin/pw-repl.js

@@ -41,9 +41,10 @@ send exit status: 0 ok, 1 command error, 2 completion not confirmed, 64 usage or
 The browser must be running with --remote-debugging-port (default http://localhost:9222; set $PW_CDP_URL).
 
 --launch is the quick start instead: it starts a Chromium of the REPL's own (headless unless --headed, in
-a temporary profile), prints the command it ran, and stops it with the REPL. Flags after -- go to that
-Chromium; PW_CHROME picks which one. To set a browser up your own way, start it yourself and use
-PW_CDP_URL.
+a temporary profile, on a free port of its own), prints the command it ran, and stops it with the REPL
+(Ctrl-C while it starts too); stop returns once that Chromium has exited. Flags after -- go to it; a
+--user-data-dir=<dir> among them is used instead of the temporary profile, and kept. PW_CHROME picks
+which one. To set a browser up your own way, start it yourself and use PW_CDP_URL.
 
 In a tmux session named playwright-repl, pw-repl send reaches pw-repl run without the server.`;
 

package/lib/background.js

@@ -8,7 +8,13 @@ const client = require('./client');
 
 const BIN = path.join(__dirname, '..', 'bin', 'pw-repl.js');
 const START_TIMEOUT = 20000;
-const STOP_TIMEOUT = 10000;
+// Longer than --launch gives Chromium, twice when it retries without the sandbox, then the connect: its own
+// error, and its cleanup, come first.
+const LAUNCH_START_TIMEOUT = 2 * require('./launch').START_TIMEOUT + 20000;
+// Longer than a REPL can take to stop: its cleanups and letting go of the browser (up to
+// SHUTDOWN_TIMEOUT each), then stopping a Chromium it launched.
+const STOP_TIMEOUT = 2 * require('./state').SHUTDOWN_TIMEOUT + require('./launch').STOP_WORST + 4000;
+const LOG_LIMIT = 5 * 1024 * 1024;
 const FOLLOW_INTERVAL = 150;
 const ATTACH_BACKLOG = 20;
 const ATTACH_COMMAND_TIMEOUT = 3600000;
@@ -47,6 +53,13 @@ function tail(file, lines) {
   try { return fs.readFileSync(file, 'utf8').trimEnd().split('\n').slice(-lines).join('\n'); } catch { return ''; }
 }
 
+// Called in the background REPL as it starts: however it ends, served or not, its log says so.
+function markStopInLog() {
+  process.on('exit', code => {
+    try { fs.writeSync(process.stdout.fd, `--- ${new Date().toISOString()} stopped${code ? ` (exit code ${code})` : ''}\n`); } catch {}
+  });
+}
+
 // Called in the background REPL once it serves: its pid file says it runs, and goes when it exits.
 function claimPidFile(pidFile) {
   fs.writeFileSync(pidFile, String(process.pid), { mode: 0o600 });
@@ -62,8 +75,12 @@ async function start(options) {
   const running = runningPid(pidFile);
   if (running) return fail(`a background REPL is already serving on ${name} (pid ${running}); pw-repl attach uses it, pw-repl stop stops it`);
   if (await client.health(endpoint, 2000)) return fail(`a REPL is already serving on ${name}, in a terminal; pw-repl where says more`);
-  const log = fs.openSync(logFile, 'w', 0o600);
+  // Appended to, so an earlier run's log stays; each run is marked where it starts and stops. One grown
+  // past LOG_LIMIT is moved to <log>.1 first, replacing the one there.
+  try { if (fs.statSync(logFile).size > LOG_LIMIT) fs.renameSync(logFile, `${logFile}.1`); } catch {}
+  const log = fs.openSync(logFile, 'a', 0o600);
   fs.fchmodSync(log, 0o600);
+  fs.writeSync(log, `--- ${new Date().toISOString()} started\n`);
   const args = [BIN, 'serve', ...(options.launch ? ['--launch'] : []), ...(options.headed ? ['--headed'] : []),
     ...(options.endpoint ? [options.endpoint] : []), ...(options.startUrl ? [options.startUrl] : []),
     ...(options.chromeArgs.length ? ['--', ...options.chromeArgs] : [])];
@@ -74,11 +91,26 @@ async function start(options) {
   });
   fs.closeSync(log);
   let exited = false;
-  child.on('exit', () => { exited = true; });
-  const deadline = Date.now() + START_TIMEOUT;
-  while (!exited && Date.now() < deadline && !(await client.health(endpoint, 1000) && runningPid(pidFile))) {
+  const gone = new Promise(resolve => child.on('exit', () => { exited = true; resolve(); }));
+  // Ctrl-C while it waits gives up on the start: the REPL is stopped (and a Chromium it launched with it),
+  // rather than left starting where stop cannot reach it yet.
+  let interrupted = false;
+  const interrupt = () => { interrupted = true; };
+  const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+  for (const signal of signals) process.on(signal, interrupt);
+  const deadline = Date.now() + (options.launch ? LAUNCH_START_TIMEOUT : START_TIMEOUT);
+  while (!exited && !interrupted && Date.now() < deadline && !(await client.health(endpoint, 1000) && runningPid(pidFile))) {
     await new Promise(resolve => setTimeout(resolve, 200));
   }
+  for (const signal of signals) process.removeListener(signal, interrupt);
+  if (interrupted) {
+    if (!exited) child.kill();
+    await Promise.race([gone, new Promise(resolve => setTimeout(resolve, STOP_TIMEOUT))]);
+    try { fs.appendFileSync(logFile, `--- ${new Date().toISOString()} the start was interrupted\n`); } catch {}
+    console.error(`pw-repl: ${exited ? 'interrupted; the background REPL was stopped before it served' : `interrupted; the background REPL (pid ${child.pid}) has not stopped after ${STOP_TIMEOUT / 1000}s`}`);
+    // As a shell reports a command stopped by Ctrl-C.
+    return 130;
+  }
   if (exited || !runningPid(pidFile)) {
     if (!exited) child.kill();
     const last = tail(logFile, 12);
@@ -186,4 +218,4 @@ function describeBackground(endpoint) {
   return `background: pid ${pid}${since}; log ${logFile} (pw-repl attach${e}, pw-repl stop${e})`;
 }
 
-module.exports = { filesFor, endpointFlag, claimPidFile, start, stop, attach, describeBackground };
+module.exports = { filesFor, endpointFlag, markStopInLog, claimPidFile, start, stop, attach, describeBackground };

package/lib/commands.js

@@ -477,6 +477,13 @@ const BODY_TIMEOUT = 15000;
 const RECENT_HIDDEN_TYPES = new Set(['image', 'font', 'stylesheet', 'media']);
 // The bodies body prints; any other is binary.
 const TEXT_BODY = /json|^text\/|javascript|xml|html|x-www-form-urlencoded/;
+
+// UTF-8 with no control characters but tabs and line breaks.
+function looksLikeText(buffer) {
+  let text;
+  try { text = new TextDecoder('utf-8', { fatal: true }).decode(buffer); } catch { return false; }
+  return !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(text);
+}
 // A watched tab keeps each body watch shows as it arrives, since the browser
 // drops them once the tab navigates, often before anyone has read them.
 const KEPT_BODY_MAX = 100 * 1024;
@@ -491,6 +498,8 @@ const loadedAt = new WeakMap();
 const openedTabs = new WeakSet();
 // page -> the client that opened it (null: the prompt, or a sender without a name).
 const tabOwners = new WeakMap();
+// The tab the REPL opened for its start URL, which tab marks: in a kept profile it sits among restored tabs.
+const startTabs = new WeakSet();
 
 function clipText(text) {
   return text.length > MAX_EVENT_TEXT ? `${text.slice(0, MAX_EVENT_TEXT)}…` : text;
@@ -1243,6 +1252,12 @@ async function waitForLoad(timeout) {
     const navigation = (recentLogs.get(p) || []).filter(e => e.navigation && e.t >= since).pop();
     if (navigation && navigation.status.startsWith('failed')) throw new Error(`The page did not load: #${navigation.id} ${navigation.url} ${navigation.status}`);
     const loaded = navigation ? (loadedAt.get(p) || 0) >= navigation.t : await p.evaluate(() => document.readyState === 'complete').catch(() => false);
+    if (loaded && !navigation && (loadedAt.get(p) || 0) < since) {
+      // Nothing loaded since the previous command: a page that changes its URL itself (pushState) does not
+      // load, and may not have changed it yet.
+      out.log(`Loaded before the previous command, nothing since: ${p.url()} — ${await p.title().catch(() => '')}\n(A page that changes its own URL does not load: wait <selector> or wait text waits for its new view.)`);
+      return;
+    }
     if (loaded) { out.log(`Loaded: ${p.url()} — ${await p.title().catch(() => '')}`); return; }
     if (Date.now() >= deadline) throw new Error(`${p.url()} did not finish loading within ${timeout / 1000}s`);
     await new Promise(resolve => setTimeout(resolve, 50));
@@ -1408,7 +1423,8 @@ async function listTabs() {
     // URL first on its own line: it is what distinguishes otherwise
     // identically titled tabs, and titles wrap less badly when indented.
     if (i) out.log('');
-    out.log(`${marker} [${i}] ${p.url()}${tabOwners.get(p) ? `  (opened by ${tabOwners.get(p)})` : ''}`);
+    const notes = [startTabs.has(p) && 'the start URL', tabOwners.get(p) && `opened by ${tabOwners.get(p)}`].filter(Boolean);
+    out.log(`${marker} [${i}] ${p.url()}${notes.length ? `  (${notes.join(', ')})` : ''}`);
     out.log(`        ${JSON.stringify(title)}`);
   }
 }
@@ -1455,8 +1471,15 @@ const commands = {
       if (parts.length) throw new Error(usage);
       const target = state.tabListing[Number(subcommand)];
       if (target && all.includes(target)) { select(target); return commands.info(); }
+      // Not read as part of a URL instead: that could land in someone else's tab without a word.
+      if (target) throw new Error(`Tab [${subcommand}] has closed since the latest listing. Run tab to list them again.`);
       // A number that is not a tab in the listing may be part of a URL (a port).
-      if (!all.some(p => p.url().includes(subcommand))) throw new Error(`No tab [${subcommand}] in the latest listing, and no tab URL contains ${subcommand}. Run tab to list them.`);
+      const containing = all.filter(p => p.url().includes(subcommand)).length;
+      if (!containing) throw new Error(`No tab [${subcommand}] in the latest listing, and no tab URL contains ${subcommand}. Run tab to list them.`);
+      if (containing > 1) {
+        const listing = state.tabListing.length ? 'the latest listing' : 'a listing yet: each client has its own, from tab';
+        throw new Error(`No tab [${subcommand}] in ${listing}. As part of a URL, ${subcommand} is in ${containing} tabs. Run tab, then tab <index>.`);
+      }
     }
     if (subcommand === 'new') {
       select(await openTab());
@@ -1925,7 +1948,8 @@ const commands = {
   async sleep(args) {
     if (!args || !/^\d+$/.test(args) || Number(args) > 3600000) throw new Error('Usage: sleep <ms> (maximum 3600000)');
     await state.page.waitForTimeout(Number(args));
-    out.log(`Slept ${args}ms`);
+    // sleep 3 is easily meant as seconds.
+    out.log(Number(args) < 100 ? `Slept ${args}ms (sleep takes milliseconds: sleep ${args}000 is ${args}s)` : `Slept ${args}ms`);
   },
 
   // A stopped upstream does not reach the browser as a failure: the dev proxy
@@ -2049,7 +2073,8 @@ const commands = {
     const type = entry.response.headers()['content-type'] || '';
     out.log(`#${id} ${entry.method} ${entry.status} ${entry.url} (${type || 'no content type'}, ${buffer.length} bytes)`);
     if (!buffer.length) return;
-    if (!TEXT_BODY.test(type)) { out.log('[binary body not shown]'); return; }
+    // With no content type, text is told by its bytes: an error page's "not found" often has none.
+    if (!TEXT_BODY.test(type) && (type || !looksLikeText(buffer))) { out.log('[binary body not shown]'); return; }
     let text = buffer.toString('utf8');
     if (/json/.test(type)) { try { text = JSON.stringify(JSON.parse(text), null, 2); } catch {} }
     printOutput(text, all);
@@ -2345,4 +2370,4 @@ function complete(line) {
   return [[], current];
 }
 
-module.exports = { commands, cliCommands, needsTab, dialogCommand, listTabs, openTab, activeModes, watchPage, complete, compactSnapshot, grepSnapshot, summarizeChanges, scrubEditable, clock };
+module.exports = { commands, cliCommands, needsTab, dialogCommand, listTabs, openTab, startTabs, activeModes, watchPage, complete, compactSnapshot, grepSnapshot, summarizeChanges, scrubEditable, clock };

package/lib/help.js

@@ -48,7 +48,7 @@ const TOPICS = {
     commands: ['click', 'dblclick', 'hover', 'fill', 'type', 'press', 'select', 'check', 'uncheck', 'upload'],
   },
   inspect: {
-    intro: 'Output is capped; put --all right after the command for everything (e.g. text --all body).',
+    intro: 'Output is capped; --all right after the command, or at the end, shows everything (text --all body).',
     commands: ['snapshot', 'watch', 'text', 'html', 'attrs', 'listeners', 'count', 'visible', 'links', 'inputs', 'screenshot', 'viewport', 'emulate', 'wait', 'sleep'],
   },
   network: {
@@ -165,7 +165,7 @@ const COMMANDS = {
     summary: 'wait for an element, text, a response or a load (10s)',
     detail: 'wait <selector> waits for a matching element to be visible, and wait text <text> for text to be;\nwait request <url-part|glob> waits for a matching response, counting one that finished since the\nprevious command began (so click, then wait request, does not miss it).\n\nwait load waits for the page to finish loading (its load event). A navigation that began since the\nprevious command began counts, so click a link, then wait load, waits for the new page. A page\nthat changes its own URL without loading (an app\'s own routing) is not a load: wait for something on\nthe new view instead.\n\nwait text matches any part of an element\'s text, in any case.\n\n--gone waits instead until nothing matching is visible (removed or hidden): wait .spinner --gone.\nIt is done at once if nothing matches yet, so wait for it to appear first if it may not have.\n\nUp to 120s. A wait that times out is an error; the REPL carries on.',
   },
-  sleep: { usage: 'sleep <ms>', summary: 'wait a fixed time (maximum 3600000)' },
+  sleep: { usage: 'sleep <ms>', summary: 'wait a fixed time, in milliseconds (maximum 3600000)' },
   requests: {
     usage: 'requests [--all] [n] [url-filter]',
     summary: 'the selected tab\'s last n requests (default 20)',

package/lib/launch.js

@@ -1,13 +1,19 @@
 // pw-repl run|serve --launch: a Chromium of the REPL's own, started for it and
 // stopped with it, in a profile that is removed afterwards. It is the quick
 // start; a browser set up any other way is reached with PW_CDP_URL instead.
+// A --user-data-dir among the flags after -- is used instead, and kept.
 const { spawn } = require('child_process');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
 const START_TIMEOUT = 20000;
-const STOP_TIMEOUT = 5000;
+// Stopping: a moment to connect and ask it to close, a few seconds to close, as long again after SIGTERM,
+// and up to 3s to remove a profile its helpers are still writing to. STOP_WORST is what it can take.
+const CLOSE_CONNECT_TIMEOUT = 2000;
+const CLOSE_TIMEOUT = 3000;
+const TERM_TIMEOUT = 3000;
+const STOP_WORST = CLOSE_CONNECT_TIMEOUT + CLOSE_TIMEOUT + TERM_TIMEOUT + 3000;
 const INSTALL = 'npx playwright-core install chromium';
 const ON_PATH = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome', 'microsoft-edge'];
 const MAC_APPS = [
@@ -48,25 +54,69 @@ function smallShm() {
   try { const shm = fs.statfsSync('/dev/shm'); return shm.blocks * shm.bsize < 1024 ** 3; } catch { return false; }
 }
 
-// Starts it and waits for the port it picked, which it writes into its profile.
-function start(exe, args, profile) {
+const GROUP_GONE_TIMEOUT = 2000;
+
+// A launched Chromium runs in its own process group, so this stops the helper processes it starts too.
+function killGroup(pid) {
+  try { process.kill(-pid, 'SIGKILL'); } catch {}
+}
+
+async function groupGone(pid) {
+  const deadline = Date.now() + GROUP_GONE_TIMEOUT;
+  while (Date.now() < deadline) {
+    try { process.kill(-pid, 0); } catch { return; }
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+}
+
+// Starts it and waits for the port it picked, which it prints (as Playwright reads it too): a
+// DevToolsActivePort file in a profile of the caller's can be one an earlier run left behind.
+// One that does not start is stopped, helpers and all, before this returns.
+function start(exe, args, onSpawn) {
   return new Promise(resolve => {
-    // Its own process group, so stopping it also stops the helper processes it starts.
     const proc = spawn(exe, args, { stdio: ['ignore', 'ignore', 'pipe'], detached: true });
+    onSpawn(proc);
     let stderr = '';
+    let partial = '';
     let settled = false;
-    const done = result => { if (!settled) { settled = true; clearInterval(poll); clearTimeout(timer); resolve(result); } };
-    proc.stderr.on('data', d => { if (stderr.length < 20000) stderr += d; });
+    const done = result => {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      if (!result.error) return resolve(result);
+      killGroup(proc.pid);
+      // A helper still holding the profile's lock would make a retry in the same profile fail.
+      groupGone(proc.pid).then(() => resolve(result));
+    };
+    proc.stderr.on('data', d => {
+      if (stderr.length < 20000) stderr += d;
+      const text = partial + d;
+      const listening = /^DevTools listening on ws:\/\/[^/\s]+:(\d+)\//m.exec(text);
+      if (listening) done({ proc, port: listening[1] });
+      partial = text.slice(text.lastIndexOf('\n') + 1);
+    });
     proc.on('error', error => done({ error: error.message, stderr }));
     proc.on('exit', code => done({ error: `it exited with code ${code}`, stderr }));
-    const portFile = path.join(profile, 'DevToolsActivePort');
-    const poll = setInterval(() => {
-      try { const port = fs.readFileSync(portFile, 'utf8').split('\n')[0].trim(); if (port) done({ proc, port }); } catch {}
-    }, 100);
-    const timer = setTimeout(() => { proc.kill('SIGKILL'); done({ error: `no debugging port within ${START_TIMEOUT / 1000}s`, stderr }); }, START_TIMEOUT);
+    const timer = setTimeout(() => done({ error: `no debugging port within ${START_TIMEOUT / 1000}s`, stderr }), START_TIMEOUT);
   });
 }
 
+// Chromium takes only --user-data-dir=<dir>, and the last one given.
+function userDataDir(args) {
+  const given = args.filter(a => a.startsWith('--user-data-dir=')).pop();
+  return given ? path.resolve(given.slice('--user-data-dir='.length)) : null;
+}
+
+async function closeBrowser(url) {
+  let browser;
+  try {
+    browser = await require('playwright-core').chromium.connectOverCDP(url, { timeout: CLOSE_CONNECT_TIMEOUT });
+    const session = await browser.newBrowserCDPSession();
+    // It closes before it answers, or as it does.
+    await session.send('Browser.close').catch(() => {});
+  } catch {}
+  try { await browser?.close(); } catch {}
+}
+
 function quoted(args) {
   return args.map(a => (/[\s"'$]/.test(a) ? JSON.stringify(a) : a)).join(' ');
 }
@@ -76,40 +126,60 @@ async function launch({ headed = false, extraArgs = [] }) {
   if (!exe) {
     throw new Error(`No Chromium found to launch. Install Playwright's with:\n  ${INSTALL}\nor set PW_CHROME to one, or start one yourself with --remote-debugging-port and set PW_CDP_URL.`);
   }
-  const profile = fs.mkdtempSync(path.join(os.tmpdir(), 'pw-repl-chrome-'));
-  const ours = [...(headed ? [] : ['--headless=new']), '--remote-debugging-port=0', `--user-data-dir=${profile}`,
+  const given = userDataDir(extraArgs);
+  const profile = given || fs.mkdtempSync(path.join(os.tmpdir(), 'pw-repl-chrome-'));
+  const removeProfile = () => { if (!given) fs.rmSync(profile, { recursive: true, force: true }); };
+  // Registered before Chromium starts, and kept for the REPL's life: a REPL that goes without shutting
+  // down, even while it waits for Chromium, still takes it (and a profile of its own) along.
+  let group = null;
+  const onExit = () => { if (group) killGroup(group); try { removeProfile(); } catch {} };
+  process.on('exit', onExit);
+  const onSpawn = proc => { group = proc.pid; };
+  const ours = [...(headed ? [] : ['--headless=new']), '--remote-debugging-port=0', ...(given ? [] : [`--user-data-dir=${profile}`]),
     '--no-first-run', '--no-default-browser-check', ...(smallShm() ? ['--disable-dev-shm-usage'] : [])];
+  // A profile already used has tabs to restore; a blank tab of its own each time would pile up there.
+  // Local State is written at its root on the first run, whichever --profile-directory is used.
+  const blank = given && fs.existsSync(path.join(given, 'Local State')) ? [] : ['about:blank'];
   // Flags given after -- come after these, so they can override them.
-  let args = [...ours, ...extraArgs, 'about:blank'];
-  let result = await start(exe, args, profile);
+  let args = [...ours, ...extraArgs, ...blank];
+  let result = await start(exe, args, onSpawn);
   let note = null;
   // Tried with the sandbox first; a container often cannot give Chromium one.
   if (result.error && /sandbox/i.test(result.stderr)) {
-    args = [...ours, '--no-sandbox', ...extraArgs, 'about:blank'];
-    result = await start(exe, args, profile);
+    args = [...ours, '--no-sandbox', ...extraArgs, ...blank];
+    result = await start(exe, args, onSpawn);
     note = 'Chromium could not use its sandbox here, so it runs with --no-sandbox.';
   }
   const command = quoted([exe, ...args]);
   if (result.error) {
-    fs.rmSync(profile, { recursive: true, force: true });
+    process.removeListener('exit', onExit);
+    removeProfile();
     const last = result.stderr.trim().split('\n').slice(-5).join('\n');
     throw new Error(`Chromium did not start (${result.error}):\n  ${command}${last ? `\n${last}` : ''}`);
   }
   const { proc, port } = result;
-  const signal = name => { try { process.kill(-proc.pid, name); } catch {} };
+  const url = `http://127.0.0.1:${port}`;
+  const exited = new Promise(resolve => { if (proc.exitCode !== null || proc.signalCode !== null) resolve(); else proc.once('exit', resolve); });
+  const exitsWithin = ms => Promise.race([exited.then(() => true), new Promise(resolve => setTimeout(resolve, ms, false))]);
   const stop = async () => {
-    if (proc.exitCode === null && proc.signalCode === null) {
-      signal('SIGTERM');
-      await new Promise(resolve => { const t = setTimeout(() => { signal('SIGKILL'); resolve(); }, STOP_TIMEOUT); proc.once('exit', () => { clearTimeout(t); resolve(); }); });
+    if (!(await exitsWithin(0))) {
+      // Browser.close shuts it down in order: its helpers save the profile (what pages last wrote to
+      // localStorage) and it removes the profile's lock. SIGTERM to the browser process saves the
+      // profile too but leaves the lock; to the whole group, it loses the last writes.
+      // Not awaited: a browser that hangs may never answer; its exit is what counts.
+      void closeBrowser(url);
+      if (!(await exitsWithin(CLOSE_CONNECT_TIMEOUT + CLOSE_TIMEOUT))) {
+        try { process.kill(proc.pid, 'SIGTERM'); } catch {}
+        await exitsWithin(TERM_TIMEOUT);
+      }
     }
+    killGroup(proc.pid);
     // Its helper processes can still be writing to the profile for a moment.
     for (let tries = 0; tries < 30; tries++) {
-      try { fs.rmSync(profile, { recursive: true, force: true }); return; } catch { await new Promise(resolve => setTimeout(resolve, 100)); }
+      try { removeProfile(); return; } catch { await new Promise(resolve => setTimeout(resolve, 100)); }
     }
   };
-  // If the REPL goes without shutting down, the browser still goes with it.
-  process.on('exit', () => signal('SIGKILL'));
-  return { url: `http://127.0.0.1:${port}`, command, note, headed, stop };
+  return { url, command, note, headed, stop };
 }
 
-module.exports = { findChrome, launch, INSTALL };
+module.exports = { findChrome, launch, INSTALL, START_TIMEOUT, STOP_WORST };

package/lib/output.js

@@ -61,7 +61,7 @@ function printOutput(value, all = false) {
   else text = JSON.stringify(value, null, 2);
   if (text === undefined) text = 'undefined';
   if (!all && text.length > OUTPUT_LIMIT) {
-    log(`${text.slice(0, OUTPUT_LIMIT)}\n[truncated; use --all after the command to show all]`);
+    log(`${text.slice(0, OUTPUT_LIMIT)}\n[truncated; add --all to the command to show all]`);
   } else {
     log(text);
   }

package/lib/runner.js

@@ -30,7 +30,7 @@ const READ_ONLY = new Set(['info', 'listeners', 'text', 'html', 'attrs', 'count'
 // Commands that work with no tab selected.
 const NO_TAB_NEEDED = new Set(['tab', 'modes', 'capture', 'dialog', 'help', 'quit', 'tab-select', 'close']);
 
-// Commands that accept a leading --all to lift the output limit.
+// Commands that accept --all, right after the command or at the end, to lift the output limit.
 const INSPECTION = ['info', 'listeners', 'text', 'html', 'attrs', 'links', 'inputs', 'eval', 'cdp', 'cookies', 'storage', 'capture', 'body', 'console', 'snapshot', 'watch'];
 
 let queue = Promise.resolve();
@@ -85,8 +85,10 @@ async function executeCommand(text) {
   const spaceIdx = text.indexOf(' ');
   const cmd = spaceIdx === -1 ? text : text.slice(0, spaceIdx);
   let args = spaceIdx === -1 ? '' : text.slice(spaceIdx + 1);
-  const all = INSPECTION.includes(cmd) && /^--all(?:\s|$)/.test(args);
-  if (all) args = args.slice(5).trimStart();
+  let all = false;
+  if (INSPECTION.includes(cmd) && /^--all(?:\s|$)/.test(args)) { all = true; args = args.slice(5).trimStart(); }
+  // At the end too, where the truncation note's reader tends to put it (console 200 --all).
+  else if (INSPECTION.includes(cmd) && /(?:^|\s)--all$/.test(args)) { all = true; args = args.slice(0, -5).trimEnd(); }
   // wait request counts responses since the previous command began.
   state.previousCommandAt = state.currentCommandAt;
   state.currentCommandAt = Date.now();

package/lib/start.js

@@ -3,7 +3,7 @@ const { chromium } = require('playwright-core');
 const readline = require('readline');
 const { state, withTimeout, shutdown, onBeforeExit, beforeExit } = require('./state');
 const out = require('./output');
-const { listTabs, openTab, watchPage, complete } = require('./commands');
+const { listTabs, openTab, startTabs, watchPage, complete } = require('./commands');
 const runner = require('./runner');
 
 // A browser --launch starts has its own address instead.
@@ -28,6 +28,7 @@ Or let pw-repl start a private one for this REPL: pw-repl run --launch (or serve
 
 async function start(options) {
   const START_URL = options.startUrl || process.env.PW_START_URL || null;
+  if (options.pidFile) require('./background').markStopInLog();
   if (options.launch) {
     const launched = await require('./launch').launch({ headed: options.headed, extraArgs: options.chromeArgs });
     onBeforeExit(launched.stop);
@@ -72,6 +73,7 @@ async function start(options) {
 
   if (START_URL) {
     state.page = await openTab();
+    startTabs.add(state.page);
     await state.page.goto(START_URL, { waitUntil: 'networkidle', timeout: 15000 });
     out.log(`Opened ${state.page.url()} in a new tab`);
   }
@@ -150,7 +152,11 @@ function stop() {
   shutdown().then(beforeExit).then(() => process.exit(process.exitCode || 0));
 }
 
-// SIGHUP too: closing the terminal must still remove the server's socket.
-for (const signal of ['SIGTERM', 'SIGHUP']) process.on(signal, stop);
+// SIGHUP too: closing the terminal must still remove the server's socket. SIGINT is Ctrl-C before the
+// prompt reads it (while --launch starts Chromium, or while connecting): without this, node exits at
+// once and leaves a launched Chromium running.
+for (const signal of ['SIGTERM', 'SIGHUP', 'SIGINT']) process.on(signal, stop);
 
-module.exports = { start: options => start(options).catch(e => { out.error(e.message); shutdown().then(beforeExit).finally(() => process.exit(1)); }) };
+// Stopped while it starts (Ctrl-C), what was under way fails as the browser goes: stop() says nothing
+// of that, and exits.
+module.exports = { start: options => start(options).catch(e => { if (state.stopping) return; out.error(e.message); shutdown().then(beforeExit).finally(() => process.exit(1)); }) };

package/lib/state.js

@@ -83,4 +83,4 @@ async function shutdown() {
   return shutdownPromise;
 }
 
-module.exports = { state, clientRecord, asClient, withTimeout, onShutdown, onBeforeExit, beforeExit, shutdown };
+module.exports = { state, clientRecord, asClient, withTimeout, onShutdown, onBeforeExit, beforeExit, shutdown, SHUTDOWN_TIMEOUT };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pw-repl",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Text REPL for driving an existing Chromium through Playwright over CDP",
   "keywords": [
     "playwright",

package/skill/SKILL.md

@@ -25,12 +25,19 @@ one; each takes an optional start URL, which opens in a new tab.
 
 - `pw-repl serve --background` runs it detached, with a command server on `/tmp/playwright-repl.sock`
   (owner-only) and its output in `/tmp/playwright-repl.log`. `pw-repl attach` shows everything it does
-  and takes commands; `pw-repl stop` stops it.
+  and takes commands; `pw-repl stop` stops it. It returns once the REPL serves; Ctrl-C before then gives
+  up on the start, stops the REPL, exits 130, and says so in the log.
 - `pw-repl serve` runs the same in a terminal, where the pane shows every command. Its prompt is
   `pw[serve]>`.
 - Add `--launch` to `run` or `serve` (with or without `--background`) to have it start a Chromium of its
-  own instead of connecting to one: headless unless `--headed`, in a temporary profile, stopped with the
-  REPL. It prints the command it ran; flags after `--` are passed to that Chromium.
+  own instead of connecting to one: headless unless `--headed`, in a temporary profile, on a free port of
+  its own (never 9222). It stops with the REPL, Ctrl-C while it starts included, and `stop` returns once
+  it has exited. It prints the command it ran; flags after `--` are passed to that Chromium, and a
+  `--user-data-dir=<dir>` among them is used instead of the temporary profile, and kept. Started again in
+  a kept profile, Chromium picks up where it left off, as it would for a person, headless too: its tabs
+  come back, and session cookies with them, so a login stays. They start loading before the REPL is
+  attached, so `requests` and `console` have only what came after, often nothing: `reload` for a full
+  record.
 - `pw-repl run` runs it in a terminal with no server; `send` then reaches it through tmux, if it runs in
   the tmux session `playwright-repl`:
 
@@ -41,9 +48,11 @@ one; each takes an optional start URL, which opens in a new tab.
 
 `serve` and `serve --background` take a socket path of your own instead of the default
 (`pw-repl serve --background /tmp/mine.sock`); `send`, `attach`, `stop` and `where` then need
-`-e /tmp/mine.sock`, or `PW_SOCKET=/tmp/mine.sock`. The log of a background REPL is next to its socket
-(`/tmp/mine.log`); `tail -f` on it follows along without a terminal to attach from. `serve <port>`
-listens on TCP 127.0.0.1 instead of a socket, with no access control.
+`-e /tmp/mine.sock`, or `PW_SOCKET=/tmp/mine.sock`; a socket file left by a REPL that died is replaced
+when the next one starts there. The log of a background REPL is next to its socket
+(`/tmp/mine.log`), appended to run after run, with a line where each starts and stops (past 5 MB, a
+start moves it to `/tmp/mine.log.1`); `tail -f` on it follows along without a terminal to attach from.
+`serve <port>` listens on TCP 127.0.0.1 instead of a socket, with no access control.
 
 ### One REPL, many clients
 
@@ -145,8 +154,10 @@ pw-repl send -c <name> close                        # your modes off; tab close
 - The browser may have tabs that are not yours, and someone may be using it. Whether to read or act in
   one of those tabs, or to open your own (`tab new <url>`), depends on the task; when that is not
   clear, ask.
-- No tab is selected when the REPL starts (unless it was given a start URL). Closing a tab the REPL
-  opened goes back to the tab before it, if the REPL opened that one too; otherwise no tab is selected.
+- No tab is selected when the REPL starts. A start URL's tab, marked `(the start URL)` in `tab`, is
+  selected at its prompt and for `send` without a client name; a named client (`-c`) selects it with
+  `tab <index>`. Closing a tab the REPL opened goes back to the tab before it, if the REPL opened that
+  one too; otherwise no tab is selected.
   Tab numbers change when tabs open or close; `tab <url-part>` and `tab close <url-part>` pick a tab by
   its URL and refuse if it is ambiguous.
 - Dialogs are never answered on their own. While one is open, its page and the commands that read it