pw-repl 0.12.8 → 0.14.0

package/AGENTS.md

@@ -23,7 +23,7 @@ If you hit a limitation or write a workaround, consider adding the capability to
   `lib/routes.js`, `lib/network.js`, `lib/emulation.js` (and viewport), `lib/capture.js`, `lib/profile.js` (performance traces;
   `lib/trace.js` reads and sums them up), `lib/record.js`
   (video, through ffmpeg, and the steps file saved with it), `lib/dialogs.js` and `lib/modes.js`. Beneath them, `lib/tabstate.js` is the one record kept per tab, `lib/cdp.js` the CDP
-  session kept per tab, and `lib/util.js` small shared helpers. No facility requires `lib/modes.js` or
+  session kept per tab, `lib/util.js` small shared helpers, and `lib/written.js` the files written and for whom. No facility requires `lib/modes.js` or
   `lib/commands.js`, and a unit test fails on a require cycle, which CommonJS would not report.
 - `bin/pw-repl.js` is the command line; `lib/start.js` connects and runs the prompt; `lib/runner.js`
   runs commands one at a time (`quit` and `dialog` skip its queue); `lib/server.js` is the command
@@ -39,7 +39,7 @@ If you hit a limitation or write a workaround, consider adding the capability to
   accepts theirs too (`lib/cli-names.js`, `help playwright-cli`). Deviate only where it is necessary, as
   where sharing a browser with a user needs it, and say why in the help.
 - Comment the *why* when it isn't obvious from the code.
-- `npm test` runs the suite (under two minutes): a private headless Chromium, a local test site
+- `npm test` runs the suite (about two and a half minutes): a private headless Chromium, a local test site
   (`test/harness.js`), and the real REPL with its server. Nothing is mocked, and the shared browser is
   never touched. It finds Chromium through `PW_TEST_CHROME`, or where `--launch` looks (Playwright's
   browsers, then the `PATH`), and skips the browser tests if there is none. Add a test with each new
@@ -56,48 +56,24 @@ If you hit a limitation or write a workaround, consider adding the capability to
   after an intended change to it, save it again (the command is in `test/units.test.js`). The common
   tasks and modes on help's front page (`TASKS` and `MODES`) are the README's too: change both, as a
   unit test compares them.
-- Time each full run, and put the result in the body of the commit it tests (`npm test: 151 tests, 79s`).
-  Compare with the last commit that has one (`git log --grep='npm test:'`): a run that grew by more than
-  a few seconds means a slow test crept in, usually one waiting out a real timeout (5s for a click).
+- Time each full run, and put the result in the body of the commit it tests (`npm test: 151 tests, 79s`),
+  with the load average (`uptime`) when it is high. Compare with the last commit that has one (`git log
+  --grep='npm test:'`): a run that grew by more than a few seconds, at a like load (a busy machine slows
+  every test), means a slow test crept in, usually one waiting out a real timeout (5s for a click).
   Find it (each test prints its time) and make it faster, or say why it can't be, before committing.
 - Don't race the clock in a test: a page that changes on a timer, or a command timed against a budget,
   fails on a busy machine. Have the page change when the test asks (eval), or measure the thing itself
   (frames drawn, not clicks timed). A click waits for its element to hold still for two frames.
 - For anything the tests can't reach, exercise the change in a running REPL of your own: on a socket of
   your own, with `--launch` unless the change needs the user's browser, and then in a tab of your own.
+  One started before a change to `lib/` runs the old code: restart it after a change. Stop a process by
+  its pid, after checking what it is; a broad `pkill -f` pattern can match your own shell, or a REPL
+  someone else is using.
 - `skill/SKILL.md` is how agents learn to use the REPL: keep it in step with a change to how it is
   used, and leave its Custom rules section empty. Keep its `<!-- pw-repl skill stamp -->` line: `pw-repl
   skill` replaces it with the version and a hash of the skill's text, which `where` reports, so agents
   can tell a saved copy is out of date.
 
