rechrome 1.23.3 → 1.24.0

package/package.json

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

package/rech.js

@@ -400,6 +400,59 @@ export function validateChromeProfileSelector(selector: string): void {
   );
 }
 
+export async function resolveGlobalProfile(
+  registry: Record<string, TokenEntry>,
+  chromeProfiles: Record<string, ChromeProfileInfo> | null,
+  selector: string,
+): Promise<{ email: string; entry: TokenEntry }> {
+  const value = selector.trim();
+  if (!value) throw new Error("--profile requires a non-empty value");
+
+  const registryKey = Object.keys(registry).find(k => k.toLowerCase() === value.toLowerCase());
+  if (registryKey) return { email: registryKey, entry: registry[registryKey] };
+
+  if (!chromeProfiles) {
+    throw new Error(
+      `--profile "${value}" does not match any registered email, and Chrome profiles are not accessible. ` +
+      `Run \`rech setup --profile "${value}"\` to register this profile.`,
+    );
+  }
+
+  const profiles = Object.entries(chromeProfiles);
+  let match: [string, ChromeProfileInfo] | null;
+  try {
+    match = resolveChromeProfileSelector(profiles, value);
+  } catch (err) {
+    throw err;
+  }
+
+  if (!match) {
+    throw new Error(
+      `--profile "${value}" does not match any Chrome profile. ` +
+      `See available profiles with \`rech profiles\`.`,
+    );
+  }
+
+  const [dir, info] = match;
+  const email = info.user_name;
+  if (!email) {
+    throw new Error(
+      `Chrome profile "${value}" (folder: ${dir}) has no email associated. ` +
+      `Run \`rech setup --profile "${value}"\` to register it.`,
+    );
+  }
+
+  const entry = registry[email];
+  if (!entry) {
+    throw new Error(
+      `Profile "${email}" (${dir}) is not registered. ` +
+      `Run \`rech setup --profile "${value}"\` to register it.`,
+    );
+  }
+
+  return { email, entry };
+}
+
 async function findChromeUserDataDir(): Promise<string | null> {
   for (const statePath of CHROME_LOCAL_STATE_PATHS()) {
     if (!(await file(statePath).exists())) continue;
@@ -545,7 +598,10 @@ async function callServe(
   // and run() has already done so for its log line. Recomputing here would double those git
   // spawns (and, on Windows, the console-window flashes) on every `rech open`.
   const identity = precomputedIdentity ?? await getClientIdentity();
-  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
+  // A global `--profile` override must win for the session key too: the daemon hashes
+  // identity.profile into the session id, so without this, `rech --profile other open` would
+  // 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, userDataDir, loadExtension })), ...overrideEnv };
   const res = await fetch(`${protocol}://${host}:${port}/run`, {
@@ -588,12 +644,43 @@ export function normalizeCommandArgs(args: string[]): string[] {
   return normalized;
 }
 
-async function run(url: string, args: string[]) {
+// Pull a global `--profile <val>` / `--profile=<val>` out of the leading flags of an argv.
+// Only flags before the first positional (the playwright subcommand) are rech globals — a
+// --profile at/after the subcommand belongs to the forwarded CLI (e.g. playwright-cli's own
+// `open --profile <dir>`, a user-data-dir path) and must pass through untouched. Throws on a
+// missing value; accepts multiple occurrences (last one wins).
+export function extractGlobalProfileArg(args: string[]): { args: string[]; selector?: string } {
+  const rest = [...args];
+  let selector: string | undefined;
+  for (let i = 0; i < rest.length && rest[i].startsWith("-"); i++) {
+    const a = rest[i];
+    if (a === "--profile") {
+      const value = rest[i + 1];
+      if (!value || value.startsWith("--"))
+        throw new Error("--profile requires a value (e.g. --profile you@gmail.com)");
+      selector = value;
+      rest.splice(i, 2);
+      i--;
+      continue;
+    }
+    if (a.startsWith("--profile=")) {
+      const value = a.slice("--profile=".length);
+      if (!value) throw new Error("--profile requires a value (e.g. --profile you@gmail.com)");
+      selector = value;
+      rest.splice(i, 1);
+      i--;
+      continue;
+    }
+  }
+  return { args: rest, selector };
+}
+
+async function run(url: string, args: string[], overrideEnv?: Record<string, string>) {
   // Match the underlying CLI's command names while accepting the short forms humans
   // naturally try. Keep this client-side so old and new serve daemons behave alike.
   args = normalizeCommandArgs(args);
   const { host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
-  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
+  const effectiveProfile = overrideEnv?.["PLAYWRIGHT_MCP_PROFILE_DIRECTORY"] || resolveEffectiveProfile(profileDirectory);
   const displayProfile = effectiveProfile ? await resolveProfileEmail(effectiveProfile) : undefined;
   const identity = await getClientIdentity();
   const profileSuffix = displayProfile ? ` profile:${displayProfile}` : "";
@@ -602,18 +689,19 @@ async function run(url: string, args: string[]) {
   );
 
   const resolvedEnv = await getClientEnv({ extensionId, extensionToken, profileDirectory, userDataDir, loadExtension });
-  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, undefined, identity);
+  const effectiveEnv = { ...resolvedEnv, ...overrideEnv };
+  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, overrideEnv, identity);
 
   const isOpenWithUrl = args[0] === "open" && args.length > 1;
   if (existingSession && isOpenWithUrl) {
-    return run(url, ["goto", ...args.slice(1)]);
+    return run(url, ["goto", ...args.slice(1)], overrideEnv);
   }
 
   if (existingSession)
     console.error(`[rech] session already has open tabs — listing existing tabs instead of opening a new window`);
   if (stderr) {
     if (stderr.includes('Extension connection timeout')) {
-      const hasToken = !!resolvedEnv["PLAYWRIGHT_MCP_EXTENSION_TOKEN"];
+      const hasToken = !!effectiveEnv["PLAYWRIGHT_MCP_EXTENSION_TOKEN"];
       const last = hasToken
         ? `  -x: extension did not connect (reload it at chrome://extensions; then verify its token) -> extension[degraded]`
         : `  -> extension[not installed]  (run: rech setup)`;
@@ -923,12 +1011,51 @@ function findTrayBinary(): string | undefined {
   return Bun.which(`rechrome-tray${ext}`) ?? undefined;
 }
 
+// Verify a PID is actually a rechrome-tray process, not an unrelated process that
+// happened to reuse the pid after the real tray died. POSIX only (`ps` isn't on stock
+// Windows); there we fall back to trusting the liveness probe alone (best-effort).
+function isPidRechromeTray(pid: number): boolean {
+  if (IS_WINDOWS) return true;
+  try {
+    const p = Bun.spawnSync(["ps", "-o", "comm=", "-p", String(pid)], { stdout: "pipe", stderr: "ignore", windowsHide: true });
+    return (p.stdout?.toString() ?? "").trim().includes("rechrome-tray");
+  } catch {
+    return false;
+  }
+}
+
+// PIDs of live rechrome-tray processes (POSIX). Catches untracked trays — ones launched
+// outside `rech tray show` that never touch the pidfile — so a singleton guard can't
+// spawn a second icon on top of them. Empty on Windows (no `ps`), where we rely on the
+// pidfile liveness check alone.
+function listTrayPids(): number[] {
+  if (IS_WINDOWS) return [];
+  try {
+    const p = Bun.spawnSync(["ps", "-axo", "pid=,comm="], { stdout: "pipe", stderr: "ignore", windowsHide: true });
+    const out = p.stdout?.toString() ?? "";
+    const pids: number[] = [];
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(.+)$/);
+      // macOS reports the full launch path in `comm`, so match the basename via a
+      // trailing "/rechrome-tray" or an exact bare name (Linux truncates to the name).
+      if (m && Number(m[1]) !== process.pid && m[2].includes("rechrome-tray")) pids.push(Number(m[1]));
+    }
+    return pids;
+  } catch {
+    return [];
+  }
+}
+
 function isTrayRunning(): boolean {
+  // Any live tray (tracked by the pidfile or not) means "already running" — the pidfile
+  // is a single slot that only ever records the most-recent spawn, so it cannot see
+  // earlier/untracked instances on its own.
+  if (listTrayPids().length > 0) return true;
   try {
     const pid = parseInt(readFileSync(TRAY_PID_FILE, "utf8"), 10);
     if (!Number.isFinite(pid)) return false;
     process.kill(pid, 0); // signal 0 = liveness probe, doesn't actually signal
-    return true;
+    return isPidRechromeTray(pid);
   } catch {
     return false;
   }
@@ -958,7 +1085,12 @@ async function startTray({ quiet = false }: { quiet?: boolean } = {}): Promise<v
 }
 
 function stopTray(): void {
-  if (!isTrayRunning()) { console.log("tray: not running."); return; }
+  // Kill every live tray (tracked or untracked), then drop the pidfile. A singleton
+  // tray should never have more than one instance, but a crashed/overwritten pidfile
+  // can leave orphans the single-slot pidfile no longer points at — reap them too.
+  const pids = listTrayPids();
+  if (pids.length === 0 && !isTrayRunning()) { console.log("tray: not running."); return; }
+  for (const pid of pids) { try { process.kill(pid); } catch {} }
   try { process.kill(parseInt(readFileSync(TRAY_PID_FILE, "utf8"), 10)); } catch {}
   try { unlinkSync(TRAY_PID_FILE); } catch {}
   console.log("tray: stopped. Run `rech tray show` to restore.");
@@ -1623,6 +1755,14 @@ function printHelp(): void {
   console.log(`rechrome (rech) — drive Chrome via Playwright over HTTP
 
 Usage:
+  rech [--profile <email|name|folder>] <playwright-args...>
+                               Run Playwright CLI command with the given registered
+                               Chrome profile. --profile selects the profile by exact
+                               registered email (e.g. you@gmail.com), exact Chrome
+                               profile name, or exact profile folder name. The profile
+                               must already be registered (see \`rech setup\`). Place
+                               --profile before the playwright subcommand. Requires
+                               ${ENV_KEY}.
   rech setup [--profile <email|name|folder>] [--token <tok>]
                                First-time setup: daemon + Chrome extension + config
                                --profile selects the Chrome profile non-interactively.
@@ -1659,13 +1799,14 @@ Environment:
 Examples:
   rech setup
   rech setup --profile you@gmail.com --token <PLAYWRIGHT_MCP_EXTENSION_TOKEN>
+  rech --profile you@gmail.com open https://example.com
   rech eval "() => document.title"
   rech open https://example.com
   rech screenshot`);
 }
 
 if (import.meta.main) {
-  const args = process.argv.slice(2);
+  let args = process.argv.slice(2);
   const cmd = args[0]?.toLowerCase();
 
   if (cmd === "serve") {
@@ -1723,6 +1864,41 @@ if (import.meta.main) {
       printHelp();
       process.exit(1);
     }
+    // --profile: target a registered Chrome profile globally (see extractGlobalProfileArg for
+    // the leading-flags-only rule that protects the forwarded CLI's own --profile).
+    let profileSelector: string | undefined;
+    let overrideEnv: Record<string, string> | undefined;
+    try {
+      const extracted = extractGlobalProfileArg(args);
+      profileSelector = extracted.selector;
+      args = extracted.args;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      envWatcher?.close();
+      process.exit(1);
+    }
+    if (profileSelector !== undefined) {
+      try {
+        const registry = await readTokenRegistry();
+        const cache = await readChromeProfileCache();
+        const resolved = await resolveGlobalProfile(registry, cache, profileSelector);
+        // Use the registry key (email, or the managed profile name) as the profile identity:
+        // the daemon already resolves email/name → profile dir for the default URL-param path,
+        // so this keeps `--profile <email>` on the SAME session as the default path and only
+        // opens a separate session when the profile really differs.
+        overrideEnv = {
+          PLAYWRIGHT_MCP_PROFILE_DIRECTORY: resolved.email,
+          PLAYWRIGHT_MCP_EXTENSION_ID: resolved.entry.extensionId,
+          PLAYWRIGHT_MCP_EXTENSION_TOKEN: resolved.entry.token,
+        };
+        if (resolved.entry.userDataDir) overrideEnv.PLAYWRIGHT_MCP_USER_DATA_DIR = resolved.entry.userDataDir;
+        if (resolved.entry.loadExtension) overrideEnv.PLAYWRIGHT_MCP_LOAD_EXTENSION = resolved.entry.loadExtension;
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        envWatcher?.close();
+        process.exit(1);
+      }
+    }
     // --isolate: ephemeral session isolation, sugar for -s=iso-<random>. For fragile single-shot
     // flows (OAuth/login) that must not share tabs with the worktree's default session. The `iso-`
     // marker lets the daemon reap these throwaway sessions on an idle TTL (see serve.js), so an
@@ -1732,7 +1908,7 @@ if (import.meta.main) {
       args.splice(isolateIdx, 1);
       args.push(`-s=iso-${randomBytes(8).toString("hex")}`);
     }
-    await run(url, args);
+    await run(url, args, overrideEnv);
     envWatcher?.close();
   }
 }

package/rech.ts

@@ -400,6 +400,59 @@ export function validateChromeProfileSelector(selector: string): void {
   );
 }
 
+export async function resolveGlobalProfile(
+  registry: Record<string, TokenEntry>,
+  chromeProfiles: Record<string, ChromeProfileInfo> | null,
+  selector: string,
+): Promise<{ email: string; entry: TokenEntry }> {
+  const value = selector.trim();
+  if (!value) throw new Error("--profile requires a non-empty value");
+
+  const registryKey = Object.keys(registry).find(k => k.toLowerCase() === value.toLowerCase());
+  if (registryKey) return { email: registryKey, entry: registry[registryKey] };
+
+  if (!chromeProfiles) {
+    throw new Error(
+      `--profile "${value}" does not match any registered email, and Chrome profiles are not accessible. ` +
+      `Run \`rech setup --profile "${value}"\` to register this profile.`,
+    );
+  }
+
+  const profiles = Object.entries(chromeProfiles);
+  let match: [string, ChromeProfileInfo] | null;
+  try {
+    match = resolveChromeProfileSelector(profiles, value);
+  } catch (err) {
+    throw err;
+  }
+
+  if (!match) {
+    throw new Error(
+      `--profile "${value}" does not match any Chrome profile. ` +
+      `See available profiles with \`rech profiles\`.`,
+    );
+  }
+
+  const [dir, info] = match;
+  const email = info.user_name;
+  if (!email) {
+    throw new Error(
+      `Chrome profile "${value}" (folder: ${dir}) has no email associated. ` +
+      `Run \`rech setup --profile "${value}"\` to register it.`,
+    );
+  }
+
+  const entry = registry[email];
+  if (!entry) {
+    throw new Error(
+      `Profile "${email}" (${dir}) is not registered. ` +
+      `Run \`rech setup --profile "${value}"\` to register it.`,
+    );
+  }
+
+  return { email, entry };
+}
+
 async function findChromeUserDataDir(): Promise<string | null> {
   for (const statePath of CHROME_LOCAL_STATE_PATHS()) {
     if (!(await file(statePath).exists())) continue;
@@ -545,7 +598,10 @@ async function callServe(
   // and run() has already done so for its log line. Recomputing here would double those git
   // spawns (and, on Windows, the console-window flashes) on every `rech open`.
   const identity = precomputedIdentity ?? await getClientIdentity();
-  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
+  // A global `--profile` override must win for the session key too: the daemon hashes
+  // identity.profile into the session id, so without this, `rech --profile other open` would
+  // 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, userDataDir, loadExtension })), ...overrideEnv };
   const res = await fetch(`${protocol}://${host}:${port}/run`, {
@@ -588,12 +644,43 @@ export function normalizeCommandArgs(args: string[]): string[] {
   return normalized;
 }
 
-async function run(url: string, args: string[]) {
+// Pull a global `--profile <val>` / `--profile=<val>` out of the leading flags of an argv.
+// Only flags before the first positional (the playwright subcommand) are rech globals — a
+// --profile at/after the subcommand belongs to the forwarded CLI (e.g. playwright-cli's own
+// `open --profile <dir>`, a user-data-dir path) and must pass through untouched. Throws on a
+// missing value; accepts multiple occurrences (last one wins).
+export function extractGlobalProfileArg(args: string[]): { args: string[]; selector?: string } {
+  const rest = [...args];
+  let selector: string | undefined;
+  for (let i = 0; i < rest.length && rest[i].startsWith("-"); i++) {
+    const a = rest[i];
+    if (a === "--profile") {
+      const value = rest[i + 1];
+      if (!value || value.startsWith("--"))
+        throw new Error("--profile requires a value (e.g. --profile you@gmail.com)");
+      selector = value;
+      rest.splice(i, 2);
+      i--;
+      continue;
+    }
+    if (a.startsWith("--profile=")) {
+      const value = a.slice("--profile=".length);
+      if (!value) throw new Error("--profile requires a value (e.g. --profile you@gmail.com)");
+      selector = value;
+      rest.splice(i, 1);
+      i--;
+      continue;
+    }
+  }
+  return { args: rest, selector };
+}
+
+async function run(url: string, args: string[], overrideEnv?: Record<string, string>) {
   // Match the underlying CLI's command names while accepting the short forms humans
   // naturally try. Keep this client-side so old and new serve daemons behave alike.
   args = normalizeCommandArgs(args);
   const { host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
-  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
+  const effectiveProfile = overrideEnv?.["PLAYWRIGHT_MCP_PROFILE_DIRECTORY"] || resolveEffectiveProfile(profileDirectory);
   const displayProfile = effectiveProfile ? await resolveProfileEmail(effectiveProfile) : undefined;
   const identity = await getClientIdentity();
   const profileSuffix = displayProfile ? ` profile:${displayProfile}` : "";
@@ -602,18 +689,19 @@ async function run(url: string, args: string[]) {
   );
 
   const resolvedEnv = await getClientEnv({ extensionId, extensionToken, profileDirectory, userDataDir, loadExtension });
-  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, undefined, identity);
+  const effectiveEnv = { ...resolvedEnv, ...overrideEnv };
+  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, overrideEnv, identity);
 
   const isOpenWithUrl = args[0] === "open" && args.length > 1;
   if (existingSession && isOpenWithUrl) {
-    return run(url, ["goto", ...args.slice(1)]);
+    return run(url, ["goto", ...args.slice(1)], overrideEnv);
   }
 
   if (existingSession)
     console.error(`[rech] session already has open tabs — listing existing tabs instead of opening a new window`);
   if (stderr) {
     if (stderr.includes('Extension connection timeout')) {
-      const hasToken = !!resolvedEnv["PLAYWRIGHT_MCP_EXTENSION_TOKEN"];
+      const hasToken = !!effectiveEnv["PLAYWRIGHT_MCP_EXTENSION_TOKEN"];
       const last = hasToken
         ? `  -x: extension did not connect (reload it at chrome://extensions; then verify its token) -> extension[degraded]`
         : `  -> extension[not installed]  (run: rech setup)`;
@@ -923,12 +1011,51 @@ function findTrayBinary(): string | undefined {
   return Bun.which(`rechrome-tray${ext}`) ?? undefined;
 }
 
+// Verify a PID is actually a rechrome-tray process, not an unrelated process that
+// happened to reuse the pid after the real tray died. POSIX only (`ps` isn't on stock
+// Windows); there we fall back to trusting the liveness probe alone (best-effort).
+function isPidRechromeTray(pid: number): boolean {
+  if (IS_WINDOWS) return true;
+  try {
+    const p = Bun.spawnSync(["ps", "-o", "comm=", "-p", String(pid)], { stdout: "pipe", stderr: "ignore", windowsHide: true });
+    return (p.stdout?.toString() ?? "").trim().includes("rechrome-tray");
+  } catch {
+    return false;
+  }
+}
+
+// PIDs of live rechrome-tray processes (POSIX). Catches untracked trays — ones launched
+// outside `rech tray show` that never touch the pidfile — so a singleton guard can't
+// spawn a second icon on top of them. Empty on Windows (no `ps`), where we rely on the
+// pidfile liveness check alone.
+function listTrayPids(): number[] {
+  if (IS_WINDOWS) return [];
+  try {
+    const p = Bun.spawnSync(["ps", "-axo", "pid=,comm="], { stdout: "pipe", stderr: "ignore", windowsHide: true });
+    const out = p.stdout?.toString() ?? "";
+    const pids: number[] = [];
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(.+)$/);
+      // macOS reports the full launch path in `comm`, so match the basename via a
+      // trailing "/rechrome-tray" or an exact bare name (Linux truncates to the name).
+      if (m && Number(m[1]) !== process.pid && m[2].includes("rechrome-tray")) pids.push(Number(m[1]));
+    }
+    return pids;
+  } catch {
+    return [];
+  }
+}
+
 function isTrayRunning(): boolean {
+  // Any live tray (tracked by the pidfile or not) means "already running" — the pidfile
+  // is a single slot that only ever records the most-recent spawn, so it cannot see
+  // earlier/untracked instances on its own.
+  if (listTrayPids().length > 0) return true;
   try {
     const pid = parseInt(readFileSync(TRAY_PID_FILE, "utf8"), 10);
     if (!Number.isFinite(pid)) return false;
     process.kill(pid, 0); // signal 0 = liveness probe, doesn't actually signal
-    return true;
+    return isPidRechromeTray(pid);
   } catch {
     return false;
   }
@@ -958,7 +1085,12 @@ async function startTray({ quiet = false }: { quiet?: boolean } = {}): Promise<v
 }
 
 function stopTray(): void {
-  if (!isTrayRunning()) { console.log("tray: not running."); return; }
+  // Kill every live tray (tracked or untracked), then drop the pidfile. A singleton
+  // tray should never have more than one instance, but a crashed/overwritten pidfile
+  // can leave orphans the single-slot pidfile no longer points at — reap them too.
+  const pids = listTrayPids();
+  if (pids.length === 0 && !isTrayRunning()) { console.log("tray: not running."); return; }
+  for (const pid of pids) { try { process.kill(pid); } catch {} }
   try { process.kill(parseInt(readFileSync(TRAY_PID_FILE, "utf8"), 10)); } catch {}
   try { unlinkSync(TRAY_PID_FILE); } catch {}
   console.log("tray: stopped. Run `rech tray show` to restore.");
@@ -1623,6 +1755,14 @@ function printHelp(): void {
   console.log(`rechrome (rech) — drive Chrome via Playwright over HTTP
 
 Usage:
+  rech [--profile <email|name|folder>] <playwright-args...>
+                               Run Playwright CLI command with the given registered
+                               Chrome profile. --profile selects the profile by exact
+                               registered email (e.g. you@gmail.com), exact Chrome
+                               profile name, or exact profile folder name. The profile
+                               must already be registered (see \`rech setup\`). Place
+                               --profile before the playwright subcommand. Requires
+                               ${ENV_KEY}.
   rech setup [--profile <email|name|folder>] [--token <tok>]
                                First-time setup: daemon + Chrome extension + config
                                --profile selects the Chrome profile non-interactively.
@@ -1659,13 +1799,14 @@ Environment:
 Examples:
   rech setup
   rech setup --profile you@gmail.com --token <PLAYWRIGHT_MCP_EXTENSION_TOKEN>
+  rech --profile you@gmail.com open https://example.com
   rech eval "() => document.title"
   rech open https://example.com
   rech screenshot`);
 }
 
 if (import.meta.main) {
-  const args = process.argv.slice(2);
+  let args = process.argv.slice(2);
   const cmd = args[0]?.toLowerCase();
 
   if (cmd === "serve") {
@@ -1723,6 +1864,41 @@ if (import.meta.main) {
       printHelp();
       process.exit(1);
     }
+    // --profile: target a registered Chrome profile globally (see extractGlobalProfileArg for
+    // the leading-flags-only rule that protects the forwarded CLI's own --profile).
+    let profileSelector: string | undefined;
+    let overrideEnv: Record<string, string> | undefined;
+    try {
+      const extracted = extractGlobalProfileArg(args);
+      profileSelector = extracted.selector;
+      args = extracted.args;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      envWatcher?.close();
+      process.exit(1);
+    }
+    if (profileSelector !== undefined) {
+      try {
+        const registry = await readTokenRegistry();
+        const cache = await readChromeProfileCache();
+        const resolved = await resolveGlobalProfile(registry, cache, profileSelector);
+        // Use the registry key (email, or the managed profile name) as the profile identity:
+        // the daemon already resolves email/name → profile dir for the default URL-param path,
+        // so this keeps `--profile <email>` on the SAME session as the default path and only
+        // opens a separate session when the profile really differs.
+        overrideEnv = {
+          PLAYWRIGHT_MCP_PROFILE_DIRECTORY: resolved.email,
+          PLAYWRIGHT_MCP_EXTENSION_ID: resolved.entry.extensionId,
+          PLAYWRIGHT_MCP_EXTENSION_TOKEN: resolved.entry.token,
+        };
+        if (resolved.entry.userDataDir) overrideEnv.PLAYWRIGHT_MCP_USER_DATA_DIR = resolved.entry.userDataDir;
+        if (resolved.entry.loadExtension) overrideEnv.PLAYWRIGHT_MCP_LOAD_EXTENSION = resolved.entry.loadExtension;
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        envWatcher?.close();
+        process.exit(1);
+      }
+    }
     // --isolate: ephemeral session isolation, sugar for -s=iso-<random>. For fragile single-shot
     // flows (OAuth/login) that must not share tabs with the worktree's default session. The `iso-`
     // marker lets the daemon reap these throwaway sessions on an idle TTL (see serve.ts), so an
@@ -1732,7 +1908,7 @@ if (import.meta.main) {
       args.splice(isolateIdx, 1);
       args.push(`-s=iso-${randomBytes(8).toString("hex")}`);
     }
-    await run(url, args);
+    await run(url, args, overrideEnv);
     envWatcher?.close();
   }
 }

package/serve.js

@@ -84,6 +84,36 @@ function noteSession(sess: string, now: number): void {
   }
 }
 
+/**
+ * Did this returned command actually prove the relay is answering?
+ *
+ * The watchdog above clears its streaks whenever a command returns instead of timing out,
+ * on the reasoning that a reply — even a failing one — means the relay is alive. That holds
+ * for errors produced BY the browser, but not for ones the CLI raises locally before it ever
+ * opens a connection. `Browser '<id>' is not open` is the important case: it is emitted the
+ * instant a session is missing, which is precisely the state the per-session heal CREATES by
+ * closing a wedged session. So the sequence was:
+ *
+ *   timeout, timeout      → per-session heal closes the session
+ *   "browser is not open" → returned fast, counted as success, globalStreak reset to 0
+ *   timeout, timeout      → heal again … forever
+ *
+ * WATCHDOG_TIMEOUTS (3) could therefore never be reached on a genuinely dead relay, and the
+ * daemon-level restart that exists to fix exactly that never fired — leaving `oxmgr restart
+ * rechrome` by hand as the only cure (observed 2026-08-05: three manual restarts in one
+ * session, each buying only a handful of commands).
+ *
+ * Returning false here does NOT count against the relay; it just refuses to forgive the
+ * timeouts already recorded.
+ */
+export function provesRelayAlive(o: { stdout: string; stderr: string }): boolean {
+  const out = `${o.stdout ?? ""}\n${o.stderr ?? ""}`;
+  // Both spellings the CLI uses for "no such session" (cli-client/output.js).
+  if (/Browser '[^']*' is not open/i.test(out)) return false;
+  if (/is not open, please run open first/i.test(out)) return false;
+  return true;
+}
+
 export function inferSilentExtensionFailure(options: {
   status: number;
   stdout: string;
@@ -248,6 +278,27 @@ async function freeStalePort(port: number): Promise<void> {
   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
+// the orphan to init (ppid 1) and it lives forever — the resource leak behind
+// PERFORMANCE-EVENT.md. The managed daemon (oxmgr `--restart always`) keeps the
+// process as its own child, so its ppid is stable and non-1 and it is never flagged.
+// Once a serve is orphaned AND has had no real /run for the idle timeout, it exits so
+// the leak self-heals. /ping is deliberately NOT activity (the tray polls it every 2s
+// and would otherwise keep an orphan alive forever).
+const ORPHAN_POLL_INTERVAL_MS = 15_000;
+const ORPHAN_IDLE_EXIT_MS = Number(process.env.RECH_SERVE_IDLE_TIMEOUT_MS) || 5 * 60_000;
+
+// Pure decision predicate (testable). idleTimeoutMs <= 0 disables orphan self-exit.
+export function shouldExitOrphanedServe(opts: {
+  orphaned: boolean;
+  idleMs: number;
+  idleTimeoutMs: number;
+}): boolean {
+  return opts.idleTimeoutMs > 0 && opts.orphaned && opts.idleMs >= opts.idleTimeoutMs;
+}
+
 export async function serve() {
   const url = await getOrCreateUrl();
   const { key, port } = parseUrl(url);
@@ -255,6 +306,21 @@ export async function serve() {
   const workDir = join(RECH_DIR, "output");
   mkdirSync(workDir, { recursive: true });
 
+  // Foreground/orphan self-exit: a serve whose parent has been re-parented to init
+  // (ppid 1) is a leaked foreground serve. Poll for that, track the last real /run,
+  // and exit once orphaned + idle so an agent that died without shutting us down
+  // doesn't leave a daemon behind.
+  let orphaned = false;
+  let idleSince = Date.now();
+  const markActivity = () => { idleSince = Date.now(); };
+  setInterval(() => {
+    if (process.ppid === 1) orphaned = true;
+    if (shouldExitOrphanedServe({ orphaned, idleMs: Date.now() - idleSince, idleTimeoutMs: ORPHAN_IDLE_EXIT_MS })) {
+      log(`orphaned foreground serve idle ${Math.round((Date.now() - idleSince) / 1000)}s — exiting (spawning agent is gone)`);
+      process.exit(0);
+    }
+  }, ORPHAN_POLL_INTERVAL_MS);
+
   // Reap idle --isolate sessions so single-shot OAuth/login drives don't leak browser contexts.
   adoptOrphanedIsoSessions();
   setInterval(() => {
@@ -335,6 +401,7 @@ export async function serve() {
       if (reqUrl.pathname !== "/run") return new Response("rech server\n");
       const denied = authCheck(req, key);
       if (denied) return denied;
+      markActivity(); // a real command: this serve is not idle
 
       const body = await req.json();
       let args: string[];
@@ -543,8 +610,10 @@ export async function serve() {
 
       log(`exit: ${status}${stdout.trim() ? ` | ${stdout.trim().slice(0, 200)}` : ""}`);
 
-      // Relay self-heal (see notes at SESSION_CLOSE_TIMEOUTS): a command that RETURNS — even
-      // non-zero — proves the relay answered, so clear the streaks; a TIMEOUT means it didn't.
+      // Relay self-heal (see notes at SESSION_CLOSE_TIMEOUTS). A command that RETURNS usually
+      // proves the relay answered — but NOT when the CLI short-circuited locally without ever
+      // reaching it (provesRelayAlive). Treating those as success reset the global streak on
+      // every per-session heal, so WATCHDOG_TIMEOUTS could never be reached. See that helper.
       if (timedOut) {
         consecutiveTimeouts++;
         const streak = (sessionTimeouts.get(namespacedSession) ?? 0) + 1;
@@ -565,9 +634,14 @@ export async function serve() {
           log(`relay wedged: ${consecutiveTimeouts} consecutive timeouts, no success between — exiting for oxmgr (--restart always) to respawn clean; extension WS will reconnect (Chrome untouched)`);
           setTimeout(() => process.exit(1), 100); // brief delay to flush this response
         }
-      } else {
+      } else if (provesRelayAlive({ stdout, stderr })) {
         consecutiveTimeouts = 0;
         sessionTimeouts.delete(namespacedSession);
+      } else {
+        // Returned, but proved nothing about the relay (local short-circuit). Leave BOTH
+        // streaks untouched: not a timeout, so don't punish it — but don't let it forgive
+        // the timeouts that came before, which is the bug this branch exists to fix.
+        log(`inconclusive: session=${namespacedSession} did not reach the relay — streaks kept (globalStreak=${consecutiveTimeouts})`);
       }
 
       // Detect files mentioned in output

package/serve.ts

@@ -84,6 +84,36 @@ function noteSession(sess: string, now: number): void {
   }
 }
 
+/**
+ * Did this returned command actually prove the relay is answering?
+ *
+ * The watchdog above clears its streaks whenever a command returns instead of timing out,
+ * on the reasoning that a reply — even a failing one — means the relay is alive. That holds
+ * for errors produced BY the browser, but not for ones the CLI raises locally before it ever
+ * opens a connection. `Browser '<id>' is not open` is the important case: it is emitted the
+ * instant a session is missing, which is precisely the state the per-session heal CREATES by
+ * closing a wedged session. So the sequence was:
+ *
+ *   timeout, timeout      → per-session heal closes the session
+ *   "browser is not open" → returned fast, counted as success, globalStreak reset to 0
+ *   timeout, timeout      → heal again … forever
+ *
+ * WATCHDOG_TIMEOUTS (3) could therefore never be reached on a genuinely dead relay, and the
+ * daemon-level restart that exists to fix exactly that never fired — leaving `oxmgr restart
+ * rechrome` by hand as the only cure (observed 2026-08-05: three manual restarts in one
+ * session, each buying only a handful of commands).
+ *
+ * Returning false here does NOT count against the relay; it just refuses to forgive the
+ * timeouts already recorded.
+ */
+export function provesRelayAlive(o: { stdout: string; stderr: string }): boolean {
+  const out = `${o.stdout ?? ""}\n${o.stderr ?? ""}`;
+  // Both spellings the CLI uses for "no such session" (cli-client/output.ts).
+  if (/Browser '[^']*' is not open/i.test(out)) return false;
+  if (/is not open, please run open first/i.test(out)) return false;
+  return true;
+}
+
 export function inferSilentExtensionFailure(options: {
   status: number;
   stdout: string;
@@ -248,6 +278,27 @@ async function freeStalePort(port: number): Promise<void> {
   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
+// the orphan to init (ppid 1) and it lives forever — the resource leak behind
+// PERFORMANCE-EVENT.md. The managed daemon (oxmgr `--restart always`) keeps the
+// process as its own child, so its ppid is stable and non-1 and it is never flagged.
+// Once a serve is orphaned AND has had no real /run for the idle timeout, it exits so
+// the leak self-heals. /ping is deliberately NOT activity (the tray polls it every 2s
+// and would otherwise keep an orphan alive forever).
+const ORPHAN_POLL_INTERVAL_MS = 15_000;
+const ORPHAN_IDLE_EXIT_MS = Number(process.env.RECH_SERVE_IDLE_TIMEOUT_MS) || 5 * 60_000;
+
+// Pure decision predicate (testable). idleTimeoutMs <= 0 disables orphan self-exit.
+export function shouldExitOrphanedServe(opts: {
+  orphaned: boolean;
+  idleMs: number;
+  idleTimeoutMs: number;
+}): boolean {
+  return opts.idleTimeoutMs > 0 && opts.orphaned && opts.idleMs >= opts.idleTimeoutMs;
+}
+
 export async function serve() {
   const url = await getOrCreateUrl();
   const { key, port } = parseUrl(url);
@@ -255,6 +306,21 @@ export async function serve() {
   const workDir = join(RECH_DIR, "output");
   mkdirSync(workDir, { recursive: true });
 
+  // Foreground/orphan self-exit: a serve whose parent has been re-parented to init
+  // (ppid 1) is a leaked foreground serve. Poll for that, track the last real /run,
+  // and exit once orphaned + idle so an agent that died without shutting us down
+  // doesn't leave a daemon behind.
+  let orphaned = false;
+  let idleSince = Date.now();
+  const markActivity = () => { idleSince = Date.now(); };
+  setInterval(() => {
+    if (process.ppid === 1) orphaned = true;
+    if (shouldExitOrphanedServe({ orphaned, idleMs: Date.now() - idleSince, idleTimeoutMs: ORPHAN_IDLE_EXIT_MS })) {
+      log(`orphaned foreground serve idle ${Math.round((Date.now() - idleSince) / 1000)}s — exiting (spawning agent is gone)`);
+      process.exit(0);
+    }
+  }, ORPHAN_POLL_INTERVAL_MS);
+
   // Reap idle --isolate sessions so single-shot OAuth/login drives don't leak browser contexts.
   adoptOrphanedIsoSessions();
   setInterval(() => {
@@ -335,6 +401,7 @@ export async function serve() {
       if (reqUrl.pathname !== "/run") return new Response("rech server\n");
       const denied = authCheck(req, key);
       if (denied) return denied;
+      markActivity(); // a real command: this serve is not idle
 
       const body = await req.json();
       let args: string[];
@@ -543,8 +610,10 @@ export async function serve() {
 
       log(`exit: ${status}${stdout.trim() ? ` | ${stdout.trim().slice(0, 200)}` : ""}`);
 
-      // Relay self-heal (see notes at SESSION_CLOSE_TIMEOUTS): a command that RETURNS — even
-      // non-zero — proves the relay answered, so clear the streaks; a TIMEOUT means it didn't.
+      // Relay self-heal (see notes at SESSION_CLOSE_TIMEOUTS). A command that RETURNS usually
+      // proves the relay answered — but NOT when the CLI short-circuited locally without ever
+      // reaching it (provesRelayAlive). Treating those as success reset the global streak on
+      // every per-session heal, so WATCHDOG_TIMEOUTS could never be reached. See that helper.
       if (timedOut) {
         consecutiveTimeouts++;
         const streak = (sessionTimeouts.get(namespacedSession) ?? 0) + 1;
@@ -565,9 +634,14 @@ export async function serve() {
           log(`relay wedged: ${consecutiveTimeouts} consecutive timeouts, no success between — exiting for oxmgr (--restart always) to respawn clean; extension WS will reconnect (Chrome untouched)`);
           setTimeout(() => process.exit(1), 100); // brief delay to flush this response
         }
-      } else {
+      } else if (provesRelayAlive({ stdout, stderr })) {
         consecutiveTimeouts = 0;
         sessionTimeouts.delete(namespacedSession);
+      } else {
+        // Returned, but proved nothing about the relay (local short-circuit). Leave BOTH
+        // streaks untouched: not a timeout, so don't punish it — but don't let it forgive
+        // the timeouts that came before, which is the bug this branch exists to fix.
+        log(`inconclusive: session=${namespacedSession} did not reach the relay — streaks kept (globalStreak=${consecutiveTimeouts})`);
       }
 
       // Detect files mentioned in output