rechrome 1.29.0 → 1.30.0

package/README.md

@@ -106,6 +106,18 @@ 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 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`.
 
@@ -121,6 +133,9 @@ rech listener remove share
 ```
 
 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,11 +141,49 @@ 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}.`);
+}
 export {
   LISTENERS_FILE,
   allowProfiles,
   authorizeProfileRequest,
   canReadProfileFile,
+  canonicalProfileKeys,
   denyProfiles,
   isLoopback,
   listenerAddress,
@@ -153,6 +191,7 @@ export {
   normalizePublicUrl,
   profileOutputPrefix,
   readListeners,
+  resolveAllowedProfile,
   rotateListenerKey,
   serviceUrl,
   setPublicUrl,

package/listeners.ts

@@ -135,3 +135,55 @@ 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}.`);
+}

package/package.json

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

package/rechrome.js

@@ -1,5 +1,5 @@
 #!/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, type Listener } from "./listeners.js";
 
 import { file } from "bun";
 import yargs from "yargs";
@@ -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,19 @@ export function buildProfileRows(cache: Record<string, ChromeProfileInfo> | null
   return rows;
 }
 
+/** 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 +996,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 +1023,64 @@ 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 config = await requireListeners();
+  const snapshot = canonicalProfileKeys(await readTokenRegistry());
+  if (!snapshot.length) throw new Error("No registered profiles to share. Set one up first: rech setup");
+  const name = opts.listener ?? "share-all";
+  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 to use "share-all".`);
+  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: "/rechrome-all/", 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(", ")}`);
+  console.error(`[rech] this is a snapshot: after registering another profile, run rech share --all again.`);
+  // 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, "rech share --all")) 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 +1140,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 +1160,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 +1200,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 +2280,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 +2288,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 +2360,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 +2390,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,7 +2845,7 @@ 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>;
+  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean; all?: boolean }): Promise<void>;
   urlList(): Promise<void>;
   connect(url: string): Promise<void>;
   listenerPort(name?: string): Promise<void>;
@@ -2824,10 +2923,11 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
       .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
+      .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 => ["ls", "list"].includes(a.profile ?? "") && !a.listener && !a.save && !a.all
         ? handlers.urlList()
-        : handlers.printProfileUri(a.profile, a.listener, { local: a.local, save: a.save }))
+        : handlers.printProfileUri(a.profile, 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,7 +2993,11 @@ 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,
+    listListeners, addListener, removeListener, printProfileUri,
+    listProfiles: async () => {
+      const url = process.env[ENV_KEY];
+      return url && !(await isLocalDaemon(url)) ? listRemoteProfiles(url) : listProfiles();
+    },
     urlList, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
     setup: async (opts) => {
       await setup(opts); // setup closes envWatcher itself before printing Done
@@ -2954,7 +3058,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,5 +1,5 @@
 #!/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, type Listener } from "./listeners.ts";
 
 import { file } from "bun";
 import yargs from "yargs";
@@ -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,19 @@ export function buildProfileRows(cache: Record<string, ChromeProfileInfo> | null
   return rows;
 }
 
+/** 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 +996,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 +1023,64 @@ 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 config = await requireListeners();
+  const snapshot = canonicalProfileKeys(await readTokenRegistry());
+  if (!snapshot.length) throw new Error("No registered profiles to share. Set one up first: rech setup");
+  const name = opts.listener ?? "share-all";
+  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 to use "share-all".`);
+  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: "/rechrome-all/", 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(", ")}`);
+  console.error(`[rech] this is a snapshot: after registering another profile, run rech share --all again.`);
+  // 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, "rech share --all")) 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 +1140,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 +1160,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 +1200,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 +2280,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 +2288,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 +2360,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 +2390,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,7 +2845,7 @@ 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>;
+  printProfileUri(selector?: string, listener?: string, opts?: { local?: boolean; save?: boolean; all?: boolean }): Promise<void>;
   urlList(): Promise<void>;
   connect(url: string): Promise<void>;
   listenerPort(name?: string): Promise<void>;
@@ -2824,10 +2923,11 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
       .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
+      .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 => ["ls", "list"].includes(a.profile ?? "") && !a.listener && !a.save && !a.all
         ? handlers.urlList()
-        : handlers.printProfileUri(a.profile, a.listener, { local: a.local, save: a.save }))
+        : handlers.printProfileUri(a.profile, 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,7 +2993,11 @@ 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,
+    listListeners, addListener, removeListener, printProfileUri,
+    listProfiles: async () => {
+      const url = process.env[ENV_KEY];
+      return url && !(await isLocalDaemon(url)) ? listRemoteProfiles(url) : listProfiles();
+    },
     urlList, connect, listenerPort, allowListener, denyListener, rotateKey, setListener,
     setup: async (opts) => {
       await setup(opts); // setup closes envWatcher itself before printing Done
@@ -2954,7 +3058,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";
@@ -243,6 +244,116 @@ async function resolveProfileDirectory(nameOrEmail: string): Promise<string> {
   return nameOrEmail;
 }
 
+// Free the listening port from stale daemon holders before retrying a failed bind.
+// On Windows the listening socket (created inheritable by Bun.serve) is swept into the
+// detached cliDaemon grandchild via bInheritHandles, so an orphaned cliDaemon from a
+// previous `serve` keeps the port in LISTEN after the old serve dies — the fresh serve
+// then crash-loops on EADDRINUSE. A clean restart releases the port, so a failed bind
+// only happens when such a stale holder exists; killing orphaned daemon holders here is
+// safe because a freshly-starting serve owns no live sessions of its own yet (the user's
+// Chrome tabs persist regardless — the cliDaemon only drives them).
+// Command lines freeStalePort may kill: a previous rech serve, or a cliDaemon started from
+// THIS install's playwright (lib/ or vendor/ under this directory) — never another app's
+// Playwright daemon, which runs from its own node_modules.
+const escapeRegex = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const OWN_CLI_DAEMON = import.meta.dir.split(/[\\/]/).map(escapeRegex).join(String.raw`[\\/]`) + String.raw`[\\/].*cliDaemon\.js`;
+const RECH_SERVE = String.raw`rech(rome)?(\.js)?"?\s+serve`;
+const STALE_HOLDER_PATTERN = `${OWN_CLI_DAEMON}|${RECH_SERVE}`;
+// A leaked socket (or a wedged serve) accepts connections but never answers. Anything that
+// responds at an address is a live server there — possibly a healthy rech serve — so it is
+// never killed. Both schemes: the holder's TLS setting may differ from this serve's.
+async function answersAt(address: string, port: number): Promise<boolean> {
+  const host = address === "0.0.0.0" || address === "*" ? "127.0.0.1"
+    : address === "::" ? "[::1]"
+    : address.includes(":") ? `[${address}]` : address;
+  const probe = (scheme: string) => fetch(`${scheme}://${host}:${port}/`, {
+    signal: AbortSignal.timeout(1500), tls: { rejectUnauthorized: false },
+  } as RequestInit).then(() => true, () => false);
+  return (await Promise.all([probe("http"), probe("https")])).includes(true);
+}
+
+type PortHolder = { address: string; pid: number; alive: boolean; command: string };
+
+// Listeners on `port` that conflict with binding `host`: the same address, or a wildcard of
+// its family (a wildcard bind conflicts with every address of the family). Never this serve's
+// own sockets, which may already hold other addresses on the same port from this startup.
+function conflictingHolders(port: number, host: string): PortHolder[] {
+  let holders: PortHolder[] = [];
+  if (process.platform === "win32") {
+    const ps = [
+      "$ErrorActionPreference='SilentlyContinue';",
+      `$r=@(Get-NetTCPConnection -LocalPort ${port} -State Listen | ForEach-Object {`,
+      "  $p=Get-CimInstance Win32_Process -Filter \"ProcessId=$($_.OwningProcess)\";",
+      "  [pscustomobject]@{ address=[string]$_.LocalAddress; pid=[int]$_.OwningProcess; alive=[bool]$p; command=[string]$p.CommandLine } });",
+      "ConvertTo-Json -Compress -InputObject $r",
+    ].join(" ");
+    const out = Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true }).stdout?.toString().trim();
+    try { holders = out ? [JSON.parse(out)].flat() : []; } catch { holders = []; }
+  } else {
+    const out = Bun.spawnSync(["sh", "-c", `lsof -nP -iTCP:${port} -sTCP:LISTEN -Fpn 2>/dev/null`]).stdout?.toString() ?? "";
+    let pid = 0;
+    for (const line of out.split("\n")) {
+      if (line.startsWith("p")) pid = Number(line.slice(1));
+      else if (line.startsWith("n") && pid) {
+        const address = line.slice(1).replace(/:\d+$/, "").replace(/^\[(.*)\]$/, "$1");
+        const command = Bun.spawnSync(["ps", "-o", "command=", "-p", String(pid)]).stdout?.toString().trim() ?? "";
+        holders.push({ address, pid, alive: true, command });
+      }
+    }
+  }
+  const v6 = (a: string) => a.includes(":");
+  const wildcard = (a: string) => a === "0.0.0.0" || a === "::" || a === "*";
+  // A `::` listener is dual-stack on Windows and most Linux setups: it conflicts with IPv4 binds too.
+  return holders.filter(h => h.pid !== process.pid && (
+    wildcard(host) ? (h.address === "*" || h.address === "::" || host === "::" || !v6(h.address))
+      : h.address === host || h.address === "*" || h.address === "::" || (h.address === "0.0.0.0" && !v6(host))));
+}
+
+// Free the conflicting address from stale rech holders before retrying a failed bind.
+// Narrow-first: (1) kill each conflicting owner that is a live rech serve / this install's
+// cliDaemon AND doesn't answer at its own address — never an unrelated app, never a healthy
+// server; (2) only if the address is STILL held by owners that are all dead — the
+// inherited-handle case, where the socket lives in a child while netstat attributes it to a
+// now-dead owner — sweep orphaned cliDaemons (Windows). That sweep is the only recovery for
+// the case (the live holder can't be mapped from the port), so it is a logged last resort.
+async function freeStalePort(port: number, host: string): Promise<void> {
+  try {
+    const stale = new RegExp(STALE_HOLDER_PATTERN, process.platform === "win32" ? "i" : "");
+    for (const h of conflictingHolders(port, host)) {
+      if (!h.alive) continue;
+      if (!stale.test(h.command)) { log(`freeStalePort: port ${port} is held by an unrelated process (${h.pid}); not killing it`); continue; }
+      if (await answersAt(h.address, port)) { log(`freeStalePort: ${h.address}:${port} is served by a live process (${h.pid}); not killing it`); continue; }
+      log(`freeStalePort: killing stale rech holder ${h.pid} of ${h.address}:${port}`);
+      try { process.kill(h.pid, "SIGKILL"); } catch {}
+    }
+    await new Promise(r => setTimeout(r, 400));
+    const remaining = conflictingHolders(port, host);
+    if (process.platform === "win32" && remaining.length && remaining.every(h => !h.alive)) {
+      const q = (text: string) => text.replaceAll("'", "''");
+      const ps = [
+        "$ErrorActionPreference='SilentlyContinue';",
+        // A cliDaemon's parent (playwright-cli) exits right after spawning it, so a live one
+        // can't be told from an orphan by ancestry. They are only provably orphaned when no
+        // other rech serve is running: exclude this serve and its own wrappers (oxmgr, cmd).
+        `$self=@(); $x=${process.pid}; while($x){ $self+=$x; $x=(Get-CimInstance Win32_Process -Filter \"ProcessId=$x\").ParentProcessId; if($self -contains $x){ break } };`,
+        `$live=@(Get-CimInstance Win32_Process | Where-Object { $self -notcontains $_.ProcessId -and $_.ProcessId -ne $PID -and $_.CommandLine -match '${q(RECH_SERVE)}' });`,
+        "if($live.Count){ Write-Output (\"freeStalePort: port still held, but another rech serve is running (\" + ($live.ProcessId -join ',') + \"); not sweeping cliDaemons\") }",
+        "else {",
+        // Exclude this PowerShell itself: its own command line contains the pattern.
+        `  $d=Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.CommandLine -match '${q(OWN_CLI_DAEMON)}' };`,
+        "  Write-Output (\"freeStalePort: port still held; killing orphaned cliDaemon holders: \" + ($d.ProcessId -join ','));",
+        "  $d | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }",
+        "}",
+      ].join(" ");
+      const out = Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true }).stdout?.toString().trim();
+      if (out) log(out);
+    }
+  } catch {
+    // best effort — the retry will surface a clear error if the port is still held
+  }
+  await new Promise(r => setTimeout(r, 800)); // let the OS release the socket before retry
+}
+
 // --- Foreground/orphan self-exit ---------------------------------------------------
 // A foreground `rech serve` (run directly by an agent, NOT under oxmgr/pm2) has no
 // process-manager safety net: when the agent that spawned it exits, the OS re-parents
@@ -394,9 +505,13 @@ export async function serve() {
   const legacy: Listener = { name: "legacy", host: listenHost, port, key, profiles: "*" };
   const policies = new Map<string, Listener>();
   const servers = new Map<string, ReturnType<typeof Bun.serve>>();
-  const startServer = (initial: Listener) => Bun.serve({
+  const startServer = (initial: Listener, reusePort = false) => Bun.serve({
     hostname: initial.host,
     port: initial.port,
+    // reusePort is used only as a last-resort fallback (see bindAtStartup below): if an orphaned
+    // holder can't be killed, binding with SO_REUSEADDR keeps serve up (degraded, port-shared)
+    // instead of crash-looping on EADDRINUSE. The normal path binds a clean, exclusive socket.
+    reusePort,
     tls,
     error(err) {
       log(`unhandled error: ${err.message}`);
@@ -477,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 = {
@@ -490,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;
@@ -773,14 +899,47 @@ export async function serve() {
     },
   });
 
+  // A leaked listening-socket handle in an orphaned cliDaemon can keep a port in LISTEN after a
+  // prior serve exits: Bun.serve creates the socket inheritable and Bun.spawn sweeps it into the
+  // detached daemon grandchild via bInheritHandles, so the socket outlives its creating serve.
+  // netstat then attributes the port to the now-dead *creator*, not the live holder, so we can't
+  // map port -> killable PID — freeStalePort kills the orphan by its cliDaemon signature instead.
+  // Startup only: a freshly-starting serve owns no live sessions, so clearing stale holders is
+  // safe. Hot reloads never kill anything (see reconcile). As an absolute last resort, bind with
+  // reusePort so a holder we genuinely can't kill degrades to "up but sharing the port" rather
+  // than a permanent EADDRINUSE crash-loop.
+  const isEaddrInUse = (e: any) => String(e?.code ?? e?.message ?? "").includes("EADDRINUSE");
+  const MAX_BIND_ATTEMPTS = 4;
+  const bindAtStartup = async (listener: Listener) => {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return startServer(listener);
+      } catch (e: any) {
+        if (!isEaddrInUse(e)) throw e;
+        // Something answers at this exact address: a live server (never killed, never port-shared).
+        if (await answersAt(listener.host, listener.port)) {
+          log(`port ${listener.port} is held by a live server that answers requests — not touching it`);
+          throw e;
+        }
+        if (attempt === MAX_BIND_ATTEMPTS) {
+          log(`port ${listener.port} still held after ${attempt - 1} cleanup attempts — binding with reusePort (last resort)`);
+          return startServer(listener, true);
+        }
+        log(`port ${listener.port} in use — clearing stale daemon holders and retrying (attempt ${attempt}/${MAX_BIND_ATTEMPTS - 1})`);
+        await freeStalePort(listener.port, listener.host);
+      }
+    }
+  };
+
   // Stage all new sockets before changing policy. Bind failure leaves existing
-  // listeners and browser sessions intact; never kill a process holding another port.
-  const reconcile = async (listeners: Listener[]) => {
+  // listeners and browser sessions intact; never kill a process holding another port
+  // once serving (stale-holder recovery runs only at startup).
+  const reconcile = async (listeners: Listener[], startup = false) => {
     const staged = new Map<string, ReturnType<typeof Bun.serve>>();
     try {
       for (const listener of listeners) {
         const address = listenerAddress(listener);
-        if (!servers.has(address)) staged.set(address, startServer(listener));
+        if (!servers.has(address)) staged.set(address, startup ? await bindAtStartup(listener) : startServer(listener));
       }
     } catch (error) {
       for (const server of staged.values()) server.stop(true);
@@ -795,17 +954,17 @@ export async function serve() {
   };
   let applied = "";
   let configured = false;
-  const reload = async () => {
+  const reload = async (startup = false) => {
     const config = await readListeners();
     if (!config && configured) throw new Error("listeners.json disappeared; refusing to restore unrestricted legacy access");
     const listeners = config?.listeners ?? [legacy];
     const fingerprint = JSON.stringify(listeners);
     if (applied === fingerprint) return;
-    await reconcile(listeners);
+    await reconcile(listeners, startup);
     configured ||= !!config;
     applied = fingerprint;
   };
-  await reload();
+  await reload(true);
   let reloading = false;
   let lastError = "";
   setInterval(async () => {

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";
@@ -243,6 +244,116 @@ async function resolveProfileDirectory(nameOrEmail: string): Promise<string> {
   return nameOrEmail;
 }
 
+// Free the listening port from stale daemon holders before retrying a failed bind.
+// On Windows the listening socket (created inheritable by Bun.serve) is swept into the
+// detached cliDaemon grandchild via bInheritHandles, so an orphaned cliDaemon from a
+// previous `serve` keeps the port in LISTEN after the old serve dies — the fresh serve
+// then crash-loops on EADDRINUSE. A clean restart releases the port, so a failed bind
+// only happens when such a stale holder exists; killing orphaned daemon holders here is
+// safe because a freshly-starting serve owns no live sessions of its own yet (the user's
+// Chrome tabs persist regardless — the cliDaemon only drives them).
+// Command lines freeStalePort may kill: a previous rech serve, or a cliDaemon started from
+// THIS install's playwright (lib/ or vendor/ under this directory) — never another app's
+// Playwright daemon, which runs from its own node_modules.
+const escapeRegex = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const OWN_CLI_DAEMON = import.meta.dir.split(/[\\/]/).map(escapeRegex).join(String.raw`[\\/]`) + String.raw`[\\/].*cliDaemon\.js`;
+const RECH_SERVE = String.raw`rech(rome)?(\.ts)?"?\s+serve`;
+const STALE_HOLDER_PATTERN = `${OWN_CLI_DAEMON}|${RECH_SERVE}`;
+// A leaked socket (or a wedged serve) accepts connections but never answers. Anything that
+// responds at an address is a live server there — possibly a healthy rech serve — so it is
+// never killed. Both schemes: the holder's TLS setting may differ from this serve's.
+async function answersAt(address: string, port: number): Promise<boolean> {
+  const host = address === "0.0.0.0" || address === "*" ? "127.0.0.1"
+    : address === "::" ? "[::1]"
+    : address.includes(":") ? `[${address}]` : address;
+  const probe = (scheme: string) => fetch(`${scheme}://${host}:${port}/`, {
+    signal: AbortSignal.timeout(1500), tls: { rejectUnauthorized: false },
+  } as RequestInit).then(() => true, () => false);
+  return (await Promise.all([probe("http"), probe("https")])).includes(true);
+}
+
+type PortHolder = { address: string; pid: number; alive: boolean; command: string };
+
+// Listeners on `port` that conflict with binding `host`: the same address, or a wildcard of
+// its family (a wildcard bind conflicts with every address of the family). Never this serve's
+// own sockets, which may already hold other addresses on the same port from this startup.
+function conflictingHolders(port: number, host: string): PortHolder[] {
+  let holders: PortHolder[] = [];
+  if (process.platform === "win32") {
+    const ps = [
+      "$ErrorActionPreference='SilentlyContinue';",
+      `$r=@(Get-NetTCPConnection -LocalPort ${port} -State Listen | ForEach-Object {`,
+      "  $p=Get-CimInstance Win32_Process -Filter \"ProcessId=$($_.OwningProcess)\";",
+      "  [pscustomobject]@{ address=[string]$_.LocalAddress; pid=[int]$_.OwningProcess; alive=[bool]$p; command=[string]$p.CommandLine } });",
+      "ConvertTo-Json -Compress -InputObject $r",
+    ].join(" ");
+    const out = Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true }).stdout?.toString().trim();
+    try { holders = out ? [JSON.parse(out)].flat() : []; } catch { holders = []; }
+  } else {
+    const out = Bun.spawnSync(["sh", "-c", `lsof -nP -iTCP:${port} -sTCP:LISTEN -Fpn 2>/dev/null`]).stdout?.toString() ?? "";
+    let pid = 0;
+    for (const line of out.split("\n")) {
+      if (line.startsWith("p")) pid = Number(line.slice(1));
+      else if (line.startsWith("n") && pid) {
+        const address = line.slice(1).replace(/:\d+$/, "").replace(/^\[(.*)\]$/, "$1");
+        const command = Bun.spawnSync(["ps", "-o", "command=", "-p", String(pid)]).stdout?.toString().trim() ?? "";
+        holders.push({ address, pid, alive: true, command });
+      }
+    }
+  }
+  const v6 = (a: string) => a.includes(":");
+  const wildcard = (a: string) => a === "0.0.0.0" || a === "::" || a === "*";
+  // A `::` listener is dual-stack on Windows and most Linux setups: it conflicts with IPv4 binds too.
+  return holders.filter(h => h.pid !== process.pid && (
+    wildcard(host) ? (h.address === "*" || h.address === "::" || host === "::" || !v6(h.address))
+      : h.address === host || h.address === "*" || h.address === "::" || (h.address === "0.0.0.0" && !v6(host))));
+}
+
+// Free the conflicting address from stale rech holders before retrying a failed bind.
+// Narrow-first: (1) kill each conflicting owner that is a live rech serve / this install's
+// cliDaemon AND doesn't answer at its own address — never an unrelated app, never a healthy
+// server; (2) only if the address is STILL held by owners that are all dead — the
+// inherited-handle case, where the socket lives in a child while netstat attributes it to a
+// now-dead owner — sweep orphaned cliDaemons (Windows). That sweep is the only recovery for
+// the case (the live holder can't be mapped from the port), so it is a logged last resort.
+async function freeStalePort(port: number, host: string): Promise<void> {
+  try {
+    const stale = new RegExp(STALE_HOLDER_PATTERN, process.platform === "win32" ? "i" : "");
+    for (const h of conflictingHolders(port, host)) {
+      if (!h.alive) continue;
+      if (!stale.test(h.command)) { log(`freeStalePort: port ${port} is held by an unrelated process (${h.pid}); not killing it`); continue; }
+      if (await answersAt(h.address, port)) { log(`freeStalePort: ${h.address}:${port} is served by a live process (${h.pid}); not killing it`); continue; }
+      log(`freeStalePort: killing stale rech holder ${h.pid} of ${h.address}:${port}`);
+      try { process.kill(h.pid, "SIGKILL"); } catch {}
+    }
+    await new Promise(r => setTimeout(r, 400));
+    const remaining = conflictingHolders(port, host);
+    if (process.platform === "win32" && remaining.length && remaining.every(h => !h.alive)) {
+      const q = (text: string) => text.replaceAll("'", "''");
+      const ps = [
+        "$ErrorActionPreference='SilentlyContinue';",
+        // A cliDaemon's parent (playwright-cli) exits right after spawning it, so a live one
+        // can't be told from an orphan by ancestry. They are only provably orphaned when no
+        // other rech serve is running: exclude this serve and its own wrappers (oxmgr, cmd).
+        `$self=@(); $x=${process.pid}; while($x){ $self+=$x; $x=(Get-CimInstance Win32_Process -Filter \"ProcessId=$x\").ParentProcessId; if($self -contains $x){ break } };`,
+        `$live=@(Get-CimInstance Win32_Process | Where-Object { $self -notcontains $_.ProcessId -and $_.ProcessId -ne $PID -and $_.CommandLine -match '${q(RECH_SERVE)}' });`,
+        "if($live.Count){ Write-Output (\"freeStalePort: port still held, but another rech serve is running (\" + ($live.ProcessId -join ',') + \"); not sweeping cliDaemons\") }",
+        "else {",
+        // Exclude this PowerShell itself: its own command line contains the pattern.
+        `  $d=Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.CommandLine -match '${q(OWN_CLI_DAEMON)}' };`,
+        "  Write-Output (\"freeStalePort: port still held; killing orphaned cliDaemon holders: \" + ($d.ProcessId -join ','));",
+        "  $d | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }",
+        "}",
+      ].join(" ");
+      const out = Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true }).stdout?.toString().trim();
+      if (out) log(out);
+    }
+  } catch {
+    // best effort — the retry will surface a clear error if the port is still held
+  }
+  await new Promise(r => setTimeout(r, 800)); // let the OS release the socket before retry
+}
+
 // --- Foreground/orphan self-exit ---------------------------------------------------
 // A foreground `rech serve` (run directly by an agent, NOT under oxmgr/pm2) has no
 // process-manager safety net: when the agent that spawned it exits, the OS re-parents
@@ -394,9 +505,13 @@ export async function serve() {
   const legacy: Listener = { name: "legacy", host: listenHost, port, key, profiles: "*" };
   const policies = new Map<string, Listener>();
   const servers = new Map<string, ReturnType<typeof Bun.serve>>();
-  const startServer = (initial: Listener) => Bun.serve({
+  const startServer = (initial: Listener, reusePort = false) => Bun.serve({
     hostname: initial.host,
     port: initial.port,
+    // reusePort is used only as a last-resort fallback (see bindAtStartup below): if an orphaned
+    // holder can't be killed, binding with SO_REUSEADDR keeps serve up (degraded, port-shared)
+    // instead of crash-looping on EADDRINUSE. The normal path binds a clean, exclusive socket.
+    reusePort,
     tls,
     error(err) {
       log(`unhandled error: ${err.message}`);
@@ -477,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 = {
@@ -490,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;
@@ -773,14 +899,47 @@ export async function serve() {
     },
   });
 
+  // A leaked listening-socket handle in an orphaned cliDaemon can keep a port in LISTEN after a
+  // prior serve exits: Bun.serve creates the socket inheritable and Bun.spawn sweeps it into the
+  // detached daemon grandchild via bInheritHandles, so the socket outlives its creating serve.
+  // netstat then attributes the port to the now-dead *creator*, not the live holder, so we can't
+  // map port -> killable PID — freeStalePort kills the orphan by its cliDaemon signature instead.
+  // Startup only: a freshly-starting serve owns no live sessions, so clearing stale holders is
+  // safe. Hot reloads never kill anything (see reconcile). As an absolute last resort, bind with
+  // reusePort so a holder we genuinely can't kill degrades to "up but sharing the port" rather
+  // than a permanent EADDRINUSE crash-loop.
+  const isEaddrInUse = (e: any) => String(e?.code ?? e?.message ?? "").includes("EADDRINUSE");
+  const MAX_BIND_ATTEMPTS = 4;
+  const bindAtStartup = async (listener: Listener) => {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return startServer(listener);
+      } catch (e: any) {
+        if (!isEaddrInUse(e)) throw e;
+        // Something answers at this exact address: a live server (never killed, never port-shared).
+        if (await answersAt(listener.host, listener.port)) {
+          log(`port ${listener.port} is held by a live server that answers requests — not touching it`);
+          throw e;
+        }
+        if (attempt === MAX_BIND_ATTEMPTS) {
+          log(`port ${listener.port} still held after ${attempt - 1} cleanup attempts — binding with reusePort (last resort)`);
+          return startServer(listener, true);
+        }
+        log(`port ${listener.port} in use — clearing stale daemon holders and retrying (attempt ${attempt}/${MAX_BIND_ATTEMPTS - 1})`);
+        await freeStalePort(listener.port, listener.host);
+      }
+    }
+  };
+
   // Stage all new sockets before changing policy. Bind failure leaves existing
-  // listeners and browser sessions intact; never kill a process holding another port.
-  const reconcile = async (listeners: Listener[]) => {
+  // listeners and browser sessions intact; never kill a process holding another port
+  // once serving (stale-holder recovery runs only at startup).
+  const reconcile = async (listeners: Listener[], startup = false) => {
     const staged = new Map<string, ReturnType<typeof Bun.serve>>();
     try {
       for (const listener of listeners) {
         const address = listenerAddress(listener);
-        if (!servers.has(address)) staged.set(address, startServer(listener));
+        if (!servers.has(address)) staged.set(address, startup ? await bindAtStartup(listener) : startServer(listener));
       }
     } catch (error) {
       for (const server of staged.values()) server.stop(true);
@@ -795,17 +954,17 @@ export async function serve() {
   };
   let applied = "";
   let configured = false;
-  const reload = async () => {
+  const reload = async (startup = false) => {
     const config = await readListeners();
     if (!config && configured) throw new Error("listeners.json disappeared; refusing to restore unrestricted legacy access");
     const listeners = config?.listeners ?? [legacy];
     const fingerprint = JSON.stringify(listeners);
     if (applied === fingerprint) return;
-    await reconcile(listeners);
+    await reconcile(listeners, startup);
     configured ||= !!config;
     applied = fingerprint;
   };
-  await reload();
+  await reload(true);
   let reloading = false;
   let lastError = "";
   setInterval(async () => {