-## Waves
-
-Work goes in waves, and each one ends with a release that is ready to push.
-
-1. Build what was asked, with tests, and try it in a running REPL. For anything the user will look at
-   (a cursor, an overlay, a video), show them a demo while it is still a prototype (a recording or
-   screenshots they can open) and get their go-ahead on how it looks before writing tests or
-   building on it.
-2. Try it on a fresh agent that has not seen the code or the change (a guinea pig), on something real: a
-   small local page whose planted bugs need the change to find.
-   - Brief it with goals only: what to find out or do in the browser, never the commands.
-   - First it reads back its plan, learned from `pw-repl skill` and help alone: the commands, where it
-     found them, and what is unclear. It runs nothing yet.
-   - A wrong or unsure plan means the docs or the brief were unclear: find out which, fix that, then
-     ask again.
-   - Then it carries the plan out, in a browser and on a socket of its own, and reports as it goes:
-     above all, where the tool did something other than what the docs led it to expect.
-   - Once it has confirmed the fixes work, it reviews them as a second pair of eyes: anything important
-     they miss or get wrong, not nitpicks.
-3. Triage what it reports. Fix what matters, and what is small and useful; don't put off something
-   useful for later. Leave trivia alone, and say why.
-4. Repeat 2 and 3, with a fresh agent each time, until a pass comes back clean: no real bugs, and
-   nothing unclear in the docs or the brief that changed the plan. A pass after fixes tries the fixes,
-   and something not tried yet.
-5. Only then cut the release (Releasing, steps 1-3), and say it is ready. The maintainer pushes and
-   publishes it, and the next wave starts from what they find. A release cut too early and not pushed
-   yet is undone (its commit and tag) and cut again after the fixes.
-
 ## Releasing
 
 Commits follow [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `docs:`,
@@ -105,13 +81,19 @@ Commits follow [Conventional Commits](https://www.conventionalcommits.org/): `fe
 1.0, a change that breaks how the REPL is used is a minor bump (0.2.0 to 0.3.0), anything else a patch.
 
 1. `npm test` passes and the working tree is clean.
-2. `npm outdated` and `npm audit` show nothing that needs doing first. The lockfile holds playwright-core
-   at 1.63: on 1.64 (and 1.64.1), a click on a link to a 204 waits out its timeout instead of returning (the test
-   "waits for the page to load, counting a navigation that just began" fails). Update it once a version
-   passes `npm test`.
+2. `npm outdated` and `npm audit` show nothing that needs doing first. Dependencies are always the newest
+   stable release, never pinned back. When the newest breaks a test, fix it in our code; only a
+   regression of the dependency's own, with the fix already in its next release, keeps the version before
+   it, until that release ships. playwright-core stays at 1.63 for that reason: on 1.64.1 a click
+   on a link to a 204 hangs at "waiting for scheduled navigations to finish" until its timeout, in plain
+   Playwright too (chromium.launch, a page with a link to a 204, page.click on it); 1.65's alphas fix it.
+   The test "waits for the page to load, counting a navigation that just began" shows it: move up once it
+   passes on the newest release.
 3. `npm version <patch|minor|major> -m "chore: release %s"` sets the version in `package.json` and
    `package-lock.json`, commits it as `chore: release X.Y.Z`, and tags that commit `vX.Y.Z`.
 4. `git push --follow-tags` pushes the commits and the tag.
 5. `npm publish` publishes it; `prepublishOnly` runs the tests again first.
 
+A release cut too early and not pushed yet is undone (its commit and tag) and cut again after the fixes.
+
 Pushing and publishing need the maintainer's GitHub and npm credentials.

package/README.md

@@ -83,7 +83,7 @@ With `npx`, use `npx pw-repl@latest` the same way every time, so every command r
   whole tab's network.
 - **Emulate:** a phone, dark mode, a locale, a timezone, a viewport size.
 - **Run code:** `eval` any JavaScript in the page, a line or a file of it, or send a raw CDP command with
-  `cdp`.
+  `cdp`; read what a Copy button put on the clipboard (`clipboard`).
 - **Wait:** for an element, some text, a response or a page load.
 - **Record:** what someone does in a tab (`watch`), a timeline of requests and console (`capture`), or a
   video of the tab (`record`), with a virtual pointer (`cursor`), captions (`toast`) and highlights
@@ -154,7 +154,7 @@ example the Docker bridge gateway, `ip route | awk '/default/ {print $3}'`).
 | record requests and console together  | `capture on`, then `capture off`                              |
 | find what makes the page slow         | `profile on`, then `profile off`; `profile reload` for a load |
 | fake a backend response               | `route <glob> <status> <json>`, `route <glob> abort`          |
-| change or slow an API response        | `route <glob> patch <json>`, `route <glob> delay <secs>`      |
+| change or slow an API response        | `route <glob> patch <json>`, `route <glob> delay <time>`      |
 | cut or slow the whole network         | `network off`, `network slow`, then `network on`              |
 | record a video of the page            | `record on`, then `record off` (`help video` for a take)      |
 | show a pointer where the agent acts   | `cursor on`, then `cursor off`                                |
@@ -199,7 +199,10 @@ pw-repl where           # which REPL send would reach
 
 `pw-repl send` sends one command and prints its result, through the server when one is running, and
 through the `pw-repl` tmux session otherwise. Chain several in the shell: `&&` stops at the first that
-fails or is not confirmed (exit 1 or 2), and `;` carries on.
+fails or is not confirmed (exit 1 or 2), and `;` carries on. `-t` is how long it waits for the answer
+(default 20s). Times, there and in every command, are in milliseconds, as in Playwright, or in seconds
+with an `s`: `-t 90000` or `-t 90s`. A send that gives up cancels its command: one still queued never
+runs, and one running is no longer waited for.
 
 Several agents can share one REPL. `pw-repl send -c <name>` (or `PW_CLIENT=<name>`) sends as a client
 with a selected tab of its own, shown in the REPL as `[server:<name>]`. `modes` says which client turned
@@ -227,7 +230,8 @@ The body may also have `"client": "<name>"`, and `"vars": {"PW_NAME": "<value>"}
 "error", "output": "..."}`, plus `"unconfirmed": true` when the command may or may not have done what it
 was sent to do (it timed out, or the REPL quit while it ran and it was not read-only). While the REPL
 starts, `/run` answers 503 with `"starting": true`: retry. `GET /health` says `"status": "starting"` until
-it serves, then `"ok"`. `pw-repl serve <port>` serves TCP on 127.0.0.1; other addresses are refused.
+it serves, then `"ok"`. A client that closes its connection before the answer cancels the command, as
+`send` does when it gives up. `pw-repl serve <port>` serves TCP on 127.0.0.1; other addresses are refused.
 
 ## How it differs from playwright-cli
 
@@ -237,6 +241,7 @@ playwright-cli's command names and most of their options work here too (`help pl
 them). Where pw-repl differs, it is mostly because someone else may be using the browser:
 
 - `open` and `close` open a tab and turn off your modes; they never start, close or wipe a browser.
