rechrome 1.20.0 → 1.21.0

package/package.json

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

package/rech.js

@@ -194,48 +194,116 @@ export function authCheck(req: Request, key: string): Response | null {
   return null;
 }
 
-async function getClientIdentity(): Promise<{ gitUrl?: string; hostname?: string; cwd?: string }> {
-  const cwd = process.cwd();
+function realpathSafe(p: string): string {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+async function gitOutput(args: string[], cwd: string): Promise<string | null> {
   try {
-    const remoteProc = Bun.spawn(["git", "remote", "get-url", "origin"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    const remoteUrl = (await new Response(remoteProc.stdout).text()).trim();
-    await remoteProc.exited;
+    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+    const out = (await new Response(proc.stdout).text()).trim();
+    await proc.exited;
+    return out || null;
+  } catch {
+    return null;
+  }
+}
 
-    const branchProc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    const branch = (await new Response(branchProc.stdout).text()).trim();
-    await branchProc.exited;
-
-    if (remoteUrl) {
-      let gitUrl: string;
-      const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
-      const httpsMatch = remoteUrl.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
-      if (sshMatch) {
-        gitUrl = `https://${sshMatch[1]}/${sshMatch[2]}`;
-      } else if (httpsMatch) {
-        gitUrl = `https://${httpsMatch[1]}/${httpsMatch[2]}`;
-      } else {
-        gitUrl = remoteUrl.replace(/\.git$/, "");
-      }
-      if (branch) gitUrl += `/tree/${branch}`;
-      // Strip any embedded credentials from the URL
-      try {
-        const u = new URL(gitUrl);
-        u.username = "";
-        u.password = "";
-        gitUrl = u.toString();
-      } catch {}
-      return { gitUrl };
+// Normalize a git remote URL to "host/owner/repo" — no scheme, no .git, no credentials.
+export function normalizeRemote(remoteUrl: string): string {
+  const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+  const httpsMatch = remoteUrl.match(/^https?:\/\/(?:[^@/]+@)?([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
+  if (httpsMatch) return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  return remoteUrl.replace(/^[^/]*:\/\//, "").replace(/^[^@]*@/, "").replace(/\.git$/, "");
+}
+
+// Derive the session bucket KEY (what the server hashes) and a human LABEL (logs / tab group)
+// from already-gathered git facts. KEY and LABEL are deliberately decoupled: the key is keyed
+// on the *worktree root path* for predictability (a human can tell which browser they drive),
+// while the label renders a pretty <remote>#<basename>@<branch> for display only.
+//   - mode "worktree" (default): key = realpath(worktree root). Stable across `cd` within the
+//     project, distinct per worktree (no same-branch collisions), survives `git checkout`
+//     (no mutable-branch surprise), and has no branch so detached HEAD doesn't degrade it.
+//   - mode "branch": legacy opt-in — key = <remote>/tree/<branch> (the old behavior).
+//   - mode "cwd": key = realpath(cwd).
+// Pass realpath'd `cwd` and `root`.
+export function deriveIdentity(opts: {
+  mode: string;
+  cwd: string;
+  host: string;
+  root?: string | null;   // worktree root (already realpath'd), null when not in git
+  remote?: string | null; // normalized host/owner/repo
+  branch?: string | null; // branch name, or short SHA when detached
+}): { key: string; label: string } {
+  const { mode, cwd, host } = opts;
+  const root = opts.root || null;
+  const remote = opts.remote || null;
+  const branch = opts.branch || null;
+
+  let key: string;
+  if (mode === "branch") {
+    key = remote ? `https://${remote}${branch ? `/tree/${branch}` : ""}` : `${host}:${cwd}`;
+  } else if (mode === "cwd") {
+    key = `cwd:${cwd}`;
+  } else {
+    key = `worktree:${root || cwd}`;
+  }
+
+  let label: string;
+  if (root) {
+    label = `${remote ? `${remote}#` : ""}${basename(root)}${branch ? `@${branch}` : ""}`;
+  } else if (remote) {
+    label = `${remote}${branch ? `/tree/${branch}` : ""}`;
+  } else {
+    label = `${host}:${cwd}`;
+  }
+  return { key, label };
+}
+
+async function getClientIdentity(): Promise<{ key: string; label: string; profile?: string }> {
+  const cwd = realpathSafe(process.cwd());
+  const mode = (process.env.RECH_IDENTITY || "worktree").toLowerCase();
+  let root: string | null = null;
+  let remote: string | null = null;
+  let branch: string | null = null;
+
+  const top = await gitOutput(["rev-parse", "--show-toplevel"], cwd);
+  if (top) {
+    // Roll a submodule cwd up to the outermost superproject working tree, so submodule work
+    // shares the parent worktree's browser session (monorepo-friendly). Bounded loop guards
+    // against pathological nesting.
+    let superCwd = top;
+    for (let i = 0; i < 16; i++) {
+      const sup = await gitOutput(["rev-parse", "--show-superproject-working-tree"], superCwd);
+      if (!sup) break;
+      superCwd = sup;
     }
-  } catch {}
-  return { hostname: hostname(), cwd };
+    root = realpathSafe(superCwd);
+    branch = await gitOutput(["rev-parse", "--abbrev-ref", "HEAD"], root);
+    if (!branch || branch === "HEAD")
+      branch = await gitOutput(["rev-parse", "--short", "HEAD"], root); // detached HEAD
+    const remoteUrl = await gitOutput(["remote", "get-url", "origin"], root);
+    if (remoteUrl) remote = normalizeRemote(remoteUrl);
+  }
+
+  return deriveIdentity({ mode, cwd, host: hostname(), root, remote, branch });
+}
+
+// Profile precedence: an explicit `?profile=` in RECHROME_URL is authoritative; the
+// PLAYWRIGHT_MCP_PROFILE_DIRECTORY shell env is the fallback. When both are set and differ,
+// warn once — a silent mismatch here is how an OAuth/login flow can target the WRONG account.
+let _profileMismatchWarned = false;
+function resolveEffectiveProfile(urlProfile?: string): string | undefined {
+  const envProfile = process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
+  if (urlProfile && envProfile && urlProfile !== envProfile && !_profileMismatchWarned) {
+    _profileMismatchWarned = true;
+    console.error(
+      `[rech] warning: profile mismatch — RECHROME_URL profile="${urlProfile}" wins over ` +
+      `PLAYWRIGHT_MCP_PROFILE_DIRECTORY="${envProfile}". Unset the env var to silence this.`,
+    );
+  }
+  return urlProfile || envProfile;
 }
 
 async function getClientEnv(urlExtras?: { extensionId?: string; extensionToken?: string; profileDirectory?: string; userDataDir?: string; loadExtension?: string }): Promise<Record<string, string>> {
@@ -429,8 +497,8 @@ async function callServe(
 ): Promise<{ status: number; stdout: string; stderr: string; files?: string[]; existingSession?: boolean }> {
   const { key, host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
   const identity = await getClientIdentity();
-  const effectiveProfile = profileDirectory || process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
-  if (effectiveProfile) (identity as any).profile = effectiveProfile;
+  const effectiveProfile = 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`, {
     method: "POST",
@@ -468,12 +536,12 @@ async function callServe(
 
 async function run(url: string, args: string[]) {
   const { host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
-  const effectiveProfile = profileDirectory || process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
+  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
   const displayProfile = effectiveProfile ? await resolveProfileEmail(effectiveProfile) : undefined;
   const identity = await getClientIdentity();
   const profileSuffix = displayProfile ? ` profile:${displayProfile}` : "";
   console.error(
-    `[rech] connecting to ${host}:${port} (identity: ${identity.gitUrl || `${identity.hostname}:${identity.cwd}`}${profileSuffix})`,
+    `[rech] connecting to ${host}:${port} (identity: ${identity.label}${profileSuffix})`,
   );
 
   const resolvedEnv = await getClientEnv({ extensionId, extensionToken, profileDirectory, userDataDir, loadExtension });
@@ -1396,10 +1464,16 @@ Usage:
   rech serve                   Start the serve server manually (foreground)
   rech profiles                List Chrome profiles
   rech <playwright-args...>    Run Playwright CLI command (requires ${ENV_KEY})
+  rech --isolate <args...>     Run in a throwaway session (sugar for -s=<random>) so a
+                               fragile single-shot flow (OAuth/login) never shares tabs
+                               with the worktree's default session
 
 Environment:
   ${ENV_KEY}   Server URL set by \`rech setup\`
   RECH_TOKEN     Auth token for \`rech setup\` (same as --token)
+  RECH_IDENTITY  Session bucket mode: worktree (default) | branch | cwd. The session a
+                 client reuses is keyed on the worktree root path; \`branch\` restores the
+                 old <remote>/tree/<branch> keying, \`cwd\` keys on the exact directory
 
 Examples:
   rech setup
@@ -1468,6 +1542,15 @@ if (import.meta.main) {
       printHelp();
       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
+    // OAuth drive can't leak an orphaned browser context.
+    const isolateIdx = args.findIndex((a) => a === "--isolate" || a === "--isolated");
+    if (isolateIdx !== -1) {
+      args.splice(isolateIdx, 1);
+      args.push(`-s=iso-${randomBytes(8).toString("hex")}`);
+    }
     await run(url, args);
     envWatcher?.close();
   }

package/rech.ts

@@ -194,48 +194,116 @@ export function authCheck(req: Request, key: string): Response | null {
   return null;
 }
 
-async function getClientIdentity(): Promise<{ gitUrl?: string; hostname?: string; cwd?: string }> {
-  const cwd = process.cwd();
+function realpathSafe(p: string): string {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+async function gitOutput(args: string[], cwd: string): Promise<string | null> {
   try {
-    const remoteProc = Bun.spawn(["git", "remote", "get-url", "origin"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    const remoteUrl = (await new Response(remoteProc.stdout).text()).trim();
-    await remoteProc.exited;
+    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+    const out = (await new Response(proc.stdout).text()).trim();
+    await proc.exited;
+    return out || null;
+  } catch {
+    return null;
+  }
+}
 
-    const branchProc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    const branch = (await new Response(branchProc.stdout).text()).trim();
-    await branchProc.exited;
-
-    if (remoteUrl) {
-      let gitUrl: string;
-      const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
-      const httpsMatch = remoteUrl.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
-      if (sshMatch) {
-        gitUrl = `https://${sshMatch[1]}/${sshMatch[2]}`;
-      } else if (httpsMatch) {
-        gitUrl = `https://${httpsMatch[1]}/${httpsMatch[2]}`;
-      } else {
-        gitUrl = remoteUrl.replace(/\.git$/, "");
-      }
-      if (branch) gitUrl += `/tree/${branch}`;
-      // Strip any embedded credentials from the URL
-      try {
-        const u = new URL(gitUrl);
-        u.username = "";
-        u.password = "";
-        gitUrl = u.toString();
-      } catch {}
-      return { gitUrl };
+// Normalize a git remote URL to "host/owner/repo" — no scheme, no .git, no credentials.
+export function normalizeRemote(remoteUrl: string): string {
+  const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+  const httpsMatch = remoteUrl.match(/^https?:\/\/(?:[^@/]+@)?([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
+  if (httpsMatch) return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  return remoteUrl.replace(/^[^/]*:\/\//, "").replace(/^[^@]*@/, "").replace(/\.git$/, "");
+}
+
+// Derive the session bucket KEY (what the server hashes) and a human LABEL (logs / tab group)
+// from already-gathered git facts. KEY and LABEL are deliberately decoupled: the key is keyed
+// on the *worktree root path* for predictability (a human can tell which browser they drive),
+// while the label renders a pretty <remote>#<basename>@<branch> for display only.
+//   - mode "worktree" (default): key = realpath(worktree root). Stable across `cd` within the
+//     project, distinct per worktree (no same-branch collisions), survives `git checkout`
+//     (no mutable-branch surprise), and has no branch so detached HEAD doesn't degrade it.
+//   - mode "branch": legacy opt-in — key = <remote>/tree/<branch> (the old behavior).
+//   - mode "cwd": key = realpath(cwd).
+// Pass realpath'd `cwd` and `root`.
+export function deriveIdentity(opts: {
+  mode: string;
+  cwd: string;
+  host: string;
+  root?: string | null;   // worktree root (already realpath'd), null when not in git
+  remote?: string | null; // normalized host/owner/repo
+  branch?: string | null; // branch name, or short SHA when detached
+}): { key: string; label: string } {
+  const { mode, cwd, host } = opts;
+  const root = opts.root || null;
+  const remote = opts.remote || null;
+  const branch = opts.branch || null;
+
+  let key: string;
+  if (mode === "branch") {
+    key = remote ? `https://${remote}${branch ? `/tree/${branch}` : ""}` : `${host}:${cwd}`;
+  } else if (mode === "cwd") {
+    key = `cwd:${cwd}`;
+  } else {
+    key = `worktree:${root || cwd}`;
+  }
+
+  let label: string;
+  if (root) {
+    label = `${remote ? `${remote}#` : ""}${basename(root)}${branch ? `@${branch}` : ""}`;
+  } else if (remote) {
+    label = `${remote}${branch ? `/tree/${branch}` : ""}`;
+  } else {
+    label = `${host}:${cwd}`;
+  }
+  return { key, label };
+}
+
+async function getClientIdentity(): Promise<{ key: string; label: string; profile?: string }> {
+  const cwd = realpathSafe(process.cwd());
+  const mode = (process.env.RECH_IDENTITY || "worktree").toLowerCase();
+  let root: string | null = null;
+  let remote: string | null = null;
+  let branch: string | null = null;
+
+  const top = await gitOutput(["rev-parse", "--show-toplevel"], cwd);
+  if (top) {
+    // Roll a submodule cwd up to the outermost superproject working tree, so submodule work
+    // shares the parent worktree's browser session (monorepo-friendly). Bounded loop guards
+    // against pathological nesting.
+    let superCwd = top;
+    for (let i = 0; i < 16; i++) {
+      const sup = await gitOutput(["rev-parse", "--show-superproject-working-tree"], superCwd);
+      if (!sup) break;
+      superCwd = sup;
     }
-  } catch {}
-  return { hostname: hostname(), cwd };
+    root = realpathSafe(superCwd);
+    branch = await gitOutput(["rev-parse", "--abbrev-ref", "HEAD"], root);
+    if (!branch || branch === "HEAD")
+      branch = await gitOutput(["rev-parse", "--short", "HEAD"], root); // detached HEAD
+    const remoteUrl = await gitOutput(["remote", "get-url", "origin"], root);
+    if (remoteUrl) remote = normalizeRemote(remoteUrl);
+  }
+
+  return deriveIdentity({ mode, cwd, host: hostname(), root, remote, branch });
+}
+
+// Profile precedence: an explicit `?profile=` in RECHROME_URL is authoritative; the
+// PLAYWRIGHT_MCP_PROFILE_DIRECTORY shell env is the fallback. When both are set and differ,
+// warn once — a silent mismatch here is how an OAuth/login flow can target the WRONG account.
+let _profileMismatchWarned = false;
+function resolveEffectiveProfile(urlProfile?: string): string | undefined {
+  const envProfile = process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
+  if (urlProfile && envProfile && urlProfile !== envProfile && !_profileMismatchWarned) {
+    _profileMismatchWarned = true;
+    console.error(
+      `[rech] warning: profile mismatch — RECHROME_URL profile="${urlProfile}" wins over ` +
+      `PLAYWRIGHT_MCP_PROFILE_DIRECTORY="${envProfile}". Unset the env var to silence this.`,
+    );
+  }
+  return urlProfile || envProfile;
 }
 
 async function getClientEnv(urlExtras?: { extensionId?: string; extensionToken?: string; profileDirectory?: string; userDataDir?: string; loadExtension?: string }): Promise<Record<string, string>> {
@@ -429,8 +497,8 @@ async function callServe(
 ): Promise<{ status: number; stdout: string; stderr: string; files?: string[]; existingSession?: boolean }> {
   const { key, host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
   const identity = await getClientIdentity();
-  const effectiveProfile = profileDirectory || process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
-  if (effectiveProfile) (identity as any).profile = effectiveProfile;
+  const effectiveProfile = 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`, {
     method: "POST",
@@ -468,12 +536,12 @@ async function callServe(
 
 async function run(url: string, args: string[]) {
   const { host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
-  const effectiveProfile = profileDirectory || process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY;
+  const effectiveProfile = resolveEffectiveProfile(profileDirectory);
   const displayProfile = effectiveProfile ? await resolveProfileEmail(effectiveProfile) : undefined;
   const identity = await getClientIdentity();
   const profileSuffix = displayProfile ? ` profile:${displayProfile}` : "";
   console.error(
-    `[rech] connecting to ${host}:${port} (identity: ${identity.gitUrl || `${identity.hostname}:${identity.cwd}`}${profileSuffix})`,
+    `[rech] connecting to ${host}:${port} (identity: ${identity.label}${profileSuffix})`,
   );
 
   const resolvedEnv = await getClientEnv({ extensionId, extensionToken, profileDirectory, userDataDir, loadExtension });
@@ -1396,10 +1464,16 @@ Usage:
   rech serve                   Start the serve server manually (foreground)
   rech profiles                List Chrome profiles
   rech <playwright-args...>    Run Playwright CLI command (requires ${ENV_KEY})
+  rech --isolate <args...>     Run in a throwaway session (sugar for -s=<random>) so a
+                               fragile single-shot flow (OAuth/login) never shares tabs
+                               with the worktree's default session
 
 Environment:
   ${ENV_KEY}   Server URL set by \`rech setup\`
   RECH_TOKEN     Auth token for \`rech setup\` (same as --token)
+  RECH_IDENTITY  Session bucket mode: worktree (default) | branch | cwd. The session a
+                 client reuses is keyed on the worktree root path; \`branch\` restores the
+                 old <remote>/tree/<branch> keying, \`cwd\` keys on the exact directory
 
 Examples:
   rech setup
@@ -1468,6 +1542,15 @@ if (import.meta.main) {
       printHelp();
       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
+    // OAuth drive can't leak an orphaned browser context.
+    const isolateIdx = args.findIndex((a) => a === "--isolate" || a === "--isolated");
+    if (isolateIdx !== -1) {
+      args.splice(isolateIdx, 1);
+      args.push(`-s=iso-${randomBytes(8).toString("hex")}`);
+    }
     await run(url, args);
     envWatcher?.close();
   }

package/serve.js

@@ -1,6 +1,6 @@
 import { file } from "bun";
 import { createHash, X509Certificate } from "crypto";
-import { mkdirSync, unlinkSync, accessSync, constants as fsConstants } from "fs";
+import { mkdirSync, unlinkSync, accessSync, readdirSync, constants as fsConstants } from "fs";
 import { join, resolve, relative, isAbsolute } from "path";
 import {
   log,
@@ -16,25 +16,91 @@ import {
 const TAILSCALE_BIN = process.env.TAILSCALE_BIN || "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
 const CERT_RENEW_THRESHOLD_DAYS = 7;
 
-// Short label for a client identity, used as the Chrome tab-group name (the tab
-// strip is space-constrained, so cap at 7 chars). gitUrl ".../owner/repo/tree/branch"
-// -> "rep:bra" (3+3); "host:/path/to/dir" -> "dir"; bare host/IP -> as-is. Strips a
-// trailing "@profile" suffix first.
-const MAX_GROUP_LABEL_LEN = 7;
-function shortClientLabel(raw: string): string {
+// Short label for a client identity, used as the Chrome tab-group name (the tab strip is
+// space-constrained, so cap at 7 chars). Handles the current label shape and the legacy gitUrl:
+//   "host/owner/repo#<basename>@<branch>" -> "bas:bra" (3+3)   (current)
+//   "host/owner/repo/tree/branch"         -> "rep:bra" (3+3)   (legacy gitUrl)
+//   "host:/path/to/dir"                   -> "dir"             (non-git)
+//   bare host/IP                          -> as-is
+export const MAX_GROUP_LABEL_LEN = 7;
+export function shortClientLabel(raw: string): string {
   if (!raw) return raw;
-  const baseId = raw.includes("@") ? raw.slice(0, raw.indexOf("@")) : raw;
-  const git = baseId.match(/^https?:\/\/[^/]+\/[^/]+\/([^/]+?)(?:\/tree\/(.+))?$/);
-  let label: string;
-  if (git)
-    label = git[2] ? `${git[1].slice(0, 3)}:${git[2].slice(0, 3)}` : git[1];
-  else {
-    const hostCwd = baseId.match(/^[^:]+:(.+)$/);
-    label = hostCwd ? (hostCwd[1].split("/").filter(Boolean).pop() || baseId) : baseId;
+  const join3 = (a: string, b?: string) => (b ? `${a.slice(0, 3)}:${b.slice(0, 3)}` : a);
+  // Current label: "[remote#]<worktree-basename>[@<branch>]"
+  if (raw.includes("#") || (raw.includes("@") && !raw.startsWith("http"))) {
+    const afterHash = raw.includes("#") ? raw.slice(raw.indexOf("#") + 1) : raw;
+    const [base, branch] = afterHash.split("@");
+    return join3(base, branch).slice(0, MAX_GROUP_LABEL_LEN);
   }
+  // Legacy gitUrl: ".../owner/repo/tree/branch"
+  const git = raw.match(/^https?:\/\/[^/]+\/[^/]+\/([^/]+?)(?:\/tree\/(.+))?$/);
+  if (git) return join3(git[1], git[2]).slice(0, MAX_GROUP_LABEL_LEN);
+  // "host:/path/to/dir" -> basename
+  const hostCwd = raw.match(/^[^:]+:(.+)$/);
+  const label = hostCwd ? (hostCwd[1].split("/").filter(Boolean).pop() || raw) : raw;
   return label.slice(0, MAX_GROUP_LABEL_LEN);
 }
 
+// --isolate sessions (`rech --isolate ...` -> `-s=iso-<rand>`) are throwaway, single-flow
+// buckets. We reap them on an idle TTL so an OAuth/login drive can't leak an orphaned browser
+// context. A TTL (not close-on-exit-per-command) is required because the flows are multi-step
+// (open -> click -> consent): closing after each command would break them. The reaper runs the
+// CLI's `close` for the specific iso session only — it never touches the user's other sessions
+// or quits Chrome.
+const ISO_SESSION_TTL_MS = Number(process.env.RECH_ISOLATE_TTL_MS) || 15 * 60_000;
+const ISO_REAP_INTERVAL_MS = 60_000;
+const isoLastUsed = new Map<string, number>();
+
+export function isIsoSession(namespacedSession: string): boolean {
+  return /(?:^|-)iso-[0-9a-f]+$/.test(namespacedSession);
+}
+
+function tmpSocketRoot(): string {
+  return `${(process.env.TMPDIR || "/tmp").replace(/\/$/, "")}/playwright-cli`;
+}
+
+// On startup, adopt any iso-* sessions a previous daemon left behind so they still get reaped
+// (in-memory tracking alone would miss pre-restart orphans). Best-effort: a mis-derived session
+// just yields a harmless no-op `close`. Socket files are named with the session as their prefix.
+function adoptOrphanedIsoSessions(): void {
+  try {
+    const root = tmpSocketRoot();
+    for (const sub of readdirSync(root)) {
+      let entries: string[];
+      try { entries = readdirSync(`${root}/${sub}`); } catch { continue; }
+      for (const f of entries) {
+        const m = f.match(/^([0-9a-f]+-iso-[0-9a-f]+)/) || f.match(/^(iso-[0-9a-f]+)/);
+        if (m && !isoLastUsed.has(m[1])) {
+          isoLastUsed.set(m[1], Date.now());
+          log(`adopted orphaned isolated session for reaping: ${m[1]}`);
+        }
+      }
+    }
+  } catch {
+    // socket dir may not exist yet — nothing to adopt
+  }
+}
+
+function reapIdleIsoSessions(bin: string, binArgs: string[], workDir: string): void {
+  const now = Date.now();
+  for (const [sess, last] of isoLastUsed) {
+    if (now - last < ISO_SESSION_TTL_MS) continue;
+    isoLastUsed.delete(sess);
+    try {
+      Bun.spawn([bin, ...binArgs, "close", `-s=${sess}`], {
+        cwd: workDir,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        env: { PATH: process.env.PATH, HOME: HOME, USERPROFILE: process.env.USERPROFILE },
+      });
+      log(`reaped idle isolated session (idle ${Math.round((now - last) / 1000)}s): ${sess}`);
+    } catch (e) {
+      log(`reap failed for ${sess}: ${e}`);
+    }
+  }
+}
+
 async function renewCertIfNeeded(certPath: string, keyPath: string): Promise<boolean> {
   const certContent = await file(certPath).text().catch(() => null);
   if (!certContent) return false;
@@ -142,6 +208,13 @@ export async function serve() {
   const workDir = join(RECH_DIR, "output");
   mkdirSync(workDir, { recursive: true });
 
+  // Reap idle --isolate sessions so single-shot OAuth/login drives don't leak browser contexts.
+  adoptOrphanedIsoSessions();
+  setInterval(() => {
+    const [bin, ...binArgs] = splitCommand(resolvePlaywrightCli());
+    reapIdleIsoSessions(bin, binArgs, workDir);
+  }, ISO_REAP_INTERVAL_MS);
+
   const listenHost = process.env.RECH_HOST || "127.0.0.1";
   const canRead = (p?: string) => { try { accessSync(p!, fsConstants.R_OK); return true; } catch { return false; } };
   const certPath = canRead(process.env.RECH_TLS_CERT) ? process.env.RECH_TLS_CERT : undefined;
@@ -201,14 +274,19 @@ export async function serve() {
       } else {
         args = body.args;
         const id = body.identity as
-          | { gitUrl?: string; hostname?: string; cwd?: string; profile?: string }
+          | { key?: string; label?: string; gitUrl?: string; hostname?: string; cwd?: string; profile?: string }
           | undefined;
-        const baseId = id?.gitUrl || (id?.hostname && id?.cwd ? `${id.hostname}:${id.cwd}` : null);
-        const raw = baseId && id?.profile ? `${baseId}@${id.profile}` : baseId;
-        if (raw) {
-          sessionId = createHash("sha256").update(raw).digest("hex").slice(0, 8);
-          clientName = raw;
-          log(`session from identity: ${raw} -> ${sessionId}`);
+        // New clients send {key,label} (key = worktree-root-based, decoupled from the pretty
+        // label). Fall back to the legacy {gitUrl|hostname:cwd} shape for older clients.
+        const legacy = id?.gitUrl || (id?.hostname && id?.cwd ? `${id.hostname}:${id.cwd}` : null);
+        const keyBase = id?.key || legacy;
+        const labelBase = id?.label || legacy || keyBase;
+        if (keyBase) {
+          // Hash the key (+ profile via a NUL separator that never appears in a label).
+          const hashInput = id?.profile ? `${keyBase}\u0000${id.profile}` : keyBase;
+          sessionId = createHash("sha256").update(hashInput).digest("hex").slice(0, 8);
+          clientName = labelBase || keyBase;
+          log(`session from identity: ${clientName}${id?.profile ? ` profile:${id.profile}` : ""} [${keyBase}] -> ${sessionId}`);
         } else {
           const clientAddr = `${req.headers.get("x-forwarded-for") || server.requestIP(req)?.address || "unknown"}`;
           sessionId = createHash("sha256").update(clientAddr).digest("hex").slice(0, 8);
@@ -233,6 +311,8 @@ export async function serve() {
         return true;
       });
       const namespacedSession = clientSession ? `${sessionId}-${clientSession}` : sessionId;
+      // Track --isolate sessions so the idle-TTL reaper can close them later.
+      if (isIsoSession(namespacedSession)) isoLastUsed.set(namespacedSession, Date.now());
 
       // daemonInstall bakes PLAYWRIGHT_CLI into the daemon env; resolvePlaywrightCli() is the
       // fallback for a standalone `serve` (it re-runs the same env > fork > @playwright/cli > legacy chain).

package/serve.ts

@@ -1,6 +1,6 @@
 import { file } from "bun";
 import { createHash, X509Certificate } from "crypto";
-import { mkdirSync, unlinkSync, accessSync, constants as fsConstants } from "fs";
+import { mkdirSync, unlinkSync, accessSync, readdirSync, constants as fsConstants } from "fs";
 import { join, resolve, relative, isAbsolute } from "path";
 import {
   log,
@@ -16,25 +16,91 @@ import {
 const TAILSCALE_BIN = process.env.TAILSCALE_BIN || "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
 const CERT_RENEW_THRESHOLD_DAYS = 7;
 
-// Short label for a client identity, used as the Chrome tab-group name (the tab
-// strip is space-constrained, so cap at 7 chars). gitUrl ".../owner/repo/tree/branch"
-// -> "rep:bra" (3+3); "host:/path/to/dir" -> "dir"; bare host/IP -> as-is. Strips a
-// trailing "@profile" suffix first.
-const MAX_GROUP_LABEL_LEN = 7;
-function shortClientLabel(raw: string): string {
+// Short label for a client identity, used as the Chrome tab-group name (the tab strip is
+// space-constrained, so cap at 7 chars). Handles the current label shape and the legacy gitUrl:
+//   "host/owner/repo#<basename>@<branch>" -> "bas:bra" (3+3)   (current)
+//   "host/owner/repo/tree/branch"         -> "rep:bra" (3+3)   (legacy gitUrl)
+//   "host:/path/to/dir"                   -> "dir"             (non-git)
+//   bare host/IP                          -> as-is
+export const MAX_GROUP_LABEL_LEN = 7;
+export function shortClientLabel(raw: string): string {
   if (!raw) return raw;
-  const baseId = raw.includes("@") ? raw.slice(0, raw.indexOf("@")) : raw;
-  const git = baseId.match(/^https?:\/\/[^/]+\/[^/]+\/([^/]+?)(?:\/tree\/(.+))?$/);
-  let label: string;
-  if (git)
-    label = git[2] ? `${git[1].slice(0, 3)}:${git[2].slice(0, 3)}` : git[1];
-  else {
-    const hostCwd = baseId.match(/^[^:]+:(.+)$/);
-    label = hostCwd ? (hostCwd[1].split("/").filter(Boolean).pop() || baseId) : baseId;
+  const join3 = (a: string, b?: string) => (b ? `${a.slice(0, 3)}:${b.slice(0, 3)}` : a);
+  // Current label: "[remote#]<worktree-basename>[@<branch>]"
+  if (raw.includes("#") || (raw.includes("@") && !raw.startsWith("http"))) {
+    const afterHash = raw.includes("#") ? raw.slice(raw.indexOf("#") + 1) : raw;
+    const [base, branch] = afterHash.split("@");
+    return join3(base, branch).slice(0, MAX_GROUP_LABEL_LEN);
   }
+  // Legacy gitUrl: ".../owner/repo/tree/branch"
+  const git = raw.match(/^https?:\/\/[^/]+\/[^/]+\/([^/]+?)(?:\/tree\/(.+))?$/);
+  if (git) return join3(git[1], git[2]).slice(0, MAX_GROUP_LABEL_LEN);
+  // "host:/path/to/dir" -> basename
+  const hostCwd = raw.match(/^[^:]+:(.+)$/);
+  const label = hostCwd ? (hostCwd[1].split("/").filter(Boolean).pop() || raw) : raw;
   return label.slice(0, MAX_GROUP_LABEL_LEN);
 }
 
+// --isolate sessions (`rech --isolate ...` -> `-s=iso-<rand>`) are throwaway, single-flow
+// buckets. We reap them on an idle TTL so an OAuth/login drive can't leak an orphaned browser
+// context. A TTL (not close-on-exit-per-command) is required because the flows are multi-step
+// (open -> click -> consent): closing after each command would break them. The reaper runs the
+// CLI's `close` for the specific iso session only — it never touches the user's other sessions
+// or quits Chrome.
+const ISO_SESSION_TTL_MS = Number(process.env.RECH_ISOLATE_TTL_MS) || 15 * 60_000;
+const ISO_REAP_INTERVAL_MS = 60_000;
+const isoLastUsed = new Map<string, number>();
+
+export function isIsoSession(namespacedSession: string): boolean {
+  return /(?:^|-)iso-[0-9a-f]+$/.test(namespacedSession);
+}
+
+function tmpSocketRoot(): string {
+  return `${(process.env.TMPDIR || "/tmp").replace(/\/$/, "")}/playwright-cli`;
+}
+
+// On startup, adopt any iso-* sessions a previous daemon left behind so they still get reaped
+// (in-memory tracking alone would miss pre-restart orphans). Best-effort: a mis-derived session
+// just yields a harmless no-op `close`. Socket files are named with the session as their prefix.
+function adoptOrphanedIsoSessions(): void {
+  try {
+    const root = tmpSocketRoot();
+    for (const sub of readdirSync(root)) {
+      let entries: string[];
+      try { entries = readdirSync(`${root}/${sub}`); } catch { continue; }
+      for (const f of entries) {
+        const m = f.match(/^([0-9a-f]+-iso-[0-9a-f]+)/) || f.match(/^(iso-[0-9a-f]+)/);
+        if (m && !isoLastUsed.has(m[1])) {
+          isoLastUsed.set(m[1], Date.now());
+          log(`adopted orphaned isolated session for reaping: ${m[1]}`);
+        }
+      }
+    }
+  } catch {
+    // socket dir may not exist yet — nothing to adopt
+  }
+}
+
+function reapIdleIsoSessions(bin: string, binArgs: string[], workDir: string): void {
+  const now = Date.now();
+  for (const [sess, last] of isoLastUsed) {
+    if (now - last < ISO_SESSION_TTL_MS) continue;
+    isoLastUsed.delete(sess);
+    try {
+      Bun.spawn([bin, ...binArgs, "close", `-s=${sess}`], {
+        cwd: workDir,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        env: { PATH: process.env.PATH, HOME: HOME, USERPROFILE: process.env.USERPROFILE },
+      });
+      log(`reaped idle isolated session (idle ${Math.round((now - last) / 1000)}s): ${sess}`);
+    } catch (e) {
+      log(`reap failed for ${sess}: ${e}`);
+    }
+  }
+}
+
 async function renewCertIfNeeded(certPath: string, keyPath: string): Promise<boolean> {
   const certContent = await file(certPath).text().catch(() => null);
   if (!certContent) return false;
@@ -142,6 +208,13 @@ export async function serve() {
   const workDir = join(RECH_DIR, "output");
   mkdirSync(workDir, { recursive: true });
 
+  // Reap idle --isolate sessions so single-shot OAuth/login drives don't leak browser contexts.
+  adoptOrphanedIsoSessions();
+  setInterval(() => {
+    const [bin, ...binArgs] = splitCommand(resolvePlaywrightCli());
+    reapIdleIsoSessions(bin, binArgs, workDir);
+  }, ISO_REAP_INTERVAL_MS);
+
   const listenHost = process.env.RECH_HOST || "127.0.0.1";
   const canRead = (p?: string) => { try { accessSync(p!, fsConstants.R_OK); return true; } catch { return false; } };
   const certPath = canRead(process.env.RECH_TLS_CERT) ? process.env.RECH_TLS_CERT : undefined;
@@ -201,14 +274,19 @@ export async function serve() {
       } else {
         args = body.args;
         const id = body.identity as
-          | { gitUrl?: string; hostname?: string; cwd?: string; profile?: string }
+          | { key?: string; label?: string; gitUrl?: string; hostname?: string; cwd?: string; profile?: string }
           | undefined;
-        const baseId = id?.gitUrl || (id?.hostname && id?.cwd ? `${id.hostname}:${id.cwd}` : null);
-        const raw = baseId && id?.profile ? `${baseId}@${id.profile}` : baseId;
-        if (raw) {
-          sessionId = createHash("sha256").update(raw).digest("hex").slice(0, 8);
-          clientName = raw;
-          log(`session from identity: ${raw} -> ${sessionId}`);
+        // New clients send {key,label} (key = worktree-root-based, decoupled from the pretty
+        // label). Fall back to the legacy {gitUrl|hostname:cwd} shape for older clients.
+        const legacy = id?.gitUrl || (id?.hostname && id?.cwd ? `${id.hostname}:${id.cwd}` : null);
+        const keyBase = id?.key || legacy;
+        const labelBase = id?.label || legacy || keyBase;
+        if (keyBase) {
+          // Hash the key (+ profile via a NUL separator that never appears in a label).
+          const hashInput = id?.profile ? `${keyBase}\u0000${id.profile}` : keyBase;
+          sessionId = createHash("sha256").update(hashInput).digest("hex").slice(0, 8);
+          clientName = labelBase || keyBase;
+          log(`session from identity: ${clientName}${id?.profile ? ` profile:${id.profile}` : ""} [${keyBase}] -> ${sessionId}`);
         } else {
           const clientAddr = `${req.headers.get("x-forwarded-for") || server.requestIP(req)?.address || "unknown"}`;
           sessionId = createHash("sha256").update(clientAddr).digest("hex").slice(0, 8);
@@ -233,6 +311,8 @@ export async function serve() {
         return true;
       });
       const namespacedSession = clientSession ? `${sessionId}-${clientSession}` : sessionId;
+      // Track --isolate sessions so the idle-TTL reaper can close them later.
+      if (isIsoSession(namespacedSession)) isoLastUsed.set(namespacedSession, Date.now());
 
       // daemonInstall bakes PLAYWRIGHT_CLI into the daemon env; resolvePlaywrightCli() is the
       // fallback for a standalone `serve` (it re-runs the same env > fork > @playwright/cli > legacy chain).