rechrome 1.28.2 → 1.29.1

package/README.md

@@ -88,13 +88,14 @@ On the host (the machine with Chrome):
 rech listener add share --listen local --prefix=rechrome --port 13776 --profile you@example.com
 tailscale serve --bg --set-path=/rechrome 13776
 rech listener set share --public-url https://host.example.ts.net/rechrome/
-rech url you@example.com --listener share        # prints the URL to share — it contains a secret key
+rech share you@example.com                       # prints the URL to share — it contains a secret key
 ```
 
 `rech listener add` prints these follow-up lines with your port filled in. For scripts,
 `rech listener port share` prints the port (`$(rech listener port share)` in bash or PowerShell).
 
-On the other machine, inside the project that should use it:
+On the other machine, inside the project that should use it (or just open the link in a
+browser: it shows these commands, per shell, with a Copy button):
 
 ```bash
 rech connect 'https://host.example.ts.net/rechrome/?profile=you%40example.com#key=…'
@@ -106,13 +107,13 @@ rech open https://example.com
 interactions, but not `eval`/`run-code` or filesystem commands (see [Remote access](#remote-access)).
 
 On a trusted LAN without a proxy, `rech setup --listen lan --profile you@example.com` binds the
-profile to your LAN address directly (plain HTTP); share the result of `rech url`.
+profile to your LAN address directly (plain HTTP); share the result of `rech share`.
 
 ### 5. Manage access
 
 ```bash
-rech url ls                                   # every listener × profile, local and public URLs (keys hidden)
-rech url you@example.com --listener share     # print one URL again (add --save to use it in this project)
+rech share ls                                 # everything shared: listener × profile, local and public URLs (keys hidden)
+rech share you@example.com                    # print one URL again (add --save to use it in this project)
 rech listener allow share teammate@example.com
 rech listener deny share teammate@example.com
 rech listener rotate-key share                # revoke: every URL for this listener stops working
@@ -193,7 +194,7 @@ Connection parameters also accept URL fragments:
 RECHROME_URL='https://your-host.ts.net/rechrome/?profile=qa#key=DAEMON_KEY' rech status
 ```
 
-`rech setup` prints and saves this URI format. Retrieve it later with `rech url qa` (alias: `rech profile qa --print-uri`), or omit `qa` to use the configured profile. `profiles` remains an alias. The command prints only the URI to stdout, using the configured `RECHROME_URL` endpoint; `--listener local` selects a local listener instead. For example: `rech profile qa --print-uri --listener local`. The output contains a secret daemon key.
+`rech setup` prints and saves this URI format. Retrieve it later with `rech share qa` (alias: `rech profile qa --print-uri`), or omit `qa` to use the configured profile. `profiles` remains an alias. The command prints only the URI to stdout, using the configured `RECHROME_URL` endpoint; `--listener local` selects a local listener instead. For example: `rech profile qa --print-uri --listener local`. The output contains a secret daemon key.
 
 Direct connections use the root path, such as `http://127.0.0.1:13775/?profile=qa#key=DAEMON_KEY`. A prefix is optional and only added when explicitly configured with `--prefix`, for example for a proxy mounted at `/rechrome/`. Tailscale can also serve at the root without a prefix.
 
@@ -207,7 +208,7 @@ cp .env.example .env.local
 
 | Variable                            | Description                                                                                                                         | Default          |
 | ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
-| `RECHROME_URL`                      | Connection URL, saved by `rech setup` / `rech connect` / `rech url --save`. Also accepts `?extension_id=`, `?token=`, `?profile=` query params | —                |
+| `RECHROME_URL`                      | Connection URL, saved by `rech setup` / `rech connect` / `rech share --save`. Also accepts `?extension_id=`, `?token=`, `?profile=` query params | —                |
 | `PLAYWRIGHT_CLI`                    | Override the playwright-cli command/path (defaults to the bundled `@playwright/cli`; set this only for a custom or forked CLI)       | bundled `@playwright/cli` |
 | `RECH_HOST`                         | Legacy bind address, used only before listeners.json is configured                                                                  | `127.0.0.1`      |
 | `PLAYWRIGHT_MCP_EXTENSION_ID`       | Chrome extension ID (client overrides server)                                                                                       | —                |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rechrome",
-  "version": "1.28.2",
+  "version": "1.29.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/rechrome.git"

package/rechrome.js

@@ -671,6 +671,40 @@ export function validateChromeProfileSelector(selector: string): void {
   );
 }
 
+export type ProfileCandidate = { id: string; label: string; fields: string[]; localPart?: string };
+
+/** Several profiles match; an interactive caller can offer them as a choice. */
+export class AmbiguousProfileError extends Error {
+  constructor(message: string, readonly candidates: ProfileCandidate[]) { super(message); }
+}
+
+/** share can't pick a listener on its own; an interactive caller can ask. */
+export class ShareListenerError extends Error {
+  constructor(message: string, readonly kind: "several" | "none", readonly listeners: Listener[]) { super(message); }
+}
+
+/**
+ * Looser profile matching, tried after the exact rules: the email's part before "@", then the
+ * start (3+ characters) of an email/name/folder. No substring matching: "h" must not pick a
+ * profile because its email happens to contain an h. Each stage counts only when it picks out
+ * exactly one profile; if a stage matches several, stop and name them rather than guess.
+ */
+export function matchProfileLoosely(value: string, candidates: ProfileCandidate[]): ProfileCandidate | null {
+  const needle = value.trim().toLowerCase();
+  if (!needle) return null;
+  const stages: Array<[string, (c: ProfileCandidate) => boolean]> = [
+    ["email name", c => c.localPart?.toLowerCase() === needle],
+    ["prefix", c => needle.length >= 3 && c.fields.some(f => f.toLowerCase().startsWith(needle))],
+  ];
+  for (const [, test] of stages) {
+    const hits = candidates.filter(test);
+    if (hits.length === 1) return hits[0];
+    if (hits.length > 1)
+      throw new AmbiguousProfileError(`Profile "${value}" matches several profiles: ${hits.map(c => c.label).join(", ")}. Use one of those, or see \`rech profile\`.`, hits);
+  }
+  return null;
+}
+
 export async function resolveGlobalProfile(
   registry: Record<string, TokenEntry>,
   chromeProfiles: Record<string, ChromeProfileInfo> | null,
@@ -690,18 +724,32 @@ export async function resolveGlobalProfile(
   }
 
   const profiles = Object.entries(chromeProfiles);
-  let match: [string, ChromeProfileInfo] | null;
-  try {
-    match = resolveChromeProfileSelector(profiles, value);
-  } catch (err) {
-    throw err;
-  }
+  let match = resolveChromeProfileSelector(profiles, value);
 
   if (!match) {
-    throw new Error(
-      `--profile "${value}" does not match any Chrome profile. ` +
-      `See available profiles with \`rech profile\`.`,
-    );
+    // No exact match: accept a looser one only when it is unique, and say which profile it chose.
+    const chromeIds = new Set(profiles.flatMap(([dir, info]) => [dir, info.user_name ?? ""]));
+    for (const [key, entry] of Object.entries(registry)) if (profiles.some(([dir]) => dir === entry.profileDir)) chromeIds.add(key);
+    const candidates: ProfileCandidate[] = [
+      ...profiles.map(([dir, info]) => ({
+        id: `chrome:${dir}`,
+        label: info.user_name ? `${info.user_name} (${info.name ?? dir})` : `${info.name ?? dir} [${dir}]`,
+        fields: [info.user_name ?? "", info.name ?? "", dir].filter(Boolean),
+        localPart: info.user_name?.split("@")[0],
+      })),
+      // Registered profiles Chrome doesn't list (managed test profiles).
+      ...Object.keys(registry).filter(k => !chromeIds.has(k)).map(k => ({ id: `registry:${k}`, label: k, fields: [k], localPart: k.includes("@") ? k.split("@")[0] : undefined })),
+    ];
+    const loose = matchProfileLoosely(value, candidates);
+    if (!loose) {
+      throw new Error(`Profile "${value}" does not match any Chrome profile. See available profiles with \`rech profile\`.`);
+    }
+    console.error(`[rech] profile "${value}" → ${loose.label}`);
+    if (loose.id.startsWith("registry:")) {
+      const key = loose.id.slice("registry:".length);
+      return { email: key, entry: registry[key] };
+    }
+    match = profiles.find(([dir]) => `chrome:${dir}` === loose.id)!;
   }
 
   const [dir, info] = match;
@@ -883,6 +931,12 @@ async function listProfiles(): Promise<void> {
 export function profileConnectionUri(profile: string, configuredUrl: string | undefined, listeners: Listener[], listenerName?: string): string {
   let url = configuredUrl;
   if (listenerName || !url) {
+    if (listenerName) {
+      const named = listeners.find(l => l.name === listenerName);
+      if (!named) throw new Error(`Unknown listener "${listenerName}". See rech listener ls.`);
+      if (named.profiles !== "*" && !named.profiles.includes(profile))
+        throw new Error(`Listener "${listenerName}" does not allow "${profile}". Allow it with: rech listener allow ${listenerName} ${JSON.stringify(profile)}`);
+    }
     const candidates = listeners.filter(l => (l.profiles === "*" || l.profiles.includes(profile)) && (!listenerName || l.name === listenerName));
     if (candidates.length !== 1) throw new Error("Choose a listener with --listener <name>, or set RECHROME_URL to the desired endpoint.");
     const listener = candidates[0];
@@ -898,16 +952,129 @@ export function profileConnectionUri(profile: string, configuredUrl: string | un
   return result.toString();
 }
 
+/** Prompts only when a person is at the terminal; scripts and agents get errors, never a hang. */
+export const isInteractive = () => !!process.stdin.isTTY && !!process.stderr.isTTY;
+
+/**
+ * Numbered choice on `output` (stderr, so stdout stays clean for piping). Enter takes the
+ * default; q or end of input cancels (null). Invalid answers ask again.
+ */
+export async function promptChoice<T>(
+  question: string, options: { label: string; value: T }[], defaultIndex = 0,
+  io: { input: NodeJS.ReadableStream; output: NodeJS.WritableStream } = { input: process.stdin, output: process.stderr },
+): Promise<T | null> {
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: io.input, output: io.output, terminal: false });
+  const lines = rl[Symbol.asyncIterator]();
+  try {
+    io.output.write(`${question}\n`);
+    options.forEach((o, i) => io.output.write(`  ${String(i + 1).padStart(2)}. ${o.label}${i === defaultIndex ? "  (default)" : ""}\n`));
+    while (true) {
+      io.output.write(`Choice [${defaultIndex + 1}, q to cancel]: `);
+      const next = await lines.next();
+      if (next.done) return null;
+      const answer = String(next.value).trim().toLowerCase();
+      if (answer === "q") return null;
+      if (answer === "") return options[defaultIndex]?.value ?? null;
+      const index = Number(answer) - 1;
+      if (Number.isInteger(index) && options[index]) return options[index].value;
+      io.output.write(`Enter a number from 1 to ${options.length}.\n`);
+    }
+  } finally { rl.close(); }
+}
+
+/** Registered profiles as choices, one per Chrome profile folder (the registry may alias one folder twice). */
+function registeredProfileChoices(registry: Record<string, TokenEntry>): { label: string; value: string }[] {
+  const byDir = new Map<string, string>();
+  for (const key of Object.keys(registry)) {
+    const dir = registry[key].profileDir;
+    const kept = byDir.get(dir);
+    if (!kept || (!kept.includes("@") && key.includes("@"))) byDir.set(dir, key);
+  }
+  return [...byDir.entries()].map(([dir, key]) => ({ label: key === dir ? key : `${key}  [${dir}]`, value: key }));
+}
+
+/**
+ * Which listener `rech share <profile>` uses when none is named: a scoped one that allows the
+ * profile, preferring one with a public URL. Never the management listener, whose key gives
+ * full access to every profile.
+ */
+export function chooseShareListener(profile: string, listeners: Listener[]): string {
+  const scoped = listeners.filter(l => l.profiles !== "*");
+  const allowing = scoped.filter(l => (l.profiles as string[]).includes(profile));
+  const pick = allowing.length === 1 ? allowing : allowing.filter(l => l.publicUrl);
+  if (pick.length === 1) return pick[0].name;
+  if (allowing.length > 1)
+    throw new ShareListenerError(`"${profile}" is shared on several listeners (${allowing.map(l => l.name).join(", ")}). Pick one with --listener <name>.`, "several", allowing);
+  throw new ShareListenerError([
+    `"${profile}" isn't shared on any listener yet.`,
+    scoped.length ? `  Allow it on one:  rech listener allow ${scoped[0].name} ${JSON.stringify(profile)}   (listeners: ${scoped.map(l => l.name).join(", ")})` : "",
+    `  Or create one:    rech listener add share --listen local --prefix=rechrome --port 13776 --profile ${JSON.stringify(profile)}`,
+  ].filter(Boolean).join("\n"), "none", scoped);
+}
+
 async function printProfileUri(selector?: string, listener?: string, opts: { local?: boolean; save?: boolean } = {}): Promise<void> {
   const url = process.env[ENV_KEY];
-  selector ??= url ? parseUrl(url).profileDirectory : undefined;
-  if (!selector) throw new Error("Specify a profile: rech url <profile>");
+  const interactive = isInteractive();
   const registry = await readTokenRegistry();
   const cache = await readChromeProfileCache();
+  const cancelled = () => new Error("Cancelled; nothing shared.");
+  const current = resolveEffectiveProfile(url ? parseUrl(url).profileDirectory : undefined);
+  const pickProfile = async (question: string, choices = registeredProfileChoices(registry)) => {
+    const def = Math.max(0, choices.findIndex(c => c.value === current || registry[c.value]?.profileDir === current));
+    return (await promptChoice(question, choices, def)) ?? (() => { throw cancelled(); })();
+  };
+  if (!selector) {
+    // No profile given: ask, defaulting to the current one (?profile= in the URL, else PLAYWRIGHT_MCP_PROFILE_DIRECTORY).
+    if (interactive && Object.keys(registry).length) selector = await pickProfile("Share which profile?");
+    else {
+      selector = current;
+      if (!selector) throw new Error("No current profile to share. Name one: rech share <profile>   (see rech profile; rech share ls lists what is shared)");
+      console.error(`[rech] sharing the current profile: ${selector}`);
+    }
+  }
   // A configured remote profile may not exist in this machine's local registry.
-  const profile = url && parseUrl(url).profileDirectory === selector && !listener
-    ? selector : (await resolveGlobalProfile(registry, cache, selector)).email;
-  const listeners = (await readListeners())?.listeners ?? [];
+  let profile: string;
+  if (url && parseUrl(url).profileDirectory === selector && !listener) profile = selector;
+  else {
+    try { profile = (await resolveGlobalProfile(registry, cache, selector)).email; }
+    catch (error) {
+      if (!interactive || !(error instanceof Error)) throw error;
+      if (error instanceof AmbiguousProfileError) {
+        const choice = await pickProfile(`"${selector}" matches several profiles. Which one?`,
+          error.candidates.map(c => ({ label: c.label, value: c.id.replace(/^(chrome|registry):/, "") })));
+        profile = (await resolveGlobalProfile(registry, cache, choice)).email;
+      } else if (/does not match/.test(error.message)) {
+        profile = (await resolveGlobalProfile(registry, cache, await pickProfile(`No profile matches "${selector}". Share which one?`))).email;
+      } else throw error;
+    }
+  }
+  const config = await readListeners();
+  const listeners = config?.listeners ?? [];
+  // On a host, share through a scoped listener by default, never the management key.
+  if (!listener && config) {
+    try { listener = chooseShareListener(profile, listeners); }
+    catch (error) {
+      if (!interactive || !(error instanceof ShareListenerError)) throw error;
+      const describe = (l: Listener) => `${l.name}  ${l.publicUrl ?? `${listenerAddress(l)}${normalizePrefix(l.prefix)}`}`;
+      if (error.kind === "several") {
+        listener = (await promptChoice(`"${profile}" is on several listeners. Share through which?`, error.listeners.map(l => ({ label: describe(l), value: l.name })))) ?? undefined;
+        if (!listener) throw cancelled();
+      } else {
+        if (!error.listeners.length) throw error; // nothing to allow it on: the error names `rech listener add`
+        // Allowing is a config change, so the default is to cancel.
+        const target = await promptChoice(`"${profile}" isn't shared on any listener yet. Allow it on:`,
+          [...error.listeners.map(l => ({ label: describe(l), value: l.name as string | null })), { label: "Cancel (change nothing)", value: null }], error.listeners.length);
+        if (!target) throw cancelled();
+        allowProfiles(config, target, [profile]);
+        await writeListeners(config);
+        console.error(`[rech] allowed "${profile}" on ${target}`);
+        listener = target;
+      }
+    }
+  }
+  if (listeners.find(l => l.name === listener)?.profiles === "*")
+    console.error(`[rech] "${listener}" is the local management listener: its key controls every profile. Don't share this URL.`);
   let uri = profileConnectionUri(profile, url, listeners, listener);
   // Prefer where a proxy exposes the listener, when it has been recorded.
   const publicUrl = listeners.find(l => l.key === parseUrl(uri).key)?.publicUrl;
@@ -1091,7 +1258,7 @@ export function notConnectedMessage(): string {
   return [
     `rech: not connected to a rechrome daemon (${ENV_KEY} is not set).`,
     `  On the machine with Chrome:   rech setup`,
-    `  On another machine:           rech connect '<URL printed by \`rech url\` on that machine>'`,
+    `  On another machine:           rech connect '<URL printed by \`rech share\` on that machine>'`,
   ].join("\n");
 }
 
@@ -1109,7 +1276,7 @@ export function unknownCommandHint(output: string, rechCommands: Iterable<string
   const best = scored[0] && scored[0].d <= Math.max(1, Math.floor(unknown.length / 3)) ? scored[0].c : null;
   return [
     `rech: unknown command "${unknown}".${best ? ` Did you mean "${best}"?` : ""}`,
-    `  rech --help       rechrome commands (setup, status, profile, url, connect, listener…)`,
+    `  rech --help       rechrome commands (setup, status, profile, share, connect, listener…)`,
     `  rech pw --help    browser commands (open, click, screenshot…)`,
   ].join("\n");
 }
@@ -2026,7 +2193,7 @@ export function listenerNextSteps(listener: Listener, profile?: string): string[
     `  tailscale serve --bg${mount ? ` --set-path=${mount}` : ""} ${listener.port}`,
     `Then record where it is reachable and print the URL to share:`,
     `  rech listener set ${listener.name} --public-url https://<your-host>${prefix}`,
-    `  rech url ${profile ? JSON.stringify(profile) : "<profile>"} --listener ${listener.name}`,
+    `  rech share ${profile ? JSON.stringify(profile) : "<profile>"}`,
   ];
 }
 
@@ -2078,7 +2245,7 @@ async function rotateKey(name: string): Promise<void> {
   const config = await requireListeners();
   rotateListenerKey(config, name);
   await writeListeners(config);
-  console.log(`New key for ${name}; URLs carrying the old key stop working now. Print new ones with: rech url <profile> --listener ${name}`);
+  console.log(`New key for ${name}; URLs carrying the old key stop working now. Print new ones with: rech share <profile> --listener ${name}`);
 }
 
 async function setListener(name: string, opts: { publicUrl?: string; clearPublicUrl?: boolean }): Promise<void> {
@@ -2098,7 +2265,7 @@ async function urlList(): Promise<void> {
     for (const profile of l.profiles === "*" ? ["(all profiles)"] : l.profiles) rows.push([l.name, profile, local, l.publicUrl ?? "-"]);
   }
   printTable(rows);
-  console.log(`\nPrint a full URL (contains the secret key): rech url <profile> --listener <name>`);
+  console.log(`\nPrint a full URL (contains the secret key): rech share <profile>`);
 }
 
 /** Write RECHROME_URL to this project's .rechrome/.env.local (the folder git-ignores itself). */
@@ -2116,7 +2283,7 @@ async function saveProjectUrl(url: string): Promise<string> {
 
 async function connect(url: string): Promise<void> {
   const parsed = parseUrl(url);
-  if (!parsed.key) throw new Error("That URL has no key (#key=…). Ask the host for the full URL from: rech url <profile>");
+  if (!parsed.key) throw new Error("That URL has no key (#key=…). Ask the host for the full URL from: rech share <profile>");
   const response = await fetch(serviceUrl(url, "ping"), { headers: { Authorization: `Bearer ${parsed.key}` }, signal: AbortSignal.timeout(5000) })
     .catch(error => { throw new Error(`Could not reach ${serviceUrl(url)}: ${error instanceof Error ? error.message : error}`); });
   if (response.status === 401) throw new Error("The daemon rejected this key; ask the host for a fresh URL (keys change on rech listener rotate-key).");
@@ -2546,7 +2713,7 @@ async function status(): Promise<void> {
   const details = [pingBody?.listener && `listener ${pingBody.listener}`, pingBody?.bind && `bind ${pingBody.bind}`].filter(Boolean).join(", ");
   console.log(`serve:    ${ping ? `running  ${serviceUrl(url)}${details ? `  (${details})` : ""}` : `not reachable at ${serviceUrl(url)}`}`);
   if (pingResponse?.status === 401)
-    console.log(`auth:     ✗ key rejected — ask the host for a fresh URL (\`rech url <profile>\`), then \`rech connect '<url>'\``);
+    console.log(`auth:     ✗ key rejected — ask the host for a fresh URL (\`rech share <profile>\`), then \`rech connect '<url>'\``);
   // daemonManager().id — there is no PM_BIN constant. Referencing one threw a
   // ReferenceError that took down the whole of `rech status`, so the one command
   // that reports "the relay is wedged" died exactly when the relay was wedged,
@@ -2567,7 +2734,7 @@ async function status(): Promise<void> {
   const current = effective ? await resolveProfileEmail(effective).catch(() => effective) : undefined;
   const allowed = pingBody?.profiles === "*" ? "all registered profiles" : pingBody?.profiles?.join(", ");
   console.log(`profile:  ${current ?? "(none selected; add ?profile= to the URL or pass --profile)"}${allowed ? `  — this listener serves: ${allowed}` : ""}`);
-  if (isHost) console.log(`\nMore: rech profile (profiles) · rech url ls (who can connect, and where)`);
+  if (isHost) console.log(`\nMore: rech profile (profiles) · rech share ls (who can connect, and where)`);
 }
 
 
@@ -2594,7 +2761,7 @@ export type RechHandlers = {
 };
 
 /** Commands rech handles itself; anything else is forwarded verbatim to playwright-cli. */
-export const RECH_COMMANDS = new Set(["serve", "status", "listener", "listeners", "profile", "profiles", "url", "urls", "connect", "setup", "tray", "provision-profile", "uninstall"]);
+export const RECH_COMMANDS = new Set(["serve", "status", "listener", "listeners", "profile", "profiles", "share", "connect", "setup", "tray", "provision-profile", "uninstall"]);
 
 const portOption = { type: "number", requiresArg: true, describe: "Listener port (1-65535)" } as const;
 
@@ -2621,7 +2788,7 @@ Examples:
   rech setup --profile you@example.com         set up Chrome on this machine
   rech open https://example.com                open a page in this project's session
   rech screenshot                              saved to <project>/.rechrome/output/
-  rech url you@example.com --listener share    URL to give another machine (secret)
+  rech share you@example.com                   URL to give another machine (secret)
   rech connect '<url>'                         use that URL in this project
 
 Run \`rech <command> --help\` for a command's options. Tutorial: https://github.com/snomiao/rechrome#tutorial`;
@@ -2645,24 +2812,24 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
     .command("status", "Is it working? The URL in use, the daemon, and the current profile", {}, () => handlers.status())
     .command(["profile [name]", "profiles [name]"], "List Chrome profiles and whether each is connected", y => y
       .positional("name", { type: "string", describe: "ls/list lists all (the default)" })
-      .option("print-uri", { type: "boolean", describe: "Same as `rech url <name>`" })
+      .option("print-uri", { type: "boolean", describe: "Same as `rech share <name>`" })
       .option("listener", { type: "string", requiresArg: true, implies: "print-uri", describe: "Listener to build the URL for" }),
       a => {
-        if (a.printUri) return handlers.printProfileUri(a.name, a.listener); // alias of `rech url`
+        if (a.printUri) return handlers.printProfileUri(a.name, a.listener); // alias of `rech share`
         if (a.name === undefined || ["ls", "list"].includes(a.name)) return handlers.listProfiles();
-        throw new Error(`To print "${a.name}"'s connection URL: rech url ${JSON.stringify(a.name)}. To list profiles: rech profile`);
+        throw new Error(`To share "${a.name}" with another machine: rech share ${JSON.stringify(a.name)}. To list profiles: rech profile`);
       })
     // Share with and connect from other machines
-    .command(["url [profile]", "urls [profile]"], "Print a connection URL to share (contains a secret key); `url ls` lists all", y => y
-      .positional("profile", { type: "string", describe: "Profile (email, name or folder); ls/list lists every listener's URLs" })
-      .option("listener", { type: "string", requiresArg: true, describe: "Listener to build the URL for" })
+    .command("share [profile]", "Print a URL another machine can connect with (secret); `share ls` lists all", y => y
+      .positional("profile", { type: "string", describe: "Profile: email, name, folder, or a unique part of one; ls/list lists everything shared" })
+      .option("listener", { type: "string", requiresArg: true, describe: "Listener to share through (default: the one that allows the profile)" })
       .option("local", { type: "boolean", describe: "Print the direct listener address even when a public URL is set" })
       .option("save", { type: "boolean", describe: "Also save it as RECHROME_URL in this project's .rechrome/.env.local" }),
       a => ["ls", "list"].includes(a.profile ?? "") && !a.listener && !a.save
         ? handlers.urlList()
         : handlers.printProfileUri(a.profile, a.listener, { local: a.local, save: a.save }))
     .command("connect <url>", "Use a URL from another machine in this project (checks it first)", y => y
-      .positional("url", { type: "string", demandOption: true, describe: "The URL printed by `rech url <profile>` on the machine with Chrome. Quote it: it contains #" })
+      .positional("url", { type: "string", demandOption: true, describe: "The URL printed by `rech share <profile>` on the machine with Chrome. Quote it: it contains #" })
       .example("rech connect 'https://host.example.js.net/rechrome/?profile=you%40example.com#key=…'", ""),
       a => handlers.connect(a.url))
     .command(["listener", "listeners"], "Control who can connect: listeners, allowed profiles, keys, public URLs", y => y