+  `close` also lists the files you wrote that are still there.
 - Routes, network and emulation apply to one tab, not the whole browser.
 - File pickers are not caught, since they may be the user's: `upload` names the input instead.
 - There is no snapshot after every command, since the user reads the REPL too; `snapshot` shows one.

package/bin/pw-repl.js

@@ -2,6 +2,7 @@
 // The one command: pw-repl run | serve | attach | stop | send | where | help | skill.
 
 const { looksLikeEndpoint } = require('../lib/client');
+const { longDuration } = require('../lib/util');
 
 const USAGE = `Usage:
   pw-repl run [--launch [--headed]] [start-url] [-- <chromium flags>]
@@ -19,7 +20,7 @@ const USAGE = `Usage:
       stop a background REPL, and say what became of each recording it ended; its socket is removed, its
       log stays
 
-  pw-repl send [-e endpoint | -s session] [-c client] [-t seconds] [--no-vars]
+  pw-repl send [-e endpoint | -s session] [-c client] [-t time] [--no-vars]
                <command...> | --file <file>
       run one command in a running REPL and print its output; --file runs a file of them, one per line
 
@@ -56,12 +57,14 @@ serves on that same one: $PW_ENDPOINT, then $PW_SOCKET, then the default.
 send -c <client> (or $PW_CLIENT) sends as a client of the REPL's with a selected tab of its own, so
 several agents can share one REPL; pw-repl help session has the rest.
 
-send's options can also follow the command, as in pw-repl send open <url> -t 30; after a -- before the
-command, every word is the command's, -t 30 included.
+send's options can also follow the command, as in pw-repl send open <url> -t 30s; after a -- before the
+command, every word is the command's, -t 30s included.
 
 Exit status: 0 ok, 1 command error, 2 completion not confirmed, 64 usage or unreachable. -t is how long
-send waits for the answer (default 20s); it does not lengthen a command's own limits, such as the 5s an
-action waits for its element.
+send waits for the answer, in milliseconds or with s for seconds (default 20s: 20000); it does not
+lengthen a command's own limits, such as the 5s an action waits for its element. Over the server, giving
+up cancels the command: one still queued is never run, and one running is no longer waited for, though
+what it began in the page may go on.
 
 --file <file> runs each line of a file as a command, in order, as if typed at the REPL's prompt: quoted
 as the prompt reads it (no shell), with a file it records, uploads or saves relative to this folder, as
