rechrome 1.29.1 → 1.31.0

package/README.md

@@ -106,6 +106,23 @@ rech open https://example.com
 `.rechrome/.env.local`. Remote listeners allow navigation, tabs, snapshots, screenshots and basic
 interactions, but not `eval`/`run-code` or filesystem commands (see [Remote access](#remote-access)).
 
+**Share several profiles in one link.** `rech share work@example.com taku2 symval-dev` puts
+exactly those profiles on one listener (its own key; running it again reuses it). Add
+`--listener <name>` to use a listener that already has a proxy route. Its links then reach
+exactly this list, and `rech listener rotate-key <name>` issues a fresh key if old links shouldn't.
+
+**Share every profile at once.** `rech share --all` gives one link for all Chrome profiles
+registered on the host. It uses its own listener (`share-all`) and key, so one-profile links you
+already handed out never gain access to the others. It is a snapshot: after registering another
+profile, run `rech share --all` again. On the other machine, pick a profile per command, and the
+host resolves the name (exact, the part of an email before `@`, or a unique 3+ letter prefix):
+
+```bash
+rech connect '<url from rech share --all>'
+rech profile                                   # the profiles that link shares
+rech --profile work@example.com open https://example.com
+```
+
 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 share`.
 
@@ -118,9 +135,19 @@ 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
 rech listener remove share
+rech profile rm old-test-profile              # unregister a profile everywhere (asks first)
 ```
 
+`rech profile rm <name>` shows its plan and asks before changing anything (`--yes` skips the
+question). It removes every alias of the profile from rech's registry and from every listener,
+dropping a listener left with no profiles. A managed test profile's own folder goes to the Trash,
+and its running window is closed only with your consent (`--close` when not in a terminal). A real
+Chrome profile's data is never touched: it is only unregistered from rech.
+
 Changes apply immediately; the daemon reloads its listeners without restarting Chrome.
+A link's key opens **every** profile its listener allows (`?profile=` only picks the default),
+so give a profile its own listener when a link should reach only that one. `rech share ls`
+points out keys that cover several profiles. The local management listener is never shared.
 
 ## Setup reference
 

package/listeners.js

@@ -141,18 +141,68 @@ function setPublicUrl(config, name, publicUrl) {
     listener.publicUrl = normalizePublicUrl(publicUrl);
   return listener;
 }
+var profileIdentity = (e) => `${e.userDataDir ?? ""}\x00${e.profileDir}`;
+function canonicalProfileKeys(registry) {
+  const byProfile = new Map;
+  for (const key of Object.keys(registry).sort()) {
+    const id = profileIdentity(registry[key]);
+    const kept = byProfile.get(id);
+    if (!kept || !kept.includes("@") && key.includes("@"))
+      byProfile.set(id, key);
+  }
+  return [...byProfile.values()];
+}
+function resolveAllowedProfile(selector, allowed, registry, chromeNames = {}) {
+  const list = allowed.join(", ");
+  if (!selector?.trim())
+    throw new Error(`Pick a profile: this link shares ${list}. For example: rech --profile ${JSON.stringify(allowed[0] ?? "<name>")} open https://example.com`);
+  const needle = selector.trim().toLowerCase();
+  const candidates = allowed.filter((k) => registry[k]).map((key) => {
+    const entry = registry[key];
+    const aliases = Object.keys(registry).filter((k) => profileIdentity(registry[k]) === profileIdentity(entry));
+    const name = entry.userDataDir ? undefined : chromeNames[entry.profileDir];
+    const fields = [...new Set([...aliases, entry.profileDir, ...name ? [name] : []])].map((f) => f.toLowerCase());
+    return { key, fields, localParts: fields.filter((f) => f.includes("@")).map((f) => f.split("@")[0]) };
+  });
+  const stages = [
+    (c) => c.fields.includes(needle),
+    (c) => c.localParts.includes(needle),
+    (c) => needle.length >= 3 && c.fields.some((f) => f.startsWith(needle))
+  ];
+  for (const test of stages) {
+    const hits = candidates.filter(test);
+    if (hits.length === 1)
+      return hits[0].key;
+    if (hits.length > 1)
+      throw new Error(`"${selector}" matches several shared profiles (${hits.map((h) => h.key).join(", ")}); be more specific.`);
+  }
+  throw new Error(`"${selector}" is not shared by this link. It shares: ${list}.`);
+}
+function planProfileRemoval(key, registry, listeners, managedRoot) {
+  const entry = registry[key];
+  if (!entry)
+    throw new Error(`"${key}" is not a registered profile.`);
+  const keys = Object.keys(registry).filter((k) => profileIdentity(registry[k]) === profileIdentity(entry));
+  const edits = listeners.filter((l) => l.profiles !== "*" && l.profiles.some((p) => keys.includes(p))).map((l) => ({ name: l.name, remove: l.profiles.filter((p) => keys.includes(p)), drop: l.profiles.every((p) => keys.includes(p)) }));
+  const root = managedRoot.replace(/[\\/]+$/, "");
+  const managed = !!entry.loadExtension && !!entry.userDataDir && (entry.userDataDir.startsWith(root + "/") || entry.userDataDir.startsWith(root + "\\"));
+  return { keys, listeners: edits, ...managed ? { dataDir: entry.userDataDir } : {} };
+}
 export {
   LISTENERS_FILE,
   allowProfiles,
   authorizeProfileRequest,
   canReadProfileFile,
+  canonicalProfileKeys,
   denyProfiles,
   isLoopback,
   listenerAddress,
   normalizePrefix,
   normalizePublicUrl,
+  planProfileRemoval,
   profileOutputPrefix,
   readListeners,
+  resolveAllowedProfile,
   rotateListenerKey,
   serviceUrl,
   setPublicUrl,

package/listeners.ts

@@ -135,3 +135,79 @@ export function setPublicUrl(config: ListenerConfig, name: string, publicUrl: st
   else listener.publicUrl = normalizePublicUrl(publicUrl);
   return listener;
 }
+
+/** What the resolver needs from a registry entry: which Chrome profile it points at. */
+export type RegisteredProfile = { profileDir: string; userDataDir?: string };
+const profileIdentity = (e: RegisteredProfile) => `${e.userDataDir ?? ""}\0${e.profileDir}`;
+
+/**
+ * One registry key per Chrome profile (a profile can be registered under several aliases,
+ * e.g. "Profile 5" and "taku2"): prefer an email, else the alphabetically first key.
+ */
+export function canonicalProfileKeys(registry: Record<string, RegisteredProfile>): string[] {
+  const byProfile = new Map<string, string>();
+  for (const key of Object.keys(registry).sort()) {
+    const id = profileIdentity(registry[key]);
+    const kept = byProfile.get(id);
+    if (!kept || (!kept.includes("@") && key.includes("@"))) byProfile.set(id, key);
+  }
+  return [...byProfile.values()];
+}
+
+/**
+ * Resolve what a remote client typed (`rech --profile work`) to one allowed registry key, on
+ * the host, so the client needs no registry of its own. Aliases of an allowed profile map to
+ * it, so they share one session. Matching: exact key, alias, folder or Chrome name
+ * (case-insensitive), then the email part before "@", then a unique 3+ character prefix.
+ * Ambiguity and misses list the allowed profiles; nothing outside the allowlist can match.
+ */
+export function resolveAllowedProfile(
+  selector: string | undefined, allowed: string[], registry: Record<string, RegisteredProfile>,
+  chromeNames: Record<string, string> = {},
+): string {
+  const list = allowed.join(", ");
+  if (!selector?.trim()) throw new Error(`Pick a profile: this link shares ${list}. For example: rech --profile ${JSON.stringify(allowed[0] ?? "<name>")} open https://example.com`);
+  const needle = selector.trim().toLowerCase();
+  const candidates = allowed.filter(k => registry[k]).map(key => {
+    const entry = registry[key];
+    const aliases = Object.keys(registry).filter(k => profileIdentity(registry[k]) === profileIdentity(entry));
+    const name = entry.userDataDir ? undefined : chromeNames[entry.profileDir];
+    const fields = [...new Set([...aliases, entry.profileDir, ...(name ? [name] : [])])].map(f => f.toLowerCase());
+    return { key, fields, localParts: fields.filter(f => f.includes("@")).map(f => f.split("@")[0]) };
+  });
+  const stages: Array<(c: typeof candidates[number]) => boolean> = [
+    c => c.fields.includes(needle),
+    c => c.localParts.includes(needle),
+    c => needle.length >= 3 && c.fields.some(f => f.startsWith(needle)),
+  ];
+  for (const test of stages) {
+    const hits = candidates.filter(test);
+    if (hits.length === 1) return hits[0].key;
+    if (hits.length > 1) throw new Error(`"${selector}" matches several shared profiles (${hits.map(h => h.key).join(", ")}); be more specific.`);
+  }
+  throw new Error(`"${selector}" is not shared by this link. It shares: ${list}.`);
+}
+
+export type ProfileRemovalPlan = {
+  keys: string[];                                              // every registry alias of the profile
+  listeners: { name: string; remove: string[]; drop: boolean }[];  // allowlist edits; drop = no profiles left
+  dataDir?: string;                                            // a managed profile's own folder (never real Chrome data)
+};
+
+/**
+ * What `rech profile rm` would change for one registry key: all aliases of that Chrome profile,
+ * their listener entries (dropping a listener left empty), and, for a managed test profile
+ * whose data lives under `managedRoot`, its folder. Real Chrome profiles only get unregistered.
+ */
+export function planProfileRemoval(
+  key: string, registry: Record<string, RegisteredProfile & { loadExtension?: string }>, listeners: Listener[], managedRoot: string,
+): ProfileRemovalPlan {
+  const entry = registry[key];
+  if (!entry) throw new Error(`"${key}" is not a registered profile.`);
+  const keys = Object.keys(registry).filter(k => profileIdentity(registry[k]) === profileIdentity(entry));
+  const edits = listeners.filter(l => l.profiles !== "*" && l.profiles.some(p => keys.includes(p)))
+    .map(l => ({ name: l.name, remove: (l.profiles as string[]).filter(p => keys.includes(p)), drop: (l.profiles as string[]).every(p => keys.includes(p)) }));
+  const root = managedRoot.replace(/[\\/]+$/, "");
+  const managed = !!entry.loadExtension && !!entry.userDataDir && (entry.userDataDir.startsWith(root + "/") || entry.userDataDir.startsWith(root + "\\"));
+  return { keys, listeners: edits, ...(managed ? { dataDir: entry.userDataDir } : {}) };
+}

package/package.json

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

package/rechrome.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
-import { readListeners, writeListeners, listenerAddress, isLoopback, normalizePrefix, serviceUrl, allowProfiles, denyProfiles, rotateListenerKey, setPublicUrl, type Listener } from "./listeners.js";
+import { readListeners, writeListeners, listenerAddress, isLoopback, normalizePrefix, serviceUrl, allowProfiles, denyProfiles, rotateListenerKey, setPublicUrl, canonicalProfileKeys, planProfileRemoval, type Listener } from "./listeners.js";
 
 import { file } from "bun";
 import yargs from "yargs";
 import { readExtensionTokenFromProfile } from "./extension-token.js";
-import { randomBytes } from "crypto";
+import { createHash, randomBytes } from "crypto";
 import { mkdirSync, appendFileSync, existsSync, realpathSync, accessSync, cpSync, unlinkSync, readFileSync, readdirSync, renameSync, rmdirSync, constants as fsConstants } from "fs";
 import { hostname, homedir, networkInterfaces } from "os";
 import { isIPv4 } from "net";
@@ -624,7 +624,7 @@ const CHROME_LOCAL_STATE_PATHS = () => {
 
 type ChromeProfileInfo = { user_name?: string; name?: string };
 
-async function readChromeProfileCache(): Promise<Record<string, ChromeProfileInfo> | null> {
+export async function readChromeProfileCache(): Promise<Record<string, ChromeProfileInfo> | null> {
   for (const statePath of CHROME_LOCAL_STATE_PATHS()) {
     const f = file(statePath);
     if (!(await f.exists())) continue;
@@ -893,6 +893,91 @@ export function buildProfileRows(cache: Record<string, ChromeProfileInfo> | null
   return rows;
 }
 
+/** PIDs of browser processes (not helpers) running on a Chrome user-data dir. POSIX only. */
+function browsersUsing(userDataDir: string): number[] {
+  if (process.platform === "win32") return [];
+  const ps = Bun.spawnSync(["ps", "ax", "-o", "pid=,command="]).stdout.toString();
+  return ps.split("\n").filter(line => line.includes(`--user-data-dir=${userDataDir}`) && !line.includes("--type="))
+    .map(line => Number(line.trim().split(/\s+/)[0])).filter(Boolean);
+}
+
+/** Move a folder to the user's Trash (recoverable). Returns where it went, or null if unsupported here. */
+function moveToTrash(dir: string): string | null {
+  const trash = process.platform === "darwin" ? join(HOME, ".Trash") : process.platform === "linux" ? join(HOME, ".local", "share", "Trash", "files") : null;
+  if (!trash) return null;
+  mkdirSync(trash, { recursive: true });
+  let dest = join(trash, basename(dir));
+  if (existsSync(dest)) dest = `${dest} ${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  renameSync(dir, dest);
+  return dest;
+}
+
+/**
+ * `rech profile rm <name>`: unregister a profile everywhere (all its aliases, every listener
+ * allowlist, dropping listeners left empty) and move a managed test profile's own folder to the
+ * Trash. Real Chrome profile data is never touched. Shows the plan and asks first (--yes skips);
+ * a browser still running on a managed folder is closed only with consent (--close).
+ */
+async function removeProfile(selector: string, opts: { yes?: boolean; close?: boolean } = {}): Promise<void> {
+  const registry = await readTokenRegistry(), cache = await readChromeProfileCache();
+  const key = (await resolveGlobalProfile(registry, cache, selector)).email;
+  const config = await readListeners();
+  const plan = planProfileRemoval(key, registry, config?.listeners ?? [], join(RECH_DIR, "profiles"));
+  const running = plan.dataDir ? browsersUsing(plan.dataDir) : [];
+  console.log(`Remove profile "${key}"${plan.keys.length > 1 ? ` (registered as ${plan.keys.join(", ")})` : ""}:`);
+  for (const edit of plan.listeners) console.log(edit.drop ? `  - remove listener "${edit.name}" (it serves only this profile)` : `  - stop sharing it on listener "${edit.name}"`);
+  console.log(`  - unregister it from rech (~/.rechrome/profiles.yaml)`);
+  if (plan.dataDir) console.log(`  - move its data folder to the Trash: ${plan.dataDir}`);
+  else console.log(`  - its Chrome data is left alone (this only unregisters it from rech)`);
+  if (running.length) console.log(`  - close its browser window, which is running now (pid ${running.join(", ")})`);
+  const interactive = isInteractive();
+  if (!opts.yes) {
+    if (!interactive) throw new Error("Not removed. Re-run with --yes to confirm" + (running.length ? " and --close to close its running window." : "."));
+    const ok = await promptChoice("Go ahead?", [{ label: "No, keep it", value: false }, { label: "Yes, remove it", value: true }], 0);
+    if (!ok) throw new Error("Cancelled; nothing changed.");
+  }
+  if (running.length) {
+    // In a terminal, confirming the plan above (which lists closing it) is the consent; otherwise --close.
+    if (!interactive && !opts.close) throw new Error("Its window is running; re-run with --close to close it, or close it yourself first.");
+    for (const pid of running) process.kill(pid, "SIGTERM");
+    for (let i = 0; i < 40 && browsersUsing(plan.dataDir!).length; i++) await Bun.sleep(250);
+    if (browsersUsing(plan.dataDir!).length) throw new Error("Its window did not close; close it and run this again. Nothing else changed.");
+  }
+  if (config && plan.listeners.length) {
+    for (const edit of plan.listeners) {
+      if (edit.drop) config.listeners = config.listeners.filter(l => l.name !== edit.name);
+      else { const l = config.listeners.find(x => x.name === edit.name)!; l.profiles = (l.profiles as string[]).filter(p => !plan.keys.includes(p)); }
+    }
+    await writeListeners(config);
+  }
+  for (const k of plan.keys) delete registry[k];
+  await writeTokenRegistry(registry);
+  // The migrated profiles.json backup still holds tokens: drop the same keys there.
+  const legacy = join(RECH_DIR, "profiles.json");
+  if (existsSync(legacy)) {
+    try {
+      const old = JSON.parse(readFileSync(legacy, "utf8"));
+      if (plan.keys.some(k => k in old)) { for (const k of plan.keys) delete old[k]; await writeFile(legacy, JSON.stringify(old, null, 2) + "\n", { mode: 0o600 }); await chmod(legacy, 0o600); }
+    } catch { /* unreadable backup: leave it */ }
+  }
+  let moved: string | null = null;
+  if (plan.dataDir && existsSync(plan.dataDir)) moved = moveToTrash(plan.dataDir);
+  console.log(`Removed "${key}".${moved ? ` Its data folder is in the Trash: ${moved}` : plan.dataDir ? ` Its data folder was left at ${plan.dataDir}; delete it yourself if you like.` : ""}`);
+}
+
+/** On a client of a remote host, `rech profile` lists what that host's link shares. */
+async function listRemoteProfiles(url: string): Promise<void> {
+  const response = await fetch(serviceUrl(url, "ping"), { headers: { Authorization: `Bearer ${parseUrl(url).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 host rejected this link's key; ask for a fresh one (rech share on the host), then rech connect '<url>'.");
+  const body = await response.json().catch(() => ({})) as { listener?: string; profiles?: string[] | "*" };
+  const current = resolveEffectiveProfile(parseUrl(url).profileDirectory);
+  console.log(`Profiles shared by ${serviceUrl(url)}${body.listener ? ` (listener ${body.listener})` : ""}:`);
+  if (body.profiles === "*") console.log("  every profile registered on that host");
+  else for (const p of body.profiles ?? []) console.log(`  ${p}${p === current ? "   ← current" : ""}`);
+  console.log(`\nUse one: rech --profile <name> open https://example.com`);
+}
+
 async function listProfiles(): Promise<void> {
   const [cache, registry, root] = await Promise.all([readChromeProfileCache(), readTokenRegistry(), findChromeUserDataDir()]);
   const profiles = buildProfileRows(cache, registry, root);
@@ -983,15 +1068,12 @@ export async function promptChoice<T>(
   } finally { rl.close(); }
 }
 
-/** Registered profiles as choices, one per Chrome profile folder (the registry may alias one folder twice). */
+/** Registered profiles as choices, one per Chrome profile (data dir + folder; aliases collapse). */
 function registeredProfileChoices(registry: Record<string, TokenEntry>): { label: string; value: string }[] {
-  const byDir = new Map<string, string>();
-  for (const key of Object.keys(registry)) {
+  return canonicalProfileKeys(registry).map(key => {
     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 }));
+    return { label: key === dir ? key : `${key}  [${dir}]`, value: key };
+  });
 }
 
 /**
@@ -1013,7 +1095,95 @@ export function chooseShareListener(profile: string, listeners: Listener[]): str
   ].filter(Boolean).join("\n"), "none", scoped);
 }
 
-async function printProfileUri(selector?: string, listener?: string, opts: { local?: boolean; save?: boolean } = {}): Promise<void> {
+/** A loopback port no listener uses and nothing else is bound to, from the management port + 2. */
+function freeListenerPort(listeners: Listener[]): number {
+  const used = new Set(listeners.map(l => l.port));
+  for (let port = DEFAULT_PORT + 2; port < 65536; port++) {
+    if (used.has(port)) continue;
+    try { Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response() }).stop(true); return port; } catch { /* taken */ }
+  }
+  throw new Error("No free port for the share-all listener; pass one with rech listener add");
+}
+
+/**
+ * `rech share --all`: one link for every Chrome profile registered now (a snapshot; run it
+ * again after registering more). It uses its own listener and key, so single-profile links
+ * already handed out never gain access to the other profiles.
+ */
+async function shareAll(opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void> {
+  const snapshot = canonicalProfileKeys(await readTokenRegistry());
+  if (!snapshot.length) throw new Error("No registered profiles to share. Set one up first: rech setup");
+  return shareSet(snapshot, { ...opts, defaultName: "share-all", prefix: "/rechrome-all/", again: "rech share --all" });
+}
+
+/** The registry key rech uses for a profile: one per Chrome profile, whatever alias it was named by. */
+function canonicalKeyFor(registry: Record<string, TokenEntry>, key: string): string {
+  const entry = registry[key];
+  return canonicalProfileKeys(registry).find(k => registry[k].profileDir === entry?.profileDir && (registry[k].userDataDir ?? "") === (entry?.userDataDir ?? "")) ?? key;
+}
+
+/**
+ * `rech share a b c`: one link for exactly these profiles, on one listener. With --listener it
+ * sets that listener's profiles to the list (e.g. one that already has a proxy route); otherwise
+ * it reuses a listener with exactly this set, or creates one with its own key.
+ */
+async function shareProfiles(selectors: string[], opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void> {
+  const registry = await readTokenRegistry(), cache = await readChromeProfileCache();
+  const keys: string[] = [];
+  for (const selector of selectors) {
+    const key = canonicalKeyFor(registry, (await resolveGlobalProfile(registry, cache, selector)).email);
+    if (!keys.includes(key)) keys.push(key);
+  }
+  if (keys.length === 1) return printProfileUri(keys[0], opts.listener, opts);
+  const config = await requireListeners();
+  const same = config.listeners.find(l => l.profiles !== "*" && l.profiles.length === keys.length && keys.every(k => (l.profiles as string[]).includes(k)));
+  const id = createHash("sha256").update([...keys].sort().join("\0")).digest("hex").slice(0, 6);
+  return shareSet(keys, { ...opts, listener: opts.listener ?? same?.name, defaultName: `share-${id}`, prefix: `/rechrome-${id}/`, again: `rech share ${selectors.map(s => JSON.stringify(s)).join(" ")}` });
+}
+
+/** Put exactly `snapshot` on one scoped listener (created if missing) and print its link. */
+async function shareSet(snapshot: string[], opts: { listener?: string; local?: boolean; save?: boolean; defaultName: string; prefix: string; again: string }): Promise<void> {
+  const config = await requireListeners();
+  const name = opts.listener ?? opts.defaultName;
+  let listener = config.listeners.find(l => l.name === name);
+  if (listener?.profiles === "*")
+    throw new Error(`"${name}" is the local management listener; it is never shared. Omit --listener, or name a scoped one.`);
+  let changes = "";
+  if (!listener) {
+    if (opts.listener) throw new Error(`Unknown listener "${name}". See rech listener ls.`);
+    listener = { name, host: "127.0.0.1", port: freeListenerPort(config.listeners), prefix: opts.prefix, key: randomBytes(24).toString("base64url"), profiles: snapshot };
+    config.listeners.push(listener);
+    changes = `created listener "${name}" on ${listenerAddress(listener)}${listener.prefix}`;
+  } else {
+    const before = listener.profiles as string[];
+    const added = snapshot.filter(p => !before.includes(p)), removed = before.filter(p => !snapshot.includes(p));
+    listener.profiles = snapshot;
+    changes = added.length || removed.length ? [added.length && `added ${added.join(", ")}`, removed.length && `removed ${removed.join(", ")}`].filter(Boolean).join("; ") : "no changes";
+  }
+  await writeListeners(config);
+  console.error(`[rech] sharing ${snapshot.length} profiles through "${name}" (${changes}): ${snapshot.join(", ")}`);
+  if (opts.defaultName === "share-all") console.error(`[rech] this is a snapshot: after registering another profile, run ${opts.again} again.`);
+  else if (changes !== "no changes" && !changes.startsWith("created")) console.error(`[rech] links already given out for "${name}" now reach exactly these profiles too (same key). For a fresh key: rech listener rotate-key ${name}`);
+  // The daemon reloads listeners.json about every second: confirm this listener answers before handing out its URL.
+  const local = `http://${listener.key}@${listenerAddress(listener)}${normalizePrefix(listener.prefix)}`;
+  let ready = false;
+  for (let i = 0; i < 20 && !ready; i++) {
+    ready = await fetch(serviceUrl(local, "ping"), { headers: { Authorization: `Bearer ${listener.key}` }, signal: AbortSignal.timeout(1000) }).then(r => r.ok).catch(() => false);
+    if (!ready) await Bun.sleep(250);
+  }
+  if (!ready) console.error(`[rech] warning: listener "${name}" is not answering yet; check the daemon with rech status.`);
+  const uri = listener.publicUrl && !opts.local ? rebaseConnectionUrl(listener.publicUrl, local) : registeredProfileUrl(local);
+  if (!listener.publicUrl) for (const line of listenerNextSteps(listener, undefined, opts.again)) console.error(line);
+  console.log(uri);
+  console.error(`[rech] on the other machine: rech connect '<url>', then rech --profile <name> open https://example.com`);
+  if (opts.save) console.error(`Saved RECHROME_URL to ${await saveProjectUrl(uri)}`);
+}
+
+async function printProfileUri(selector?: string, listener?: string, opts: { local?: boolean; save?: boolean; all?: boolean } = {}): Promise<void> {
+  if (opts.all) {
+    if (selector) throw new Error("Pass a profile or --all, not both.");
+    return shareAll({ listener, local: opts.local, save: opts.save });
+  }
   const url = process.env[ENV_KEY];
   const interactive = isInteractive();
   const registry = await readTokenRegistry();
@@ -1073,8 +1243,11 @@ async function printProfileUri(selector?: string, listener?: string, opts: { loc
       }
     }
   }
-  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.`);
+  const chosen = listeners.find(l => l.name === listener);
+  if (chosen?.profiles === "*")
+    throw new Error(`"${listener}" is the local management listener: its key controls every profile and allows eval and file access, so it is never shared. Share through a scoped listener: rech share <profile>, or rech share --all.`);
+  if (chosen && chosen.profiles.length > 1)
+    console.error(`[rech] note: this link's key works for every profile on listener "${chosen.name}" (${chosen.profiles.join(", ")}); ?profile= only picks the default. For a one-profile link, give that profile its own listener.`);
   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;
@@ -1090,6 +1263,29 @@ export function sandboxConnectionWarning(env: Record<string, string | undefined>
     "If it still fails, check that the daemon is running and the host/port are correct.";
 }
 
+/**
+ * Is RECHROME_URL this machine's own daemon? True when its key is one of our listeners (or,
+ * before listeners.json existed, when it points at loopback and profiles are registered here). A remote daemon resolves
+ * profiles itself, and must never receive this machine's own extension tokens.
+ */
+export async function isLocalDaemon(url: string): Promise<boolean> {
+  const { key, host } = parseUrl(url);
+  const config = await readListeners().catch(() => null);
+  // Before listeners.json existed, a local install pointed at loopback and had its own registry;
+  // a fresh client (no registry) talking to a tunnelled loopback port is still remote.
+  if (!config) return ["127.0.0.1", "localhost", "::1", "[::1]"].includes(host) && Object.keys(await readTokenRegistry().catch(() => ({}))).length > 0;
+  return !!key && config.listeners.some(l => l.key === key);
+}
+
+/** For a remote daemon: only what the URL itself carries, plus the profile selector (not secret). */
+export function remoteClientEnv(url: string, profile?: string): Record<string, string> {
+  const { extensionId, extensionToken, userDataDir, loadExtension } = parseUrl(url);
+  return Object.fromEntries(Object.entries({
+    PLAYWRIGHT_MCP_EXTENSION_ID: extensionId, PLAYWRIGHT_MCP_EXTENSION_TOKEN: extensionToken,
+    PLAYWRIGHT_MCP_PROFILE_DIRECTORY: profile, PLAYWRIGHT_MCP_USER_DATA_DIR: userDataDir, PLAYWRIGHT_MCP_LOAD_EXTENSION: loadExtension,
+  }).filter(([, v]) => typeof v === "string" && v)) as Record<string, string>;
+}
+
 async function callServe(
   url: string,
   args: string[],
@@ -1107,7 +1303,9 @@ async function callServe(
   // reuse the default profile's session (and its browser) instead of opening its own.
   const effectiveProfile = overrideEnv?.["PLAYWRIGHT_MCP_PROFILE_DIRECTORY"] || resolveEffectiveProfile(profileDirectory);
   if (effectiveProfile) identity.profile = effectiveProfile;
-  const env = { ...(await getClientEnv({ extensionId, extensionToken, profileDirectory: effectiveProfile, userDataDir, loadExtension })), ...overrideEnv };
+  const env = await isLocalDaemon(url)
+    ? { ...(await getClientEnv({ extensionId, extensionToken, profileDirectory: effectiveProfile, userDataDir, loadExtension })), ...overrideEnv }
+    : { ...remoteClientEnv(url, effectiveProfile), ...overrideEnv };
   const res = await fetch(serviceUrl(url, "run"), {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
@@ -2185,7 +2383,7 @@ async function resolveProfileKeys(selectors: string[]): Promise<string[]> {
 }
 
 /** Next steps after exposing a listener: proxy it, record where, share. Plain text, so any shell works. */
-export function listenerNextSteps(listener: Listener, profile?: string): string[] {
+export function listenerNextSteps(listener: Listener, profile?: string, shareCommand?: string): string[] {
   const prefix = normalizePrefix(listener.prefix);
   const mount = prefix === "/" ? "" : prefix.slice(0, -1);
   return [
@@ -2193,7 +2391,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 share ${profile ? JSON.stringify(profile) : "<profile>"}`,
+    `  ${shareCommand ?? `rech share ${profile ? JSON.stringify(profile) : "<profile>"}`}`,
   ];
 }
 
@@ -2265,7 +2463,9 @@ 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 share <profile>`);
+  const wide = config.listeners.filter(l => l.profiles !== "*" && l.profiles.length > 1);
+  if (wide.length) console.log(`\nOne key covers several profiles on: ${wide.map(l => `${l.name} (${(l.profiles as string[]).length})`).join(", ")}. Anyone with such a link can use each of them.`);
+  console.log(`\nPrint a full URL (contains the secret key): rech share <profile>, or rech share --all`);
 }
 
 /** Write RECHROME_URL to this project's .rechrome/.env.local (the folder git-ignores itself). */
@@ -2293,6 +2493,8 @@ async function connect(url: string): Promise<void> {
     throw new Error(`Connected, but listener "${body.listener}" does not allow profile "${parsed.profileDirectory}".`);
   const saved = await saveProjectUrl(url);
   console.log(`Connected to ${serviceUrl(url)}${body.listener ? ` (listener ${body.listener})` : ""}. Saved RECHROME_URL to ${saved}`);
+  if (Array.isArray(body.profiles) && body.profiles.length > 1 && !parsed.profileDirectory)
+    console.log(`This link shares ${body.profiles.length} profiles: ${body.profiles.join(", ")}.\nPick one per command: rech --profile <name> open https://example.com   (see them again with rech profile)`);
 }
 
 export function detectSetupAgent(env: Record<string, string | undefined> = process.env): "Codex" | "Claude Code" | null {
@@ -2746,8 +2948,10 @@ export type RechHandlers = {
   addListener(name: string, opts: { listen: string; profile: string[]; port?: number; prefix?: string }): Promise<void>;
   removeListener(name: string): Promise<void>;
   listProfiles(): Promise<void>;
-  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean }): Promise<void>;
+  removeProfile(selector: string, opts: { yes?: boolean; close?: boolean }): Promise<void>;
+  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean; all?: boolean }): Promise<void>;
   urlList(): Promise<void>;
+  shareProfiles(selectors: string[], opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void>;
   connect(url: string): Promise<void>;
   listenerPort(name?: string): Promise<void>;
   allowListener(name: string, profiles: string[]): Promise<void>;
@@ -2810,24 +3014,39 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
       .option("yes", { alias: "y", type: "boolean", default: false, describe: "Approve installing a missing oxmgr without prompting" }),
       a => handlers.setup({ profile: a.profile, token: a.token ?? process.env.RECH_TOKEN, listen: a.listen, prefix: a.prefix, port: a.port, yes: a.yes }))
     .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)" })
+    .command(["profile [name] [target]", "profiles [name] [target]"], "List Chrome profiles; `profile rm <name>` removes one from rech", y => y
+      .positional("name", { type: "string", describe: "ls/list lists all (the default); rm/remove <name> removes a profile" })
+      .positional("target", { type: "string", describe: "The profile to remove (with rm)" })
+      .option("yes", { alias: "y", type: "boolean", describe: "With rm: don't ask for confirmation" })
+      .option("close", { type: "boolean", describe: "With rm: close the profile's running window (managed profiles)" })
       .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.name === "rm" || a.name === "remove") {
+          if (!a.target) throw new Error("Which profile? rech profile rm <name>   (see rech profile)");
+          return handlers.removeProfile(a.target, { yes: a.yes, close: a.close });
+        }
+        if (a.target) throw new Error(`Unexpected "${a.target}". To remove a profile: rech profile rm <name>`);
         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 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("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" })
+    .command("share [profiles..]", "Print a URL another machine can connect with (secret); `share ls` lists all", y => y
+      .positional("profiles", { type: "string", array: true, describe: "Profile(s): email, name, folder, or a unique part of one. Several = one link for all of them. 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 }))
+      .option("save", { type: "boolean", describe: "Also save it as RECHROME_URL in this project's .rechrome/.env.local" })
+      .option("all", { type: "boolean", describe: "One link for every registered profile (a snapshot, on its own listener); the other machine picks with --profile" }),
+      a => {
+        const profiles = (a.profiles ?? []) as string[];
+        if (profiles.length === 1 && ["ls", "list"].includes(profiles[0]) && !a.listener && !a.save && !a.all) return handlers.urlList();
+        if (profiles.length > 1) {
+          if (a.all) throw new Error("Pass profiles or --all, not both.");
+          return handlers.shareProfiles(profiles, { listener: a.listener, local: a.local, save: a.save });
+        }
+        return handlers.printProfileUri(profiles[0], a.listener, a.all ? { local: a.local, save: a.save, all: true } : { 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 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=…'", ""),
@@ -2893,8 +3112,12 @@ if (import.meta.main) {
   const handlers: RechHandlers = {
     serve: async () => { const { serve } = await import("./serve.js"); serve(); }, // long-lived; watcher intentionally kept alive
     status,
-    listListeners, addListener, removeListener, listProfiles, printProfileUri,
-    urlList, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
+    listListeners, addListener, removeListener, printProfileUri,
+    listProfiles: async () => {
+      const url = process.env[ENV_KEY];
+      return url && !(await isLocalDaemon(url)) ? listRemoteProfiles(url) : listProfiles();
+    },
+    urlList, shareProfiles, removeProfile, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
     setup: async (opts) => {
       await setup(opts); // setup closes envWatcher itself before printing Done
       // Auto-start the tray (best-effort, silent on headless / missing binary).
@@ -2954,7 +3177,11 @@ if (import.meta.main) {
       envWatcher?.close();
       process.exit(1);
     }
-    if (profileSelector !== undefined) {
+    if (profileSelector !== undefined && !(await isLocalDaemon(url))) {
+      // A remote host resolves the name among the profiles its link shares; this machine's
+      // registry is irrelevant (and usually empty on a client).
+      overrideEnv = { PLAYWRIGHT_MCP_PROFILE_DIRECTORY: profileSelector.trim() };
+    } else if (profileSelector !== undefined) {
       try {
         const registry = await readTokenRegistry();
         const cache = await readChromeProfileCache();

package/rechrome.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
-import { readListeners, writeListeners, listenerAddress, isLoopback, normalizePrefix, serviceUrl, allowProfiles, denyProfiles, rotateListenerKey, setPublicUrl, type Listener } from "./listeners.ts";
+import { readListeners, writeListeners, listenerAddress, isLoopback, normalizePrefix, serviceUrl, allowProfiles, denyProfiles, rotateListenerKey, setPublicUrl, canonicalProfileKeys, planProfileRemoval, type Listener } from "./listeners.ts";
 
 import { file } from "bun";
 import yargs from "yargs";
 import { readExtensionTokenFromProfile } from "./extension-token.ts";
-import { randomBytes } from "crypto";
+import { createHash, randomBytes } from "crypto";
 import { mkdirSync, appendFileSync, existsSync, realpathSync, accessSync, cpSync, unlinkSync, readFileSync, readdirSync, renameSync, rmdirSync, constants as fsConstants } from "fs";
 import { hostname, homedir, networkInterfaces } from "os";
 import { isIPv4 } from "net";
@@ -624,7 +624,7 @@ const CHROME_LOCAL_STATE_PATHS = () => {
 
 type ChromeProfileInfo = { user_name?: string; name?: string };
 
-async function readChromeProfileCache(): Promise<Record<string, ChromeProfileInfo> | null> {
+export async function readChromeProfileCache(): Promise<Record<string, ChromeProfileInfo> | null> {
   for (const statePath of CHROME_LOCAL_STATE_PATHS()) {
     const f = file(statePath);
     if (!(await f.exists())) continue;
@@ -893,6 +893,91 @@ export function buildProfileRows(cache: Record<string, ChromeProfileInfo> | null
   return rows;
 }
 
+/** PIDs of browser processes (not helpers) running on a Chrome user-data dir. POSIX only. */
+function browsersUsing(userDataDir: string): number[] {
+  if (process.platform === "win32") return [];
+  const ps = Bun.spawnSync(["ps", "ax", "-o", "pid=,command="]).stdout.toString();
+  return ps.split("\n").filter(line => line.includes(`--user-data-dir=${userDataDir}`) && !line.includes("--type="))
+    .map(line => Number(line.trim().split(/\s+/)[0])).filter(Boolean);
+}
+
+/** Move a folder to the user's Trash (recoverable). Returns where it went, or null if unsupported here. */
+function moveToTrash(dir: string): string | null {
+  const trash = process.platform === "darwin" ? join(HOME, ".Trash") : process.platform === "linux" ? join(HOME, ".local", "share", "Trash", "files") : null;
+  if (!trash) return null;
+  mkdirSync(trash, { recursive: true });
+  let dest = join(trash, basename(dir));
+  if (existsSync(dest)) dest = `${dest} ${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  renameSync(dir, dest);
+  return dest;
+}
+
+/**
+ * `rech profile rm <name>`: unregister a profile everywhere (all its aliases, every listener
+ * allowlist, dropping listeners left empty) and move a managed test profile's own folder to the
+ * Trash. Real Chrome profile data is never touched. Shows the plan and asks first (--yes skips);
+ * a browser still running on a managed folder is closed only with consent (--close).
+ */
+async function removeProfile(selector: string, opts: { yes?: boolean; close?: boolean } = {}): Promise<void> {
+  const registry = await readTokenRegistry(), cache = await readChromeProfileCache();
+  const key = (await resolveGlobalProfile(registry, cache, selector)).email;
+  const config = await readListeners();
+  const plan = planProfileRemoval(key, registry, config?.listeners ?? [], join(RECH_DIR, "profiles"));
+  const running = plan.dataDir ? browsersUsing(plan.dataDir) : [];
+  console.log(`Remove profile "${key}"${plan.keys.length > 1 ? ` (registered as ${plan.keys.join(", ")})` : ""}:`);
+  for (const edit of plan.listeners) console.log(edit.drop ? `  - remove listener "${edit.name}" (it serves only this profile)` : `  - stop sharing it on listener "${edit.name}"`);
+  console.log(`  - unregister it from rech (~/.rechrome/profiles.yaml)`);
+  if (plan.dataDir) console.log(`  - move its data folder to the Trash: ${plan.dataDir}`);
+  else console.log(`  - its Chrome data is left alone (this only unregisters it from rech)`);
+  if (running.length) console.log(`  - close its browser window, which is running now (pid ${running.join(", ")})`);
+  const interactive = isInteractive();
+  if (!opts.yes) {
+    if (!interactive) throw new Error("Not removed. Re-run with --yes to confirm" + (running.length ? " and --close to close its running window." : "."));
+    const ok = await promptChoice("Go ahead?", [{ label: "No, keep it", value: false }, { label: "Yes, remove it", value: true }], 0);
+    if (!ok) throw new Error("Cancelled; nothing changed.");
+  }
+  if (running.length) {
+    // In a terminal, confirming the plan above (which lists closing it) is the consent; otherwise --close.
+    if (!interactive && !opts.close) throw new Error("Its window is running; re-run with --close to close it, or close it yourself first.");
+    for (const pid of running) process.kill(pid, "SIGTERM");
+    for (let i = 0; i < 40 && browsersUsing(plan.dataDir!).length; i++) await Bun.sleep(250);
+    if (browsersUsing(plan.dataDir!).length) throw new Error("Its window did not close; close it and run this again. Nothing else changed.");
+  }
+  if (config && plan.listeners.length) {
+    for (const edit of plan.listeners) {
+      if (edit.drop) config.listeners = config.listeners.filter(l => l.name !== edit.name);
+      else { const l = config.listeners.find(x => x.name === edit.name)!; l.profiles = (l.profiles as string[]).filter(p => !plan.keys.includes(p)); }
+    }
+    await writeListeners(config);
+  }
+  for (const k of plan.keys) delete registry[k];
+  await writeTokenRegistry(registry);
+  // The migrated profiles.json backup still holds tokens: drop the same keys there.
+  const legacy = join(RECH_DIR, "profiles.json");
+  if (existsSync(legacy)) {
+    try {
+      const old = JSON.parse(readFileSync(legacy, "utf8"));
+      if (plan.keys.some(k => k in old)) { for (const k of plan.keys) delete old[k]; await writeFile(legacy, JSON.stringify(old, null, 2) + "\n", { mode: 0o600 }); await chmod(legacy, 0o600); }
+    } catch { /* unreadable backup: leave it */ }
+  }
+  let moved: string | null = null;
+  if (plan.dataDir && existsSync(plan.dataDir)) moved = moveToTrash(plan.dataDir);
+  console.log(`Removed "${key}".${moved ? ` Its data folder is in the Trash: ${moved}` : plan.dataDir ? ` Its data folder was left at ${plan.dataDir}; delete it yourself if you like.` : ""}`);
+}
+
+/** On a client of a remote host, `rech profile` lists what that host's link shares. */
+async function listRemoteProfiles(url: string): Promise<void> {
+  const response = await fetch(serviceUrl(url, "ping"), { headers: { Authorization: `Bearer ${parseUrl(url).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 host rejected this link's key; ask for a fresh one (rech share on the host), then rech connect '<url>'.");
+  const body = await response.json().catch(() => ({})) as { listener?: string; profiles?: string[] | "*" };
+  const current = resolveEffectiveProfile(parseUrl(url).profileDirectory);
+  console.log(`Profiles shared by ${serviceUrl(url)}${body.listener ? ` (listener ${body.listener})` : ""}:`);
+  if (body.profiles === "*") console.log("  every profile registered on that host");
+  else for (const p of body.profiles ?? []) console.log(`  ${p}${p === current ? "   ← current" : ""}`);
+  console.log(`\nUse one: rech --profile <name> open https://example.com`);
+}
+
 async function listProfiles(): Promise<void> {
   const [cache, registry, root] = await Promise.all([readChromeProfileCache(), readTokenRegistry(), findChromeUserDataDir()]);
   const profiles = buildProfileRows(cache, registry, root);
@@ -983,15 +1068,12 @@ export async function promptChoice<T>(
   } finally { rl.close(); }
 }
 
-/** Registered profiles as choices, one per Chrome profile folder (the registry may alias one folder twice). */
+/** Registered profiles as choices, one per Chrome profile (data dir + folder; aliases collapse). */
 function registeredProfileChoices(registry: Record<string, TokenEntry>): { label: string; value: string }[] {
-  const byDir = new Map<string, string>();
-  for (const key of Object.keys(registry)) {
+  return canonicalProfileKeys(registry).map(key => {
     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 }));
+    return { label: key === dir ? key : `${key}  [${dir}]`, value: key };
+  });
 }
 
 /**
@@ -1013,7 +1095,95 @@ export function chooseShareListener(profile: string, listeners: Listener[]): str
   ].filter(Boolean).join("\n"), "none", scoped);
 }
 
-async function printProfileUri(selector?: string, listener?: string, opts: { local?: boolean; save?: boolean } = {}): Promise<void> {
+/** A loopback port no listener uses and nothing else is bound to, from the management port + 2. */
+function freeListenerPort(listeners: Listener[]): number {
+  const used = new Set(listeners.map(l => l.port));
+  for (let port = DEFAULT_PORT + 2; port < 65536; port++) {
+    if (used.has(port)) continue;
+    try { Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response() }).stop(true); return port; } catch { /* taken */ }
+  }
+  throw new Error("No free port for the share-all listener; pass one with rech listener add");
+}
+
+/**
+ * `rech share --all`: one link for every Chrome profile registered now (a snapshot; run it
+ * again after registering more). It uses its own listener and key, so single-profile links
+ * already handed out never gain access to the other profiles.
+ */
+async function shareAll(opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void> {
+  const snapshot = canonicalProfileKeys(await readTokenRegistry());
+  if (!snapshot.length) throw new Error("No registered profiles to share. Set one up first: rech setup");
+  return shareSet(snapshot, { ...opts, defaultName: "share-all", prefix: "/rechrome-all/", again: "rech share --all" });
+}
+
+/** The registry key rech uses for a profile: one per Chrome profile, whatever alias it was named by. */
+function canonicalKeyFor(registry: Record<string, TokenEntry>, key: string): string {
+  const entry = registry[key];
+  return canonicalProfileKeys(registry).find(k => registry[k].profileDir === entry?.profileDir && (registry[k].userDataDir ?? "") === (entry?.userDataDir ?? "")) ?? key;
+}
+
+/**
+ * `rech share a b c`: one link for exactly these profiles, on one listener. With --listener it
+ * sets that listener's profiles to the list (e.g. one that already has a proxy route); otherwise
+ * it reuses a listener with exactly this set, or creates one with its own key.
+ */
+async function shareProfiles(selectors: string[], opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void> {
+  const registry = await readTokenRegistry(), cache = await readChromeProfileCache();
+  const keys: string[] = [];
+  for (const selector of selectors) {
+    const key = canonicalKeyFor(registry, (await resolveGlobalProfile(registry, cache, selector)).email);
+    if (!keys.includes(key)) keys.push(key);
+  }
+  if (keys.length === 1) return printProfileUri(keys[0], opts.listener, opts);
+  const config = await requireListeners();
+  const same = config.listeners.find(l => l.profiles !== "*" && l.profiles.length === keys.length && keys.every(k => (l.profiles as string[]).includes(k)));
+  const id = createHash("sha256").update([...keys].sort().join("\0")).digest("hex").slice(0, 6);
+  return shareSet(keys, { ...opts, listener: opts.listener ?? same?.name, defaultName: `share-${id}`, prefix: `/rechrome-${id}/`, again: `rech share ${selectors.map(s => JSON.stringify(s)).join(" ")}` });
+}
+
+/** Put exactly `snapshot` on one scoped listener (created if missing) and print its link. */
+async function shareSet(snapshot: string[], opts: { listener?: string; local?: boolean; save?: boolean; defaultName: string; prefix: string; again: string }): Promise<void> {
+  const config = await requireListeners();
+  const name = opts.listener ?? opts.defaultName;
+  let listener = config.listeners.find(l => l.name === name);
+  if (listener?.profiles === "*")
+    throw new Error(`"${name}" is the local management listener; it is never shared. Omit --listener, or name a scoped one.`);
+  let changes = "";
+  if (!listener) {
+    if (opts.listener) throw new Error(`Unknown listener "${name}". See rech listener ls.`);
+    listener = { name, host: "127.0.0.1", port: freeListenerPort(config.listeners), prefix: opts.prefix, key: randomBytes(24).toString("base64url"), profiles: snapshot };
+    config.listeners.push(listener);
+    changes = `created listener "${name}" on ${listenerAddress(listener)}${listener.prefix}`;
+  } else {
+    const before = listener.profiles as string[];
+    const added = snapshot.filter(p => !before.includes(p)), removed = before.filter(p => !snapshot.includes(p));
+    listener.profiles = snapshot;
+    changes = added.length || removed.length ? [added.length && `added ${added.join(", ")}`, removed.length && `removed ${removed.join(", ")}`].filter(Boolean).join("; ") : "no changes";
+  }
+  await writeListeners(config);
+  console.error(`[rech] sharing ${snapshot.length} profiles through "${name}" (${changes}): ${snapshot.join(", ")}`);
+  if (opts.defaultName === "share-all") console.error(`[rech] this is a snapshot: after registering another profile, run ${opts.again} again.`);
+  else if (changes !== "no changes" && !changes.startsWith("created")) console.error(`[rech] links already given out for "${name}" now reach exactly these profiles too (same key). For a fresh key: rech listener rotate-key ${name}`);
+  // The daemon reloads listeners.json about every second: confirm this listener answers before handing out its URL.
+  const local = `http://${listener.key}@${listenerAddress(listener)}${normalizePrefix(listener.prefix)}`;
+  let ready = false;
+  for (let i = 0; i < 20 && !ready; i++) {
+    ready = await fetch(serviceUrl(local, "ping"), { headers: { Authorization: `Bearer ${listener.key}` }, signal: AbortSignal.timeout(1000) }).then(r => r.ok).catch(() => false);
+    if (!ready) await Bun.sleep(250);
+  }
+  if (!ready) console.error(`[rech] warning: listener "${name}" is not answering yet; check the daemon with rech status.`);
+  const uri = listener.publicUrl && !opts.local ? rebaseConnectionUrl(listener.publicUrl, local) : registeredProfileUrl(local);
+  if (!listener.publicUrl) for (const line of listenerNextSteps(listener, undefined, opts.again)) console.error(line);
+  console.log(uri);
+  console.error(`[rech] on the other machine: rech connect '<url>', then rech --profile <name> open https://example.com`);
+  if (opts.save) console.error(`Saved RECHROME_URL to ${await saveProjectUrl(uri)}`);
+}
+
+async function printProfileUri(selector?: string, listener?: string, opts: { local?: boolean; save?: boolean; all?: boolean } = {}): Promise<void> {
+  if (opts.all) {
+    if (selector) throw new Error("Pass a profile or --all, not both.");
+    return shareAll({ listener, local: opts.local, save: opts.save });
+  }
   const url = process.env[ENV_KEY];
   const interactive = isInteractive();
   const registry = await readTokenRegistry();
@@ -1073,8 +1243,11 @@ async function printProfileUri(selector?: string, listener?: string, opts: { loc
       }
     }
   }
-  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.`);
+  const chosen = listeners.find(l => l.name === listener);
+  if (chosen?.profiles === "*")
+    throw new Error(`"${listener}" is the local management listener: its key controls every profile and allows eval and file access, so it is never shared. Share through a scoped listener: rech share <profile>, or rech share --all.`);
+  if (chosen && chosen.profiles.length > 1)
+    console.error(`[rech] note: this link's key works for every profile on listener "${chosen.name}" (${chosen.profiles.join(", ")}); ?profile= only picks the default. For a one-profile link, give that profile its own listener.`);
   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;
@@ -1090,6 +1263,29 @@ export function sandboxConnectionWarning(env: Record<string, string | undefined>
     "If it still fails, check that the daemon is running and the host/port are correct.";
 }
 
+/**
+ * Is RECHROME_URL this machine's own daemon? True when its key is one of our listeners (or,
+ * before listeners.json existed, when it points at loopback and profiles are registered here). A remote daemon resolves
+ * profiles itself, and must never receive this machine's own extension tokens.
+ */
+export async function isLocalDaemon(url: string): Promise<boolean> {
+  const { key, host } = parseUrl(url);
+  const config = await readListeners().catch(() => null);
+  // Before listeners.json existed, a local install pointed at loopback and had its own registry;
+  // a fresh client (no registry) talking to a tunnelled loopback port is still remote.
+  if (!config) return ["127.0.0.1", "localhost", "::1", "[::1]"].includes(host) && Object.keys(await readTokenRegistry().catch(() => ({}))).length > 0;
+  return !!key && config.listeners.some(l => l.key === key);
+}
+
+/** For a remote daemon: only what the URL itself carries, plus the profile selector (not secret). */
+export function remoteClientEnv(url: string, profile?: string): Record<string, string> {
+  const { extensionId, extensionToken, userDataDir, loadExtension } = parseUrl(url);
+  return Object.fromEntries(Object.entries({
+    PLAYWRIGHT_MCP_EXTENSION_ID: extensionId, PLAYWRIGHT_MCP_EXTENSION_TOKEN: extensionToken,
+    PLAYWRIGHT_MCP_PROFILE_DIRECTORY: profile, PLAYWRIGHT_MCP_USER_DATA_DIR: userDataDir, PLAYWRIGHT_MCP_LOAD_EXTENSION: loadExtension,
+  }).filter(([, v]) => typeof v === "string" && v)) as Record<string, string>;
+}
+
 async function callServe(
   url: string,
   args: string[],
@@ -1107,7 +1303,9 @@ async function callServe(
   // reuse the default profile's session (and its browser) instead of opening its own.
   const effectiveProfile = overrideEnv?.["PLAYWRIGHT_MCP_PROFILE_DIRECTORY"] || resolveEffectiveProfile(profileDirectory);
   if (effectiveProfile) identity.profile = effectiveProfile;
-  const env = { ...(await getClientEnv({ extensionId, extensionToken, profileDirectory: effectiveProfile, userDataDir, loadExtension })), ...overrideEnv };
+  const env = await isLocalDaemon(url)
+    ? { ...(await getClientEnv({ extensionId, extensionToken, profileDirectory: effectiveProfile, userDataDir, loadExtension })), ...overrideEnv }
+    : { ...remoteClientEnv(url, effectiveProfile), ...overrideEnv };
   const res = await fetch(serviceUrl(url, "run"), {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
@@ -2185,7 +2383,7 @@ async function resolveProfileKeys(selectors: string[]): Promise<string[]> {
 }
 
 /** Next steps after exposing a listener: proxy it, record where, share. Plain text, so any shell works. */
-export function listenerNextSteps(listener: Listener, profile?: string): string[] {
+export function listenerNextSteps(listener: Listener, profile?: string, shareCommand?: string): string[] {
   const prefix = normalizePrefix(listener.prefix);
   const mount = prefix === "/" ? "" : prefix.slice(0, -1);
   return [
@@ -2193,7 +2391,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 share ${profile ? JSON.stringify(profile) : "<profile>"}`,
+    `  ${shareCommand ?? `rech share ${profile ? JSON.stringify(profile) : "<profile>"}`}`,
   ];
 }
 
@@ -2265,7 +2463,9 @@ 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 share <profile>`);
+  const wide = config.listeners.filter(l => l.profiles !== "*" && l.profiles.length > 1);
+  if (wide.length) console.log(`\nOne key covers several profiles on: ${wide.map(l => `${l.name} (${(l.profiles as string[]).length})`).join(", ")}. Anyone with such a link can use each of them.`);
+  console.log(`\nPrint a full URL (contains the secret key): rech share <profile>, or rech share --all`);
 }
 
 /** Write RECHROME_URL to this project's .rechrome/.env.local (the folder git-ignores itself). */
@@ -2293,6 +2493,8 @@ async function connect(url: string): Promise<void> {
     throw new Error(`Connected, but listener "${body.listener}" does not allow profile "${parsed.profileDirectory}".`);
   const saved = await saveProjectUrl(url);
   console.log(`Connected to ${serviceUrl(url)}${body.listener ? ` (listener ${body.listener})` : ""}. Saved RECHROME_URL to ${saved}`);
+  if (Array.isArray(body.profiles) && body.profiles.length > 1 && !parsed.profileDirectory)
+    console.log(`This link shares ${body.profiles.length} profiles: ${body.profiles.join(", ")}.\nPick one per command: rech --profile <name> open https://example.com   (see them again with rech profile)`);
 }
 
 export function detectSetupAgent(env: Record<string, string | undefined> = process.env): "Codex" | "Claude Code" | null {
@@ -2746,8 +2948,10 @@ export type RechHandlers = {
   addListener(name: string, opts: { listen: string; profile: string[]; port?: number; prefix?: string }): Promise<void>;
   removeListener(name: string): Promise<void>;
   listProfiles(): Promise<void>;
-  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean }): Promise<void>;
+  removeProfile(selector: string, opts: { yes?: boolean; close?: boolean }): Promise<void>;
+  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean; all?: boolean }): Promise<void>;
   urlList(): Promise<void>;
+  shareProfiles(selectors: string[], opts: { listener?: string; local?: boolean; save?: boolean }): Promise<void>;
   connect(url: string): Promise<void>;
   listenerPort(name?: string): Promise<void>;
   allowListener(name: string, profiles: string[]): Promise<void>;
@@ -2810,24 +3014,39 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
       .option("yes", { alias: "y", type: "boolean", default: false, describe: "Approve installing a missing oxmgr without prompting" }),
       a => handlers.setup({ profile: a.profile, token: a.token ?? process.env.RECH_TOKEN, listen: a.listen, prefix: a.prefix, port: a.port, yes: a.yes }))
     .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)" })
+    .command(["profile [name] [target]", "profiles [name] [target]"], "List Chrome profiles; `profile rm <name>` removes one from rech", y => y
+      .positional("name", { type: "string", describe: "ls/list lists all (the default); rm/remove <name> removes a profile" })
+      .positional("target", { type: "string", describe: "The profile to remove (with rm)" })
+      .option("yes", { alias: "y", type: "boolean", describe: "With rm: don't ask for confirmation" })
+      .option("close", { type: "boolean", describe: "With rm: close the profile's running window (managed profiles)" })
       .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.name === "rm" || a.name === "remove") {
+          if (!a.target) throw new Error("Which profile? rech profile rm <name>   (see rech profile)");
+          return handlers.removeProfile(a.target, { yes: a.yes, close: a.close });
+        }
+        if (a.target) throw new Error(`Unexpected "${a.target}". To remove a profile: rech profile rm <name>`);
         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 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("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" })
+    .command("share [profiles..]", "Print a URL another machine can connect with (secret); `share ls` lists all", y => y
+      .positional("profiles", { type: "string", array: true, describe: "Profile(s): email, name, folder, or a unique part of one. Several = one link for all of them. 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 }))
+      .option("save", { type: "boolean", describe: "Also save it as RECHROME_URL in this project's .rechrome/.env.local" })
+      .option("all", { type: "boolean", describe: "One link for every registered profile (a snapshot, on its own listener); the other machine picks with --profile" }),
+      a => {
+        const profiles = (a.profiles ?? []) as string[];
+        if (profiles.length === 1 && ["ls", "list"].includes(profiles[0]) && !a.listener && !a.save && !a.all) return handlers.urlList();
+        if (profiles.length > 1) {
+          if (a.all) throw new Error("Pass profiles or --all, not both.");
+          return handlers.shareProfiles(profiles, { listener: a.listener, local: a.local, save: a.save });
+        }
+        return handlers.printProfileUri(profiles[0], a.listener, a.all ? { local: a.local, save: a.save, all: true } : { 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 share <profile>` on the machine with Chrome. Quote it: it contains #" })
       .example("rech connect 'https://host.example.ts.net/rechrome/?profile=you%40example.com#key=…'", ""),
@@ -2893,8 +3112,12 @@ if (import.meta.main) {
   const handlers: RechHandlers = {
     serve: async () => { const { serve } = await import("./serve.ts"); serve(); }, // long-lived; watcher intentionally kept alive
     status,
-    listListeners, addListener, removeListener, listProfiles, printProfileUri,
-    urlList, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
+    listListeners, addListener, removeListener, printProfileUri,
+    listProfiles: async () => {
+      const url = process.env[ENV_KEY];
+      return url && !(await isLocalDaemon(url)) ? listRemoteProfiles(url) : listProfiles();
+    },
+    urlList, shareProfiles, removeProfile, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
     setup: async (opts) => {
       await setup(opts); // setup closes envWatcher itself before printing Done
       // Auto-start the tray (best-effort, silent on headless / missing binary).
@@ -2954,7 +3177,11 @@ if (import.meta.main) {
       envWatcher?.close();
       process.exit(1);
     }
-    if (profileSelector !== undefined) {
+    if (profileSelector !== undefined && !(await isLocalDaemon(url))) {
+      // A remote host resolves the name among the profiles its link shares; this machine's
+      // registry is irrelevant (and usually empty on a client).
+      overrideEnv = { PLAYWRIGHT_MCP_PROFILE_DIRECTORY: profileSelector.trim() };
+    } else if (profileSelector !== undefined) {
       try {
         const registry = await readTokenRegistry();
         const cache = await readChromeProfileCache();

package/serve.js

@@ -1,4 +1,4 @@
-import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, type Listener } from "./listeners.js";
+import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, type Listener } from "./listeners.js";
 import { file } from "bun";
 import { createHash, X509Certificate } from "crypto";
 import { mkdirSync, unlinkSync, accessSync, readdirSync, realpathSync, constants as fsConstants } from "fs";
@@ -15,6 +15,7 @@ import {
   PASSTHROUGH_ENV_KEYS,
   resolvePlaywrightCli,
   readTokenRegistry,
+  readChromeProfileCache,
 } from "./rechrome.js";
 
 const TAILSCALE_BIN = process.env.TAILSCALE_BIN || "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
@@ -591,8 +592,19 @@ export async function serve() {
       let profileEnv: Record<string, string> = {};
       if (scoped) {
         try {
-          scopedProfile = authorizeProfileRequest(listener, body);
           const registry = await readTokenRegistry();
+          // The client sends whatever the user typed (`rech --profile work`); resolve it here,
+          // among this listener's profiles only, to one canonical key BEFORE authorization and
+          // session hashing, so aliases of one profile share a session and a remote client needs
+          // no registry of its own.
+          if (body && !Array.isArray(body) && typeof body.identity === "object" && body.identity) {
+            const chromeNames = Object.fromEntries(Object.entries(await readChromeProfileCache().catch(() => null) ?? {}).map(([dir, info]) => [dir, info.name ?? ""]).filter(([, name]) => name));
+            const allowed = listener.profiles as string[];
+            body.identity.profile = resolveAllowedProfile(body.identity.profile ?? body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY, allowed, registry, chromeNames);
+            if (typeof body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY === "string")
+              body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY = resolveAllowedProfile(body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY, allowed, registry, chromeNames);
+          }
+          scopedProfile = authorizeProfileRequest(listener, body);
           const entry = registry[scopedProfile];
           if (!entry?.token || !entry?.extensionId || !entry?.profileDir) throw new Error("Profile is not registered on this server");
           profileEnv = {
@@ -604,7 +616,7 @@ export async function serve() {
           };
           body.identity.key = `scoped:${body.identity.key}`;
           body.env = {}; // Server-owned profile configuration wins over every client override.
-        } catch (error) { return Response.json({ status: 1, stdout: "", stderr: String(error) }, { status: 403 }); }
+        } catch (error) { return Response.json({ status: 1, stdout: "", stderr: `${error instanceof Error ? error.message : String(error)}\n` }, { status: 403 }); }
       }
       const outputPrefix = scopedProfile ? profileOutputPrefix(scopedProfile) : "";
       const runWorkDir = scopedProfile ? join(workDir, outputPrefix) : workDir;

package/serve.ts

@@ -1,4 +1,4 @@
-import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, type Listener } from "./listeners.ts";
+import { readListeners, listenerAddress, authorizeProfileRequest, canReadProfileFile, profileOutputPrefix, normalizePrefix, resolveAllowedProfile, type Listener } from "./listeners.ts";
 import { file } from "bun";
 import { createHash, X509Certificate } from "crypto";
 import { mkdirSync, unlinkSync, accessSync, readdirSync, realpathSync, constants as fsConstants } from "fs";
@@ -15,6 +15,7 @@ import {
   PASSTHROUGH_ENV_KEYS,
   resolvePlaywrightCli,
   readTokenRegistry,
+  readChromeProfileCache,
 } from "./rechrome.ts";
 
 const TAILSCALE_BIN = process.env.TAILSCALE_BIN || "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
@@ -591,8 +592,19 @@ export async function serve() {
       let profileEnv: Record<string, string> = {};
       if (scoped) {
         try {
-          scopedProfile = authorizeProfileRequest(listener, body);
           const registry = await readTokenRegistry();
+          // The client sends whatever the user typed (`rech --profile work`); resolve it here,
+          // among this listener's profiles only, to one canonical key BEFORE authorization and
+          // session hashing, so aliases of one profile share a session and a remote client needs
+          // no registry of its own.
+          if (body && !Array.isArray(body) && typeof body.identity === "object" && body.identity) {
+            const chromeNames = Object.fromEntries(Object.entries(await readChromeProfileCache().catch(() => null) ?? {}).map(([dir, info]) => [dir, info.name ?? ""]).filter(([, name]) => name));
+            const allowed = listener.profiles as string[];
+            body.identity.profile = resolveAllowedProfile(body.identity.profile ?? body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY, allowed, registry, chromeNames);
+            if (typeof body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY === "string")
+              body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY = resolveAllowedProfile(body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY, allowed, registry, chromeNames);
+          }
+          scopedProfile = authorizeProfileRequest(listener, body);
           const entry = registry[scopedProfile];
           if (!entry?.token || !entry?.extensionId || !entry?.profileDir) throw new Error("Profile is not registered on this server");
           profileEnv = {
@@ -604,7 +616,7 @@ export async function serve() {
           };
           body.identity.key = `scoped:${body.identity.key}`;
           body.env = {}; // Server-owned profile configuration wins over every client override.
-        } catch (error) { return Response.json({ status: 1, stdout: "", stderr: String(error) }, { status: 403 }); }
+        } catch (error) { return Response.json({ status: 1, stdout: "", stderr: `${error instanceof Error ? error.message : String(error)}\n` }, { status: 403 }); }
       }
       const outputPrefix = scopedProfile ? profileOutputPrefix(scopedProfile) : "";
       const runWorkDir = scopedProfile ? join(workDir, outputPrefix) : workDir;