pw-repl 0.12.8 → 0.14.0

package/lib/profile.js

@@ -3,13 +3,15 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { state, onShutdown } = require('./state');
+const { noteWritten } = require('./written');
 const out = require('./output');
-const { NO_TAB, clock, hints } = require('./util');
+const { NO_TAB, clock, hints, TIME, longDuration, durationText } = require('./util');
 const { tabState } = require('./tabstate');
 const { targetIdOf } = require('./tabs');
 const { summarize, LONG_TASK } = require('./trace');
 
-const MAX_SECONDS = 120;
+// Without a time, a profile left on stops by itself after this long.
+const UNTIMED_MAX = 120000;
 const SHOWN = 10;
 // DevTools' Performance panel's categories, less the browser-wide ones the summary does not use.
 const CATEGORIES = ['devtools.timeline', 'disabled-by-default-devtools.timeline', 'disabled-by-default-devtools.timeline.frame',
@@ -52,12 +54,11 @@ function forget(profile) {
 
 async function startProfile(tokens, quiet = false) {
   if (prof) throw new Error(`Already profiling ${prof.page.url()}; profile off stops it`);
-  const usage = `Usage: profile on [seconds] [--cpu] (seconds from 1 to ${MAX_SECONDS})`;
+  const usage = 'Usage: profile on [time] [--cpu] (ms, or 30s)';
   const cpu = tokens.includes('--cpu');
   const rest = tokens.filter(t => t !== '--cpu');
-  if (rest.length > 1 || (rest.length && !/^\d+$/.test(rest[0]))) throw new Error(usage);
-  const seconds = rest.length ? Number(rest[0]) : null;
-  if (seconds !== null && (seconds < 1 || seconds > MAX_SECONDS)) throw new Error(usage);
+  if (rest.length > 1 || (rest.length && !TIME.test(rest[0]))) throw new Error(usage);
+  const ms = rest.length ? longDuration(rest[0], 'profile on\'s time') : null;
   if (!state.page || state.page.isClosed()) throw new Error(NO_TAB);
   await finishing;
   const page = state.page;
@@ -98,17 +99,17 @@ async function startProfile(tokens, quiet = false) {
   };
   session.on('Tracing.bufferUsage', onUsage);
   profile.unlisten = () => { page.off('close', onClose); session.off('Tracing.bufferUsage', onUsage); };
-  profile.cap = setTimeout(() => {
-    if (prof === profile) stop(`it reached ${MAX_SECONDS}s, the most a profile records.`, `The profile stopped at ${MAX_SECONDS}s, the most it records`);
-  }, MAX_SECONDS * 1000);
-  if (!seconds) {
+  if (!ms) {
+    profile.cap = setTimeout(() => {
+      if (prof === profile) stop(`it reached ${durationText(UNTIMED_MAX)}, the most a profile records without a time (profile on <time> for longer).`, `The profile stopped at ${durationText(UNTIMED_MAX)}, the most it records without a time`);
+    }, UNTIMED_MAX);
     if (quiet) return;
     out.log(`Profiling the selected tab${cpu ? ' with a JS CPU profile' : ''}; profile off stops it and prints a summary.`);
     return;
   }
-  out.log(`Profiling the selected tab for ${seconds}s...`);
+  out.log(`Profiling the selected tab for ${durationText(ms)}...`);
   await new Promise(resolve => {
-    const timer = setTimeout(resolve, seconds * 1000);
+    const timer = setTimeout(resolve, ms);
     profile.wake = () => { clearTimeout(timer); resolve(); };
   });
   // profile off may have ended it first, and printed it; anything else that ended it (its tab closed,
@@ -257,7 +258,7 @@ const commands = {
     await finishing;
     if (sub === 'save') return saveProfile(rest.join(' '));
     if (sub === 'reload' && !rest.length) return profileReload(all);
-    if (sub) throw new Error(`Usage: profile on [seconds] [--cpu] | off | save <file> | reload`);
+    if (sub) throw new Error(`Usage: profile on [time] [--cpu] | off | save <file> | reload`);
     if (prof) {
       out.log(`Profiling ${prof.page.url()} since ${clock(prof.startedAt)}${prof.owner ? `, for ${prof.owner}` : ''}`);
       out.log(hints([['profile off', 'stop and print a summary']]));
@@ -270,7 +271,7 @@ const commands = {
       out.log('Not profiling.');
     }
     out.log(hints([
-      ['profile on [seconds]', 'record what the selected tab\'s main thread does'],
+      ['profile on [time]', 'record what the selected tab\'s main thread does'],
       ['profile reload', 'profile the selected tab\'s page as it loads'],
     ]));
   },
@@ -301,6 +302,7 @@ function saveProfile(file) {
   if (fs.existsSync(file)) throw new Error(`${file} exists already; name another file`);
   if (!fs.existsSync(path.dirname(path.resolve(file)))) throw new Error(`No folder ${path.dirname(path.resolve(file))} to save ${path.basename(file)} in`);
   fs.copyFileSync(last.saveFile, file, fs.constants.COPYFILE_EXCL);
+  noteWritten(file, 'profile');
   const kb = Math.round(fs.statSync(file).size / 1024);
   out.log(`Saved the profile of ${last.url} to ${file} (${kb} KB): the tab's events only. Chrome DevTools' Performance panel (Load profile) and ui.perfetto.dev open it.`);
 }

package/lib/record.js

@@ -5,12 +5,14 @@ const path = require('path');
 const { state, onShutdown } = require('./state');
 const out = require('./output');
 const { tabState } = require('./tabstate');
-const { clock, NO_TAB, STOPPED_RECORDING, ENDED_UNSEEN, playwrightBrowsersDir } = require('./util');
+const { clock, NO_TAB, STOPPED_RECORDING, ENDED_UNSEEN, playwrightBrowsersDir, TIME, longDuration, durationText } = require('./util');
 const { shellWords, splitSelector } = require('./syntax');
 const { reapplyMetrics } = require('./emulation');
+const { noteWritten, noteMoved } = require('./written');
 
 const FPS = 25;
-const MAX_SECONDS = 3600;
+// Without a time, a recording left on stops by itself after this long.
+const UNTIMED_MAX = 3600000;
 // While recording: a moment after each action for its result to be seen, and still page at both ends,
 // so a video neither starts nor stops on an action (record on --pause, --lead, --tail).
 const PACING = { pause: 750, lead: 1000, tail: 1000 };
@@ -121,7 +123,7 @@ function sizeText(bytes) {
 }
 
 // Each client's last recording that ended, and how, for record to report: one that ends on
-// its own (its seconds, its tab closing) says so only in the pane.
+// its own (its time, its tab closing) says so only in the pane.
 const lastEnded = new Map();
 // Each client's recordings still being saved, which record waits for before it reports.
 const saving = new Map();
@@ -141,7 +143,7 @@ function recordingPages() {
   return state.browser.contexts().flatMap(c => c.pages()).filter(p => recordingOf(p));
 }
 
-async function startRecording(p, file, seconds, format, keepSteps, pacing) {
+async function startRecording(p, file, ms, format, keepSteps, pacing) {
   const exe = findFfmpeg(format);
   // As screenshot does: a tab that has not been in front since it was emulated as a phone can
   // be drawn at the window's size.
@@ -252,8 +254,8 @@ async function startRecording(p, file, seconds, format, keepSteps, pacing) {
   // drawn yet (a tab still opening) starts it when it does.
   await Promise.race([gotFirstFrame, new Promise(resolve => setTimeout(resolve, FIRST_FRAME_TIMEOUT))]);
   rec.limit = setTimeout(() => {
-    finishRecording(rec, `It reached its ${seconds}s and stopped`).then(text => out.notice(text, p));
-  }, seconds * 1000);
+    finishRecording(rec, `It reached its ${durationText(ms)} and stopped`).then(text => out.notice(text, p));
+  }, ms);
   rec.onClose = () => finishRecording(rec, TAB_CLOSED).then(text => out.notice(text, p));
   p.once('close', rec.onClose);
   // A new page, loaded or routed to by a single-page app, is a step of its own, for whoever edits the
@@ -501,6 +503,7 @@ function writeSteps(rec, seconds) {
   } catch (error) {
     return { file, error: error.code === 'EEXIST' ? `${file} already exists` : error.message };
   }
+  noteWritten(file, 'steps file', rec.owner);
   rec.stepsFile = file;
   return { file, count: rec.steps.length };
 }
@@ -565,7 +568,7 @@ function fileWords(words, usage) {
     // playwright-cli's video-start --size: here the video is the page's size.
     else if (/^--size(?:=|$)/.test(word)) throw new Error(`record takes no --size: the video is the page's size; set it first with viewport <width>x<height>`);
     else if (word.startsWith('-')) throw new Error(`record takes no ${word}. ${usage}`);
-    else if (/^\d+$/.test(word)) rest.push(word);
+    else if (TIME.test(word)) rest.push(word);
     else files.push(word);
   }
   if (files.length > 1) throw new Error(`record takes one file, and ${files.map(f => `"${f}"`).join(' and ')} are two: quote a file name with spaces in it. ${usage}`);
@@ -592,13 +595,14 @@ function moveRecording(from, to) {
     fs.chmodSync(to, 0o600);
     fs.unlinkSync(from);
   }
+  noteMoved(from, to);
 }
 
 const commands = {
   async record(args) {
     // A file may be quoted, with spaces in it.
     const words = shellWords(args);
-    const usage = `Usage: record [on [file.webm|file.mp4] [seconds] [--steps] [--pause=<ms>] [--lead=<ms>] [--tail=<ms>] | off [file]] (seconds from 1 to ${MAX_SECONDS})`;
+    const usage = `Usage: record [on [file.webm|file.mp4] [time] [--steps] [--pause=<ms>] [--lead=<ms>] [--tail=<ms>] | off [file]] (a time in ms, or 30s)`;
     if (!words.length) {
       await Promise.allSettled([...(saving.get(state.client ?? null) || [])]);
       out.log(statusText(state.page));
@@ -636,7 +640,7 @@ const commands = {
       const other = (rec.owner ?? null) !== (state.client ?? null);
       const clientName = c => c ?? 'the unnamed client';
       // What must be seen before the end (a toast's read time), then the tail: still page after the last
-      // action. Only record off has them; the seconds limit is a hard stop.
+      // action. Only record off has them; the time limit is a hard stop.
       if (!rec.finishing) for (const wait of beforeEnding) await wait(state.page);
       if (!rec.finishing) await sleep(rec.pacing.tail);
       const text = await finishRecording(rec, other ? `${clientName(state.client)}'s record off ended ${clientName(rec.owner)}'s recording` : null);
@@ -662,8 +666,7 @@ const commands = {
       return;
     }
     if (numbers.length > 1) throw new Error(usage);
-    const seconds = numbers.length ? Number(numbers[0]) : MAX_SECONDS;
-    if (seconds < 1 || seconds > MAX_SECONDS) throw new Error(usage);
+    const ms = numbers.length ? longDuration(numbers[0], 'record on\'s time') : UNTIMED_MAX;
     const file = named || nextRecordingPath();
     const current = recordingOf(state.page);
     if (current) throw new Error(`The selected tab is already being recorded to ${current.file}; record off stops it`);
@@ -673,13 +676,14 @@ const commands = {
     // ffmpeg writes over it and keeps the mode. It never replaces a file.
     try {
       fs.closeSync(fs.openSync(file, 'wx', 0o600));
+      noteWritten(file, 'video');
     } catch (error) {
       if (error.code === 'EEXIST') throw new Error(`Recording already exists: ${file}`);
       throw error;
     }
     let rec;
     try {
-      rec = await startRecording(state.page, file, seconds, format, steps, { ...PACING, ...pacing });
+      rec = await startRecording(state.page, file, ms, format, steps, { ...PACING, ...pacing });
     } catch (error) {
       fs.rmSync(file, { force: true });
       throw error;
@@ -697,7 +701,7 @@ const commands = {
     const until = Date.now() + 2000;
     while (rec.firstFrameAt === null && !rec.finishing && Date.now() < until) await sleep(20);
     if (rec.firstFrameAt !== null && !rec.finishing) await sleep(Math.max(0, rec.pacing.lead - (Date.now() - rec.firstFrameAt)));
-    const limit = numbers.length ? `for ${seconds}s` : `until record off (at most ${MAX_SECONDS / 60} minutes)`;
+    const limit = numbers.length ? `for ${durationText(ms)}` : `until record off (at most ${UNTIMED_MAX / 60000} minutes)`;
     out.log(`Recording the selected tab to ${file} ${limit}${steps ? ', with its steps' : ''}${pacingText(rec.pacing)}; record off stops it and saves the file.`);
   },
 };

package/lib/routes.js

@@ -2,7 +2,7 @@
 const { state } = require('./state');
 const out = require('./output');
 const { unquote, splitSelector } = require('./syntax');
-const { hints } = require('./util');
+const { hints, parseDuration, durationText } = require('./util');
 const { tabState } = require('./tabstate');
 const { markChanged, requestEntries } = require('./requestlog');
 
@@ -14,7 +14,6 @@ function routesFor(p) {
   return tabState(p).routes;
 }
 
-const ROUTE_DELAY_MAX = 120;
 
 // A JSON Merge Patch (RFC 7386): objects merge, null removes a key, anything else replaces.
 function mergePatch(target, patch) {
@@ -77,14 +76,14 @@ function routeKind(how, rest, usage) {
     };
   }
   if (how === 'delay') {
-    const seconds = Number(rest);
-    if (!/^\d+(?:\.\d+)?$/.test(rest || '') || seconds <= 0 || seconds > ROUTE_DELAY_MAX) throw new Error(`Usage: route <url-glob> delay <seconds> (up to ${ROUTE_DELAY_MAX})`);
+    const ms = parseDuration(rest);
+    if (!ms) throw new Error('Usage: route <url-glob> delay <time> (ms, or 3s)');
     return {
-      text: `delay ${seconds}s`,
+      text: `delay ${durationText(ms)}`,
       async handle(r, req, tag, notice) {
-        await new Promise(resolve => setTimeout(resolve, seconds * 1000));
+        await new Promise(resolve => setTimeout(resolve, ms));
         await r.continue();
-        notice(`Delayed ${seconds}s: ${tag()}`);
+        notice(`Delayed ${durationText(ms)}: ${tag()}`);
       },
     };
   }
@@ -106,7 +105,7 @@ function listRoutes() {
     ['route <url-glob> <status> [json-body]', 'answer it with this status and JSON'],
     ['route <url-glob> <status> --content-type=<type> <body>', 'or with a body of another type'],
     ['route <url-glob> patch <json>', 'let it through, then change its JSON'],
-    ['route <url-glob> delay <seconds>', 'hold it, then let it through'],
+    ['route <url-glob> delay <time>', 'hold it, then let it through'],
     ['route <url-glob> abort', 'fail it as if the connection broke'],
   ];
   if (!routes.size) {
@@ -147,7 +146,7 @@ const commands = {
     // A glob may be quoted, as it is in a shell.
     const off = /^off(?:\s+(\S+))?$/.exec(trimmed);
     if (off) return removeRoutes(off[1] && unquote(off[1]));
-    const usage = 'Usage: route <url-glob> <status> [json-body] | route <url-glob> patch <json> | route <url-glob> delay <seconds> | route <url-glob> abort | route off <url-glob>|--all';
+    const usage = 'Usage: route <url-glob> <status> [json-body] | route <url-glob> patch <json> | route <url-glob> delay <time> | route <url-glob> abort | route off <url-glob>|--all';
     const parsed = splitSelector(trimmed);
     const match = /^(\S+)(?:\s+([\s\S]+))?$/.exec(parsed?.rest || '');
     if (!match) throw new Error(usage);

package/lib/runner.js

@@ -29,14 +29,14 @@ const DIALOG = /^dialog(?:-accept|-dismiss)?(?:\s|$)/;
 // A timeout here cannot have changed anything, so it is an ordinary error. Any
 // other command that times out may or may not have done what it was sent to
 // do; that is reported, and the REPL carries on.
-const READ_ONLY = new Set(['info', 'listeners', 'text', 'html', 'attrs', 'count', 'visible', 'links', 'inputs',
+const READ_ONLY = new Set(['info', 'clipboard', 'listeners', 'text', 'html', 'attrs', 'count', 'visible', 'links', 'inputs',
   'snapshot', 'screenshot', 'wait', 'sleep', 'requests', 'body', 'console', 'cookies', 'storage', 'capture', 'help']);
 
 // Commands that work with no tab selected.
 const NO_TAB_NEEDED = new Set(['tab', 'modes', 'capture', 'profile', 'record', 'dialog', 'help', 'quit', 'tab-select', 'close']);
 
 // 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', 'profile', 'body', 'console', 'snapshot', 'watch'];
+const INSPECTION = ['info', 'listeners', 'text', 'html', 'attrs', 'links', 'inputs', 'eval', 'cdp', 'clipboard', 'cookies', 'storage', 'capture', 'profile', 'body', 'console', 'snapshot', 'watch'];
 
 const SUBCOMMANDS = ['run', 'serve', 'attach', 'stop', 'send', 'where', 'skill'];
 
@@ -65,12 +65,13 @@ function busy() {
   return running > 0;
 }
 
-// A queued command runs as its client; quit and dialog, which skip the queue,
-// run as whoever is running, so they never switch the client under a command.
-async function execute(text, client, direct = false) {
+// A queued command runs as its client; quit and dialog, which skip the queue, run as the client of
+// the queued command running now, so a dialog that holds a client's click answers in that client's tab.
+// run is the command's record (asClient).
+async function execute(text, client, direct = false, run = {}) {
   running += 1;
   try {
-    return direct ? await executeCommand(text) : await asClient(client, () => executeCommand(text));
+    return direct ? await executeCommand(text) : await asClient(client, () => executeCommand(text), run);
   } finally {
     running -= 1;
   }
@@ -200,7 +201,9 @@ function enqueue(line) {
 // client names the sender: its commands show as [server:<client>] and use its own selected tab.
 // vars: values for the {{ PW_NAME }} variables in text (from send), filled in to run it; text is shown
 // as written, so a password in one is not in the command as the pane, the log and the prompt's history show it.
-function submit(text, client = null, vars = null) {
+// signal aborts when the sender gives up (send -t): a command still queued is dropped, and one
+// running is no longer waited for, so the queue moves on; whatever it set going may still run.
+function submit(text, client = null, vars = null, signal = null) {
   let run = text;
   if (vars) {
     try { run = expandVariables(text, vars); } catch (error) { return Promise.resolve({ status: 'error', output: `Error: ${error.message}` }); }
@@ -213,6 +216,10 @@ function submit(text, client = null, vars = null) {
   return new Promise(resolve => {
     queue = queue.then(async () => {
       if (state.stopping) return resolve({ status: 'error', output: 'The REPL is shutting down.' });
+      if (signal?.aborted) {
+        console.log(`[server${client ? `:${client}` : ''}] ${text}: dropped, its sender gave up before it ran`);
+        return resolve({ status: 'error', output: 'Dropped: the sender gave up before it ran.' });
+      }
       // Printed above whatever the user at the prompt is typing, which is
       // redrawn afterwards rather than broken up.
       if (process.stdout.isTTY) { readline.clearLine(process.stdout, 0); readline.cursorTo(process.stdout, 0); }
@@ -229,9 +236,21 @@ function submit(text, client = null, vars = null) {
         let result;
         const flight = { text, resolve, answered: false };
         inFlight = flight;
-        const output = await out.collect(async () => { result = await execute(run, client); });
+        const record = { cancelled: false };
+        let giveUp;
+        const gaveUp = new Promise(r => { giveUp = r; });
+        const onAbort = () => {
+          record.cancelled = true;
+          out.take();
+          const cmd = text.split(' ')[0];
+          console.log(`[server${client ? `:${client}` : ''}] ${text}: cancelled, its sender gave up${READ_ONLY.has(cmd) ? '' : '; it may still be acting on the page'}`);
+          giveUp(null);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        const output = await Promise.race([out.collect(async () => { result = await execute(run, client, false, record); }), gaveUp]);
+        signal?.removeEventListener('abort', onAbort);
         if (inFlight === flight) inFlight = null;
-        if (!flight.answered) resolve({ status: result.status, output, uncertain: result.uncertain });
+        if (!flight.answered) resolve(output === null ? { status: 'error', output: 'Cancelled: the sender gave up.' } : { status: result.status, output, uncertain: result.uncertain });
       }
       if (!state.stopping) prompt(true);
     }).catch(e => { out.error(`Error: ${e.message}`); resolve({ status: 'error', output: e.message }); });

package/lib/send.js

@@ -6,7 +6,7 @@ const fs = require('fs');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 const client = require('./client');
-const { shellWords, variablesIn } = require('./syntax');
+const { shellWords, variablesIn, SCREENSHOT_FILE } = require('./syntax');
 
 // The prompt, after the modes on in the selected tab if any: (watch network:off) pw[serve]>
 const PROMPT = /^(?:\([^()]*\) )?pw(\[serve\])?>\s*$/;
@@ -93,6 +93,15 @@ function doubleQuote(word) {
   return `"${word.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t')}"`;
 }
 
+// Where eval's --file is, after its --timeout if it has one; -1 when it has none.
+function evalFileAt(words) {
+  if (words[0] !== 'eval') return -1;
+  let at = 1;
+  if (/^--timeout=/.test(words[at] || '')) at += 1;
+  else if (words[at] === '--timeout') at += 2;
+  return /^--file(?:=|$)/.test(words[at] || '') ? at : -1;
+}
+
 // A command's words as send was given them, made into the line the REPL reads: quoted again where the
 // shell had kept a word whole, and with the files it reads or writes made absolute from the sender's
 // folder, since the REPL's may be another.
@@ -104,7 +113,7 @@ function commandLine(words) {
   const { SELECTOR_FIRST } = require('./syntax');
   // So does playwright-cli's storage key (localstorage-set "my key" v).
   // And record's file, which may have spaces in it, and wait's text, whose last word would otherwise be
-  // taken as the seconds when it is a number (wait text 'Showing 1').
+  // taken as the time when it is a number (wait text 'Showing 1').
   const requote = words.length > 1 && (SELECTOR_FIRST.has(words[0]) || words[0] === 'drag' || /^(?:local|session)storage-/.test(words[0]) || words[0] === 'record' || words[0] === 'wait' || /^video-(?:start|stop)$/.test(words[0]));
   // An empty word (fill #name "") is the empty value.
   // upload's files are read by the REPL, whose folder may not be this one.
@@ -123,13 +132,15 @@ function commandLine(words) {
   if (words[0] === 'profile' && words[1] === 'save' && words.length > 2) resolved = ['profile', 'save', resolve(words.slice(2).join(' '))];
   if (words[0] === 'watch' && words[1] === 'save' && words.length > 2) resolved = ['watch', 'save', resolve(words.slice(2).join(' '))];
   // So does the file eval --file reads.
-  if (words[0] === 'eval' && /^--file(?:=|$)/.test(words[1] || '')) {
+  const at = evalFileAt(words);
+  if (at > 0) {
     // As one word, --file=<path>, which is quoted below when the path has spaces.
-    const [file, rest] = words[1] === '--file' ? [words[2], words.slice(3)] : [words[1].slice(7), words.slice(2)];
-    if (file) resolved = ['eval', `--file=${resolve(file)}`, ...rest];
+    const [file, rest] = words[at] === '--file' ? [words[at + 1], words.slice(at + 2)] : [words[at].slice(7), words.slice(at + 1)];
+    if (file) resolved = [...words.slice(0, at), `--file=${resolve(file)}`, ...rest];
   }
   if (words[0] === 'screenshot') {
-    resolved = words.map((w, n) => (w.startsWith('--filename=') && w.length > 11 ? `--filename=${resolve(w.slice(11))}` : words[n - 1] === '--filename' ? resolve(w) : w));
+    // A file as a word of its own is sent as --filename, so a space in it stays in it.
+    resolved = words.map((w, n) => (w.startsWith('--filename=') && w.length > 11 ? `--filename=${resolve(w.slice(11))}` : words[n - 1] === '--filename' ? resolve(w) : n && !w.startsWith('-') && SCREENSHOT_FILE.test(w) ? `--filename=${resolve(w)}` : w));
   }
   const quoted = requote ? resolved.map(w => (w === '' || /[\s"']/.test(w) ? doubleQuote(w) : w)) : resolved;
   // An option's value the shell kept whole stays whole too: --device='iPhone 15'.
@@ -167,7 +178,7 @@ async function sendFile(options) {
     // Read as the prompt reads it; a file it reads or writes is the sender's, as on send's command line.
     const words = shellWords(line);
     // eval's own line keeps its quotes; only eval --file names a file.
-    const command = PATHS.test(words[0]) || (words[0] === 'eval' && /^--file(?:=|$)/.test(words[1] || '')) ? commandLine(words) : line;
+    const command = PATHS.test(words[0]) || evalFileAt(words) > 0 ? commandLine(words) : line;
     const found = options.noVars ? null : variablesFor(command);
     if (found?.error) { console.error(`pw-repl: stopped at line ${i + 1} of ${options.file} (${line}): ${found.error}`); return 1; }
     const status = await send({ ...options, file: null, command, vars: found?.vars || null });
@@ -194,7 +205,7 @@ async function send(options) {
     if (found?.error) return fail(found.error);
     options = { ...options, vars: found?.vars || null };
   }
-  const timeoutMs = options.timeout * 1000;
+  const timeoutMs = options.timeout;
   const way = route(options);
   const name = options.client || process.env.PW_CLIENT || null;
   if (name && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,39}$/.test(name)) return fail('a client name is 1-40 letters, digits, dots, dashes and underscores');

package/lib/server.js

@@ -56,7 +56,10 @@ function handle(req, res) {
     }
     // Bound before the browser is reached, so where and send find it while it starts.
     if (!state.serving) return send(res, 503, { status: 'error', starting: true, output: `The REPL is starting (${state.startingStep}); retry shortly` });
-    const result = await runner.submit(command.trim(), client || null, vars || null);
+    // The sender gave up (send -t) once its connection closes before the answer is written.
+    const gone = new AbortController();
+    res.once('close', () => { if (!res.writableEnded) gone.abort(); });
+    const result = await runner.submit(command.trim(), client || null, vars || null, gone.signal);
     if (!result.uncertain) return send(res, 200, { status: result.status, output: result.output });
     // unconfirmed: the command may or may not have done what it was sent to do.
     send(res, 200, { status: result.status, output: result.output, unconfirmed: true });

package/lib/state.js

@@ -1,14 +1,12 @@
 // Session state shared by the entry point, the runner, and the commands, plus
 // the shutdown that ends the session.
+const { AsyncLocalStorage } = require('async_hooks');
 const out = require('./output');
 
 const SHUTDOWN_TIMEOUT = 5000;
 
 const state = {
   browser: null,
-  // The client whose command runs now: null for the prompt and senders without
-  // a name, who share one selected tab, as before clients had names.
-  client: null,
   rl: null,
   promptBase: 'pw> ',
   // The browser the REPL is connected to, and whether --launch started it.
@@ -36,18 +34,31 @@ function clientRecord(name = state.client) {
   return clients.get(name);
 }
 
+// The command running in this async context: its client, and whether its sender gave up on it.
+// Code outside any command (a browser event, quit and dialog, which skip the queue) goes by the
+// queued command running now.
+const running = new AsyncLocalStorage();
+let queued = null;
+
+// The client whose command runs now: null for the prompt and senders without a name, who share one
+// selected tab, as before clients had names. Each command keeps its own for its whole life, so one
+// its sender gave up on, still running, never acts as the command after it.
+Object.defineProperty(state, 'client', { enumerable: true, get: () => (running.getStore() ?? queued)?.client ?? null });
+
+out.onCancelled(() => running.getStore()?.cancelled === true);
+
 for (const key of Object.keys(PER_CLIENT)) {
   Object.defineProperty(state, key, { enumerable: true, get: () => clientRecord()[key], set: value => { clientRecord()[key] = value; } });
 }
 
-// Runs fn as the named client. Commands run one at a time, so this is safe.
-async function asClient(name, fn) {
-  const previous = state.client;
-  state.client = name || null;
-  try { return await fn(); } finally { state.client = previous; }
+// Runs fn as the named client. run is the command's record, whose cancelled the runner sets.
+async function asClient(name, fn, run = {}) {
+  queued = Object.assign(run, { client: name || null });
+  try { return await running.run(run, fn); } finally { if (queued === run) queued = null; }
 }
 
 const cleanups = [];
+const endings = [];
 const exitWaits = [];
 let shutdownPromise = null;
 
@@ -65,6 +76,11 @@ function onShutdown(fn) {
   cleanups.push(fn);
 }
 
+// Run once every cleanup has finished, before the browser is closed.
+function onShutdownEnd(fn) {
+  endings.push(fn);
+}
+
 // Things to finish before the process exits, e.g. answers still being sent.
 function onBeforeExit(fn) {
   exitWaits.push(fn);
@@ -80,6 +96,7 @@ async function shutdown() {
   shutdownPromise = (async () => {
     // Some undo what the REPL changed in the browser, so they finish first.
     await withTimeout(Promise.all(cleanups.map(async fn => fn())), 'Cleanup').catch(() => {});
+    for (const fn of endings) try { await fn(); } catch {}
     if (state.browser) {
       try { await withTimeout(state.browser.close(), 'Chromium shutdown'); }
       catch (error) { state.shutdownFailed = true; process.exitCode = 1; out.error(`Could not confirm Chromium shutdown: ${error.message}`); }
@@ -88,4 +105,4 @@ async function shutdown() {
   return shutdownPromise;
 }
 
-module.exports = { state, clientRecord, asClient, withTimeout, onShutdown, onBeforeExit, beforeExit, shutdown, SHUTDOWN_TIMEOUT };
+module.exports = { state, clientRecord, asClient, withTimeout, onShutdown, onShutdownEnd, onBeforeExit, beforeExit, shutdown, SHUTDOWN_TIMEOUT };

package/lib/syntax.js

@@ -89,4 +89,7 @@ function expandVariables(line, values) {
   });
 }
 
-module.exports = { SELECTOR_FIRST, REF, toSelector, unescapeDouble, unquote, shellWords, splitSelector, keyName, variablesIn, expandVariables };
+// A screenshot's file given as a word of its own: a name has neither a / nor an extension.
+const SCREENSHOT_FILE = /\/|\.(?:png|jpe?g)$/i;
+
+module.exports = { SELECTOR_FIRST, REF, SCREENSHOT_FILE, toSelector, unescapeDouble, unquote, shellWords, splitSelector, keyName, variablesIn, expandVariables };

package/lib/tabs.js

@@ -21,6 +21,12 @@ async function navigating(go) {
     for (let waited = 0; !find() && waited < 1000; waited += 50) await new Promise(resolve => setTimeout(resolve, 50));
     const navigation = find();
     if (!navigation) throw error;
+    // Chrome commits its error page just after the request fails: waited for, so info right after reads it.
+    // Capped at 1s, for a failure with no error page; a tab already on one matches at once, which info
+    // still reads right, from the log.
+    if (!stayedPut(navigation) && !/ERR_ABORTED/.test(`${navigation.status} ${navigation.failed}`)) {
+      for (let waited = 0; !state.page.url().startsWith('chrome-error://') && waited < 1000; waited += 50) await new Promise(resolve => setTimeout(resolve, 50));
+    }
     throw new Error(notLoaded(navigation));
   }
 }

package/lib/toast.js

@@ -7,6 +7,7 @@ const { unquote } = require('./syntax');
 const { takeOptions } = require('./cli-names');
 const { inOverlay, keepAcrossPages, forget } = require('./overlay');
 const { recordingOf, beforeRecordingEnds } = require('./record');
+const { parseDuration } = require('./util');
 
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
@@ -81,12 +82,6 @@ async function toastOff(p, fade = true) {
 beforeRecordingEnds(p => (p && !p.isClosed() ? waitToRead(p) : null));
 
 // 3s, 1.5s, 800ms, or a number of milliseconds.
-function parseDuration(value) {
-  const match = /^(\d+(?:\.\d+)?)(ms|s)?$/.exec(value || '');
-  if (!match) return null;
-  return Math.round(Number(match[1]) * (match[2] === 's' ? 1000 : 1));
-}
-
 onShutdown(async () => {
   if (!state.browser || state.connectionLost) return;
   const pages = state.browser.contexts().flatMap(c => c.pages()).filter(p => !p.isClosed());

package/lib/util.js

@@ -20,6 +20,28 @@ function hints(pairs) {
   return `\n${pairs.map(([command, what]) => `  ${command.padEnd(width)}  ${what}`).join('\n')}`;
 }
 
+// A time: milliseconds, as Playwright and JavaScript count it, or seconds with an s (1500, 1.5s, 1500ms).
+const TIME = /^(\d+(?:\.\d+)?)(ms|s)?$/;
+
+function parseDuration(value) {
+  const match = TIME.exec(value || '');
+  if (!match) return null;
+  return Math.round(Number(match[1]) * (match[2] === 's' ? 1000 : 1));
+}
+
+// How a time reads back: 1.5s, or 250ms under a second.
+function durationText(ms) {
+  return ms >= 1000 ? `${Number((ms / 1000).toFixed(3))}s` : `${ms}ms`;
+}
+
+// A time that is a second or more, where a smaller one is most likely seconds written as before.
+function longDuration(value, what) {
+  const ms = parseDuration(value);
+  if (ms === null) throw new Error(`${what} is a time, in milliseconds or with s for seconds: 30000 or 30s (got ${value})`);
+  if (ms < 1000) throw new Error(`${what} is in milliseconds, 1000 or more: ${value} is ${durationText(ms)}; ${value}s for seconds`);
+  return ms;
+}
+
 function clipText(text) {
   return text.length > MAX_EVENT_TEXT ? `${text.slice(0, MAX_EVENT_TEXT)}…` : text;
 }
@@ -56,6 +78,8 @@ function clock(t) {
 // by itself unseen: stop prints those lines.
 const STOPPED_RECORDING = 'The REPL stopped, which ended a recording';
 const ENDED_UNSEEN = 'A recording ended before the REPL stopped, unseen since';
+// Each line stop prints of the files a client left.
+const FILES_LEFT = 'Files left';
 
 // Where Playwright installs its browsers and ffmpeg, worked out as playwright-core does it: a cache of
 // each platform's own (~/Library/Caches on macOS), unless PLAYWRIGHT_BROWSERS_PATH says otherwise.
@@ -69,4 +93,4 @@ function playwrightBrowsersDir() {
   return path.join(cache, 'ms-playwright');
 }
 
-module.exports = { BUSY_PAGE, STOPPED_RECORDING, ENDED_UNSEEN, COMMAND_TIMEOUT, MAX_EVENT_TEXT, NO_TAB, hints, clipText, numbers, regexOf, patternText, clock, playwrightBrowsersDir };
+module.exports = { TIME, parseDuration, durationText, longDuration, BUSY_PAGE, STOPPED_RECORDING, ENDED_UNSEEN, FILES_LEFT, COMMAND_TIMEOUT, MAX_EVENT_TEXT, NO_TAB, hints, clipText, numbers, regexOf, patternText, clock, playwrightBrowsersDir };

package/lib/watch.js

@@ -4,6 +4,7 @@ const out = require('./output');
 const { printOutput } = out;
 const fs = require('fs');
 const path = require('path');
+const { noteWritten } = require('./written');
 const { clipText, clock, hints, NO_TAB } = require('./util');
 const { tabState } = require('./tabstate');
 const { keptSession, keepDrawing } = require('./cdp');
@@ -22,8 +23,8 @@ const PW_SETTINGS = ['PW_CDP_URL', 'PW_CHROME', 'PW_CLIENT', 'PW_ENDPOINT', 'PW_
   'PW_SOCKET', 'PW_START_URL', 'PW_TEST_CHROME', 'PW_TMUX_SESSION'];
 const PAGE_ACTIONS = new Set(['click', 'check', 'uncheck', 'select', 'fill', 'type', 'press', 'submit']);
 const WATCH_BINDING = '__pwReplWatch';
-// Seconds a saved step waits for its element after the app's own routing (watch save).
-const ROUTE_WAIT = 30;
+// How long a saved step waits for its element after the app's own routing (watch save).
+const ROUTE_WAIT = '30s';
 
 // Runs in the page. Describes elements the way snapshot does: role and name.
 const WATCH_SCRIPT = `(() => {
@@ -811,6 +812,7 @@ const commands = {
       if (variables.length) header.push(`# It needs ${variables.join(', ')} set in the environment: what was typed into ${where}, not saved here`);
       // It holds what was typed, so it is the user's own to read.
       fs.writeFileSync(file, `${[...header, ...lines].join('\n')}\n`, { mode: 0o600, flag: 'wx' });
+      noteWritten(file, 'watch file');
       out.log(`Saved ${watch.events.length} step${watch.events.length === 1 ? '' : 's'} to ${file}${skipped ? `; ${skipped} could not be written as commands, and are comments there saying why` : ''}.`);
       if (variables.length) out.log(`What was typed into ${where} is a variable there, filled in from the environment: ${variables.map(name => `{{ ${name} }}`).join(', ')}.`);
       out.log(`${variables.map(name => `${name}=... `).join('')}pw-repl send --file ${file} runs them.`);