@@ -105,10 +108,10 @@ function shellLine(words) {
 }
 
 // -e, -s, -c and -t, then the command words (unquoted words are one command), and send's options again
-// at the end, as an agent types them (send open <url> -t 30); after --, every word is the command.
+// at the end, as an agent types them (send open <url> -t 30s); after --, every word is the command.
 function parseSendArgs(args, subcommand) {
   const allowCommand = subcommand === 'send';
-  const options = { endpoint: null, session: null, client: null, timeout: 20, command: '', file: null };
+  const options = { endpoint: null, session: null, client: null, timeout: 20000, command: '', file: null };
   const given = new Set();
   const take = (arg, value, after) => {
     if (value === undefined) usage(`${arg} needs a value`, subcommand);
@@ -120,8 +123,7 @@ function parseSendArgs(args, subcommand) {
     if (arg === '-s') options.session = value;
     if (arg === '-c') options.client = value;
     if (arg === '-t') {
-      if (!/^\d+$/.test(value) || Number(value) < 1) usage(`-t takes whole seconds, 1 or more (got ${value})`, subcommand);
-      options.timeout = Number(value);
+      try { options.timeout = longDuration(value, '-t'); } catch (error) { usage(error.message, subcommand); }
     }
   };
   let i = 0;
@@ -296,7 +298,7 @@ async function main() {
     case '--help':
       return console.log(`${USAGE}\n\n${REPL_HELP}`);
     default: {
-      // An option before the subcommand (pw-repl -t 30 send ...): say where it goes, with the line fixed.
+      // An option before the subcommand (pw-repl -t 30s send ...): say where it goes, with the line fixed.
       if (subcommand.startsWith('-')) {
         const all = [subcommand, ...args];
         const named = all.find(word => SUBCOMMANDS.includes(word));

package/lib/background.js

@@ -5,7 +5,7 @@ const path = require('path');
 const readline = require('readline');
 const { spawn } = require('child_process');
 const client = require('./client');
-const { STOPPED_RECORDING, ENDED_UNSEEN } = require('./util');
+const { STOPPED_RECORDING, ENDED_UNSEEN, FILES_LEFT } = require('./util');
 
 const BIN = path.join(__dirname, '..', 'bin', 'pw-repl.js');
 const START_TIMEOUT = 20000;
@@ -162,7 +162,7 @@ async function stop(options) {
     fs.closeSync(fd);
     logged = buffer.toString('utf8');
   } catch {}
-  for (const line of logged.split('\n')) if (line.startsWith(STOPPED_RECORDING) || line.startsWith(ENDED_UNSEEN)) console.log(line);
+  for (const line of logged.split('\n')) if (line.startsWith(STOPPED_RECORDING) || line.startsWith(ENDED_UNSEEN) || line.startsWith(FILES_LEFT)) console.log(line);
   return 0;
 }
 

package/lib/capture.js

@@ -2,7 +2,7 @@
 const { state, onShutdown } = require('./state');
 const out = require('./output');
 const { printOutput } = out;
-const { numbers, MAX_EVENT_TEXT, NO_TAB, clock, hints } = require('./util');
+const { numbers, MAX_EVENT_TEXT, NO_TAB, clock, hints, TIME, longDuration, durationText } = require('./util');
 const { consoleText, requestEntries } = require('./requestlog');
 
 const MAX_CAPTURE_EVENTS = 10000;
@@ -17,16 +17,15 @@ function currentCapture() {
 }
 
 // Records the selected tab's requests and console messages together, in time
-// order, until capture off, or for a set number of seconds.
+// order, until capture off, or for a set time.
 async function startCapture(tokens) {
   if (cap) { out.log('Already capturing; capture off stops it.'); return; }
   if (!state.page || state.page.isClosed()) throw new Error(NO_TAB);
-  const usage = 'Usage: capture on [requests|console] [seconds] (seconds from 1 to 3600)';
+  const usage = 'Usage: capture on [requests|console] [time] (ms, or 30s)';
   const kinds = tokens.filter(t => t === 'requests' || t === 'console');
-  const numbers = tokens.filter(t => /^\d+$/.test(t));
-  if (kinds.length > 1 || numbers.length > 1 || kinds.length + numbers.length !== tokens.length) throw new Error(usage);
-  const seconds = numbers.length ? Number(numbers[0]) : null;
-  if (seconds !== null && (seconds < 1 || seconds > 3600)) throw new Error(usage);
+  const times = tokens.filter(t => TIME.test(t));
+  if (kinds.length > 1 || times.length > 1 || kinds.length + times.length !== tokens.length) throw new Error(usage);
+  const ms = times.length ? longDuration(times[0], 'capture on\'s time') : null;
   const label = kinds[0] || 'requests and console';
   const startedAt = Date.now();
   const events = [];
@@ -61,11 +60,11 @@ async function startCapture(tokens) {
     get shortened() { return shortened; },
   };
   cap = capture;
-  if (seconds) {
-    out.log(`Capturing ${label} for ${seconds}s...`);
+  if (ms) {
+    out.log(`Capturing ${label} for ${durationText(ms)}...`);
     // Also ends early if the capture does, e.g. because its tab closed.
     await new Promise(resolve => {
-      const timer = setTimeout(resolve, seconds * 1000);
+      const timer = setTimeout(resolve, ms);
       capture.wake = () => { clearTimeout(timer); resolve(); };
     });
     if (cap === capture) stopCapture();
@@ -120,7 +119,7 @@ const commands = {
     const [sub, ...rest] = (args || '').trim().split(/\s+/).filter(Boolean);
     if (sub === 'on') return startCapture(rest);
     if (sub === 'off' && !rest.length) return stopCapture(all);
-    if (sub) throw new Error('Usage: capture on [requests|console] [seconds] | capture off');
+    if (sub) throw new Error('Usage: capture on [requests|console] [time] | capture off');
     if (cap) {
       out.log(`Capturing ${cap.label} on ${cap.page.url()} since ${clock(cap.startedAt)} (${cap.events.length} so far)`);
       out.log(hints([['capture off', 'stop and print what it recorded']]));
@@ -132,7 +131,7 @@ const commands = {
     } else {
       out.log('Not capturing.');
     }
-    out.log(hints([['capture on [requests|console] [seconds]', 'record the selected tab\'s requests and console messages in time order']]));
+    out.log(hints([['capture on [requests|console] [time]', 'record the selected tab\'s requests and console messages in time order']]));
   },
 };
 

package/lib/cli-names.js

@@ -15,7 +15,7 @@ const NAMES = {
   'tab-close': [a => (a ? null : 'tab close'), 'tab close [url-part], or tab <index> then tab close'],
   open: [a => `tab new ${a}`.trim(), 'tab new [url] (goto <url> navigates); --mobile, --device=<name>: emulate mobile'],
   // It ends playwright-cli's own browser; this one is shared, so tabs stay open.
-  close: [() => 'close', 'modes off --mine, and tabs stay open'],
+  close: [() => 'close', 'modes off --mine; tabs stay open; lists the files you wrote'],
   'go-back': [() => 'back', 'back'],
   'go-forward': [() => 'forward', 'forward'],
   find: [a => `snapshot --grep ${a}`, 'snapshot --grep <text>'],

package/lib/commands.js

@@ -1,6 +1,7 @@
 // The REPL's commands, gathered from each facility's module, and what the prompt and the runner
 // need besides: playwright-cli's own commands, the hooks every page gets, and tab completion.
 const { state, shutdown } = require('./state');
+const { ownFilesText } = require('./written');
 const out = require('./output');
 const HELP = require('./help');
 const { tabState } = require('./tabstate');
@@ -80,6 +81,8 @@ const cliCommands = {
     await allModesOff(true);
     const own = state.browser.contexts().flatMap(c => c.pages()).filter(p => tabState(p).owner === state.client);
     if (own.length) out.log(`Tabs you opened are still open: ${own.map(p => p.url()).join(', ')}; tab close <url-part> closes one, or select it and tab close.`);
+    const files = ownFilesText(state.client);
+    if (files) out.log(files);
   },
 };
 

package/lib/elements.js

@@ -39,7 +39,7 @@ const MODIFIERS = ['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift'];
 // click takes --click-count too; dblclick is click's count of 2.
 function clickArgs(args, usage, counts = false) {
   // Found outside quotes only, so a quoted selector keeps whatever is in it.
-  const { found, rest: text } = takeOptions((args || '').trim(), { modifiers: 'value', button: 'value', 'click-count': 'value' });
+  const { found, rest: text } = takeOptions((args || '').trim(), { modifiers: 'value', button: 'value', 'click-count': 'value', force: 'flag' });
   if (!counts && found.some(o => o.name === 'click-count')) throw new Error('dblclick is a click count of 2; for another count, click --click-count=<n>');
   const clickCount = clickCountOf(found, usage);
   const modifiers = found.filter(o => o.name === 'modifiers').flatMap(o => (o.value || '').split(',').filter(Boolean).map(keyName));
@@ -49,12 +49,14 @@ function clickArgs(args, usage, counts = false) {
   const positional = parsed && /^(?:left|right|middle)$/.test(parsed.rest || '') && (REF.test(parsed.word) || /^["']/.test(text)) ? parsed.rest : null;
   const button = chooseButton(found, positional, usage);
   const selector = positional ? parsed.selector : soleSelector(text, usage);
-  const options = { ...(button ? { button } : {}), ...(modifiers.length ? { modifiers } : {}), ...(clickCount > 1 ? { clickCount } : {}) };
+  const force = found.some(o => o.name === 'force');
+  const options = { ...(button ? { button } : {}), ...(modifiers.length ? { modifiers } : {}), ...(clickCount > 1 ? { clickCount } : {}), ...(force ? { force } : {}) };
   // The selector as written, then the kind of click, so an option never reads as part of the selector.
   const kind = [
     ...(button && button !== 'left' ? [`${button} button`] : []),
     ...(clickCount > 1 ? [`${clickCount} times`] : []),
     ...(modifiers.length ? [`with ${modifiers.join('+')}`] : []),
+    ...(force ? ['forced'] : []),
   ];
   return { selector, shown: [positional ? parsed.word : unquote(text), ...kind].join(', '), options };
 }
@@ -104,8 +106,9 @@ async function onElement(selector, action, budget = 5000) {
     console.error(`Playwright's call log:\n${message}`);
     // Found, so the ref is not stale: no hint.
     const summary = new Error(`Timed out after ${budget / 1000}s on ${ref || selector}: ${lastBlocker(message)} (its call log is in the REPL's pane or log)`);
-    // Worked out from the whole log: the summary no longer says whether the element was found.
-    summary.uncertain = !/waiting for locator/.test(message) || /resolved to/.test(message);
+    // Unknown only once input was sent, in any retry. Playwright's checks (visible, enabled, stable, and
+    // an element covering the point) come before it logs "performing <x> action" and sends it.
+    summary.uncertain = /performing \w+ action/.test(message);
     throw summary;
   }
 }
@@ -227,6 +230,18 @@ function mouseButton(args, name) {
 // A page that renders the chosen element again (as React lists do) replaces it before it is
 // acted on; it is chosen again then, as Playwright finds a locator's element again.
 async function pointerAction(selector, act, options = {}, clicks = 0) {
+  try {
+    return await choosingPointerAction(selector, act, options, clicks);
+  } catch (error) {
+    // Playwright counts aria-disabled as disabled, though a page may keep such an element clickable.
+    if (clicks && !options.force && /: element is not enabled \(/.test(error.message)) {
+      error.message += '\nIt may be aria-disabled, which counts as disabled; --force clicks it anyway (help click).';
+    }
+    throw error;
+  }
+}
+
+async function choosingPointerAction(selector, act, options, clicks) {
   const TIMEOUT = 5000;
   const deadline = Date.now() + TIMEOUT;
   const left = () => Math.max(1000, deadline - Date.now());
@@ -426,13 +441,13 @@ function dateInputHolds(kind, value, what, selector) {
 
 const commands = {
   async click(args) {
-    const { selector, shown, options } = clickArgs(args, 'click <selector> [left|right|middle] [--button=<button>] [--click-count=<n>] [--modifiers=<key>[,<key>]]', true);
+    const { selector, shown, options } = clickArgs(args, 'click <selector> [left|right|middle] [--button=<button>] [--click-count=<n>] [--modifiers=<key>[,<key>]] [--force]', true);
     const which = await pointerAction(selector, (on, sel, o) => (sel ? on.click(sel, o) : on.click(o)), options, options.clickCount || 1);
     out.log(`Clicked: ${shown}${which}`);
   },
 
   async dblclick(args) {
-    const { selector, shown, options } = clickArgs(args, 'dblclick <selector> [left|right|middle] [--button=<button>] [--modifiers=<key>[,<key>]]');
+    const { selector, shown, options } = clickArgs(args, 'dblclick <selector> [left|right|middle] [--button=<button>] [--modifiers=<key>[,<key>]] [--force]');
     const which = await pointerAction(selector, (on, sel, o) => (sel ? on.dblclick(sel, o) : on.dblclick(o)), options, 2);
     out.log(`Double-clicked: ${shown}${which}`);
   },