rechrome 1.35.1 → 1.36.1

package/README.md

@@ -164,6 +164,11 @@ If no supported daemon manager is available, setup asks before installing `oxmgr
 when launched with npx. Pass `--yes` to approve this without prompting,
 for example `bunx rechrome setup --profile Default --yes`.
 
+On macOS, a daemon started by launchd or oxmgr cannot read Chrome's profile folder
+until its bun binary has Full Disk Access. `rech status` and the serve log report
+this and name the binary. See [Keeping rech serve running on macOS](docs/macos-daemon.md)
+for the grant, a LaunchAgent, and the terminal keep-alive alternative.
+
 Agents setting up Chrome on macOS can use the [rechrome setup skill](skills/rechrome-setup/SKILL.md),
 which covers native extension installation with Computer Use and CLI connection verification.
 `rech setup` detects Codex and Claude Code environment hints and prints agent-specific guidance;
@@ -243,6 +248,7 @@ cp .env.example .env.local
 | `PLAYWRIGHT_MCP_EXTENSION_ID`       | Chrome extension ID (client overrides server)                                                                                       | —                |
 | `PLAYWRIGHT_MCP_EXTENSION_TOKEN`    | Chrome extension token — profile-specific, get it from the extension's status page (client overrides server)                        | —                |
 | `PLAYWRIGHT_MCP_USER_DATA_DIR`      | Chrome user data directory — use to pin connections to a specific Chrome install (client overrides server)                          | —                |
+| `RECHROME_PROFILE` | Default profile selector for browser commands, equivalent to `--profile`. An explicit flag wins; blank values are ignored. Remote listeners still enforce their allowlist. | — |
 | `PLAYWRIGHT_MCP_PROFILE_DIRECTORY`  | Chrome profile — accepts directory name (`Profile 2`), display name (`Snowstar`), or **email** (`you@example.com`) (client overrides server) | —         |
 
 > **Multi-profile tip:** Each project's `.env.local` can specify a different Chrome profile via the `?profile=` query param in `RECHROME_URL`. The server resolves display names and email addresses to the actual Chrome profile directory automatically (reads `~/Library/Application Support/Google/Chrome/Local State`).
@@ -254,6 +260,57 @@ cp .env.example .env.local
 >
 > Shell-set `PLAYWRIGHT_MCP_*` variables take priority over `.env.local`, so you can always override per-command without editing files.
 
+### Small icon uploads from stdin
+
+Uploads are disabled by default on every listener. The host owner can add an
+`uploads` object to the intended listener entry in `~/.rechrome/listeners.json`:
+
+```json
+"uploads": {
+  "maxBytes": 2097152,
+  "contentTypes": ["image/png", "image/svg+xml"]
+}
+```
+
+The object enables uploads; omitting it disables them. `uploads: {}` uses the
+same defaults shown above. The owner can lower the byte limit or narrow the type
+list, but cannot exceed the hard **2 MiB** limit or enable other types. Do not
+replace the listener's other fields or share its key. Install the updated daemon
+code before enabling this policy; configuration changes then use the usual
+listener reload mechanism.
+
+On the **client machine**, open the website's file chooser with `rech click`, then
+send the icon through stdin in the same profile/session:
+
+```bash
+rech --profile work -s=slack upload --name app-icon.png < ./app-icon.png
+cat ./app-icon.svg | rech --profile work -s=slack upload --name app-icon.svg
+```
+
+`--content-type image/png` or `--content-type image/svg+xml` may be specified;
+otherwise the type is inferred from `--name`. This command is stdin-only: there
+is no positional file path. The shell reads the local file; only its bytes and
+metadata are sent to the listener. Client and server both enforce the byte cap.
+The server checks PNG signatures or UTF-8 SVG markup (rejecting DTD/entities),
+and checks the type against the listener policy. These checks identify the file
+format; they do not sanitize SVG or scan for malware. The host never renders the
+file or resolves anything referenced inside it.
+
+The receiver writes a random `.png`/`.svg` filename with mode 0600 inside a private
+0700 temporary directory, outside the downloadable output tree. It passes only
+that generated path to the existing file-chooser command and removes the directory
+on success, error, or timeout. Neither filenames nor payload fields can select a
+host file. A crash or forced process kill can interrupt cleanup; the files remain
+private OS temporary files. Permission modes apply on POSIX hosts.
+
+Each upload produces one `upload:` JSON audit record with listener, profile,
+original name, byte size, SHA-256, page origin observed immediately before upload,
+and result. It contains no file contents, credentials, page path, query, or fragment.
+Requests rejected before inspection have null values for unavailable fields.
+An HTTP(S) origin must be determined before an upload is attempted. As with other
+browser commands, avoid concurrent tab navigation in the same session. Scoped
+`eval`, `run-code`, host paths, and CLI option overrides remain unavailable.
+
 ### Remote access
 
 `rech setup --profile <profile> --listen tailscale` exposes that profile through a
@@ -345,3 +402,25 @@ PRs upstream are welcome. Once these features land in the official packages we w
 ## License
 
 MIT
+
+### Bridge connection diagnostics and recovery
+
+Each connection attempt records fixed phase names (launch, retry, WebSocket
+accepted, initialized, timeout/close) in its own private `.bridge.jsonl` file under
+`~/.cache/ms-playwright/bridge`, or `PLAYWRIGHT_MCP_BRIDGE_LOG_DIR` when configured
+for the Playwright process. Records contain an attempt ID, PID and timing only;
+no URLs, tokens, page text or raw error messages. CLI startup stderr is retained
+separately in a unique `.err` file for each launch and is not the sanitized log.
+
+A failed automated connection page retires itself at its deadline only if it
+still shows the original connection URL. The profile's worker can remove an older
+page for the same attempt and relay; it excludes other attempts, attached tabs,
+and tabs that navigated away. Automatic recovery no longer reloads the extension,
+which could disconnect other working lanes. A genuinely unresponsive worker can
+still require an explicit operator-approved extension reload.
+
+This source change requires rebuilding the vendored Playwright bundle and
+reloading the updated extension before use. It does not modify a running daemon
+or extension. The draft PR records isolated-browser validation and negative
+controls; passing recovery tests does not establish the original intermittent
+timeout's root cause.

package/extension/lib/background.mjs

@@ -566,7 +566,10 @@ class PlaywrightExtension {
   _onMessage(message, sender, sendResponse) {
     switch (message.type) {
       case "connectionRequested":
-        this._pendingConnections.create(sender.tab.id, message.mcpRelayUrl, message.protocolVersion).then(
+        (async () => {
+          if (message.recoveryAttempt) await this._retireSupersededPages(sender);
+          await this._pendingConnections.create(sender.tab.id, message.mcpRelayUrl, message.protocolVersion);
+        })().then(
           () => sendResponse({ success: true }),
           (error) => sendResponse({ success: false, error: error.message })
         );
@@ -606,6 +609,27 @@ class PlaywrightExtension {
         return false;
     }
   }
+  // The single worker coordinates recovery within this profile. It never reloads
+  // itself or touches live groups: only sibling connect pages for the same relay
+  // attempt can be retired. A different lane/attempt is outside this ownership.
+  async _retireSupersededPages(sender) {
+    var _a;
+    const current = new URL(sender.url || ((_a = sender.tab) == null ? void 0 : _a.url) || "about:blank");
+    const attempt = current.searchParams.get("attempt");
+    const relay = current.searchParams.get("mcpRelayUrl");
+    if (current.protocol !== "chrome-extension:" || current.host !== chrome.runtime.id || current.pathname !== "/connect.html" || !/^[0-9a-f-]{36}$/.test(attempt || "") || !relay) return;
+    const attached = new Set([...this._activeGroups].flatMap((g) => g.connectedTabIds()));
+    const tabs = await chrome.tabs.query({});
+    await Promise.all(tabs.map(async (tab) => {
+      var _a2;
+      if (tab.id === void 0 || tab.id === ((_a2 = sender.tab) == null ? void 0 : _a2.id) || attached.has(tab.id) || !tab.url) return;
+      const other = new URL(tab.url);
+      if (other.protocol !== current.protocol || other.host !== current.host || other.pathname !== current.pathname || other.searchParams.get("attempt") !== attempt || other.searchParams.get("mcpRelayUrl") !== relay) return;
+      const latest = await chrome.tabs.get(tab.id).catch(() => void 0);
+      if ((latest == null ? void 0 : latest.url) === tab.url) await chrome.tabs.remove(tab.id).catch(() => {
+      });
+    }));
+  }
   async _connectTab(selectorTabId, tab, clientName) {
     try {
       await Promise.race([
@@ -655,3 +679,6 @@ class PlaywrightExtension {
   }
 }
 new PlaywrightExtension();
+export {
+  PlaywrightExtension
+};

package/extension/lib/ui/connect.js

@@ -4,18 +4,12 @@
 import { c as clientExports, j as jsxRuntimeExports, r as reactExports, A as AuthTokenSection, T as TabItem, B as Button, g as getOrCreateAuthToken } from "./authToken.js";
 const SUPPORTED_PROTOCOL_VERSION = 2;
 const BACKGROUND_RESPONSE_TIMEOUT_MS = 1e4;
-const SELF_RELOAD_GUARD_KEY = "connect-self-reload-at";
-const SELF_RELOAD_MIN_INTERVAL_MS = 6e4;
-function attemptExtensionSelfReload() {
-  if (new URLSearchParams(window.location.search).get("selfReload") !== "1")
-    return false;
-  const last = Number(localStorage.getItem(SELF_RELOAD_GUARD_KEY) || 0);
-  const now = Date.now();
-  if (now - last < SELF_RELOAD_MIN_INTERVAL_MS)
-    return false;
-  localStorage.setItem(SELF_RELOAD_GUARD_KEY, String(now));
-  chrome.runtime.reload();
-  return true;
+async function retireExpiredAttempt(originalUrl) {
+  const params = new URL(originalUrl).searchParams;
+  if (!/^[0-9a-f-]{36}$/.test(params.get("attempt") || "")) return;
+  const tab = await chrome.tabs.getCurrent();
+  if ((tab == null ? void 0 : tab.id) !== void 0 && tab.url === originalUrl)
+    await chrome.tabs.remove(tab.id);
 }
 async function sendMessageWithTimeout(message, simulateHang = false) {
   let timer;
@@ -41,6 +35,17 @@ const ConnectApp = () => {
     setStatus({ type: "error", message });
   }, []);
   reactExports.useEffect(() => {
+    const originalUrl = window.location.href;
+    const expiry = Number(new URL(originalUrl).searchParams.get("expires"));
+    let connected = false;
+    const onConnected = () => {
+      connected = true;
+    };
+    window.addEventListener("bridge-connected", onConnected);
+    const expiryTimer = Number.isFinite(expiry) && expiry > 0 ? setTimeout(() => {
+      if (!connected) void retireExpiredAttempt(originalUrl).catch(() => {
+      });
+    }, Math.max(0, Math.min(expiry - Date.now(), 2147483647))) : void 0;
     const runAsync = async () => {
       const params = new URLSearchParams(window.location.search);
       const relayUrl = params.get("mcpRelayUrl");
@@ -89,13 +94,12 @@ const ConnectApp = () => {
       let response;
       try {
         response = await sendMessageWithTimeout(
-          { type: "connectionRequested", mcpRelayUrl: relayUrl, protocolVersion: requestedVersion },
+          { type: "connectionRequested", mcpRelayUrl: relayUrl, protocolVersion: requestedVersion, recoveryAttempt },
           params.get("testHangOnce") === "1" && !recoveryAttempt
         );
       } catch (error) {
         if (hasAutomationToken && !recoveryAttempt) {
-          const reloading = attemptExtensionSelfReload();
-          setError(reloading ? "Extension service worker is not responding. Reloading extension and retrying…" : "Extension service worker is not responding. Retrying once…");
+          setError("Extension service worker is not responding. Retrying once…");
           return;
         }
         setError(`Extension service worker did not recover: ${error.message}`);
@@ -108,7 +112,7 @@ const ConnectApp = () => {
       const expectedToken = getOrCreateAuthToken();
       const token = params.get("token");
       if (token === expectedToken) {
-        await handleConnectToTab(void 0, info);
+        connected = !!await handleConnectToTab(void 0, info);
         return;
       }
       if (token) {
@@ -125,7 +129,11 @@ const ConnectApp = () => {
       chrome.runtime.sendMessage({ type: "keepalive" }).catch(() => {
       });
     }, 2e4);
-    return () => clearInterval(keepalive);
+    return () => {
+      clearInterval(keepalive);
+      clearTimeout(expiryTimer);
+      window.removeEventListener("bridge-connected", onConnected);
+    };
   }, []);
   const loadTabs = reactExports.useCallback(async () => {
     const response = await chrome.runtime.sendMessage({ type: "getTabs" });
@@ -144,6 +152,8 @@ const ConnectApp = () => {
       });
       if (response == null ? void 0 : response.success) {
         setStatus({ type: "connected", message: `"${clientName}" connected.` });
+        window.dispatchEvent(new Event("bridge-connected"));
+        return true;
       } else {
         setStatus({
           type: "error",
@@ -154,8 +164,7 @@ const ConnectApp = () => {
       const recoveryAttempt = new URLSearchParams(window.location.search).get("recoveryAttempt") === "1";
       const hasAutomationToken = !!new URLSearchParams(window.location.search).get("token");
       if (hasAutomationToken && !recoveryAttempt) {
-        const reloading = attemptExtensionSelfReload();
-        setError(reloading ? "Extension service worker stopped during connection. Reloading extension and retrying…" : "Extension service worker stopped during connection. Retrying once…");
+        setError("Extension service worker stopped during connection. Retrying once…");
         return;
       }
       setStatus({
@@ -163,6 +172,7 @@ const ConnectApp = () => {
         message: `"${clientName}" failed to connect: ${e}`
       });
     }
+    return false;
   }, [clientInfo, setError]);
   reactExports.useEffect(() => {
     const listener = (message) => {

package/listeners.js

@@ -1,4 +1,14 @@
 // @bun
+// scoped-upload.ts
+var MAX_UPLOAD_BYTES = 2 * 1024 * 1024;
+var MAX_REQUEST_BYTES = 3 * 1024 * 1024;
+var UPLOAD_TYPES = ["image/png", "image/svg+xml"];
+function validateUploadPolicy(value) {
+  const p = value;
+  if (!p || typeof p !== "object" || Array.isArray(p) || Object.keys(p).some((k) => !["maxBytes", "contentTypes"].includes(k)) || p.maxBytes !== undefined && (!Number.isSafeInteger(p.maxBytes) || p.maxBytes < 1 || p.maxBytes > MAX_UPLOAD_BYTES) || p.contentTypes !== undefined && (!Array.isArray(p.contentTypes) || !p.contentTypes.length || p.contentTypes.some((t) => !UPLOAD_TYPES.includes(t))))
+    throw new Error("uploads must be an object with optional maxBytes (1..2097152) and contentTypes (image/png, image/svg+xml)");
+}
+
 // listeners.ts
 import { isIP } from "net";
 import { createHash, randomBytes } from "crypto";
@@ -54,6 +64,8 @@ function validateListeners(value) {
     } else if (!Array.isArray(l.profiles) || !l.profiles.length || l.profiles.some((p) => typeof p !== "string" || !p.trim() || p.includes("\x00") || p === "*")) {
       throw new Error("Listener profiles must be a nonempty list of registered profile keys");
     }
+    if (l.uploads !== undefined)
+      validateUploadPolicy(l.uploads);
     const address = listenerAddress(l);
     if (names.has(l.name) || addresses.has(address) || keys.has(l.key))
       throw new Error("Listener names, addresses, and credentials must be unique");
@@ -92,12 +104,16 @@ function authorizeProfileRequest(listener, body) {
   if (body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY && body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY !== profile)
     throw new Error("Profile override does not match request identity");
   const args = body.args.filter((a) => /^-s=[a-zA-Z0-9_-]{1,64}$/.test(a) === false);
-  if (!SCOPED_COMMANDS.has(args[0]))
+  if (!(args[0] === "upload" && listener.uploads !== undefined) && !SCOPED_COMMANDS.has(args[0]))
     throw new Error("Command is unavailable on profile-scoped listeners; use the local management listener for arbitrary code or host access");
   if (body.args.filter((a) => a.startsWith("-s=")).length > 1 || args.slice(1).some((a) => a.startsWith("-") && !(args[0] === "screenshot" && a === "--full-page")))
     throw new Error("CLI option overrides are unavailable on profile-scoped listeners");
   if (["open", "goto", "tab-new"].includes(args[0]) && args[1] && !/^https?:\/\//i.test(args[1]) && args[1] !== "about:blank")
     throw new Error("Scoped navigation accepts only HTTP(S) or about:blank");
+  if (args[0] === "upload" && (args.length !== 1 || !body.upload))
+    throw new Error("Upload requires stdin bytes; host paths are unavailable");
+  if (args[0] !== "upload" && body.upload !== undefined)
+    throw new Error("Unexpected upload payload");
   return profile;
 }
 function canReadProfileFile(listener, path) {

package/listeners.ts

@@ -1,3 +1,4 @@
+import { validateUploadPolicy, type UploadPolicy } from "./scoped-upload.ts";
 import { isIP } from "net";
 import { createHash, randomBytes } from "crypto";
 import { homedir } from "os";
@@ -5,7 +6,7 @@ import { join } from "path";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 
 // publicUrl: where a reverse proxy (Tailscale Serve, Caddy, nginx, ...) exposes this listener.
-export type Listener = { name: string; host: string; port: number; key: string; profiles: string[] | "*"; prefix?: string; publicUrl?: string };
+export type Listener = { name: string; host: string; port: number; key: string; profiles: string[] | "*"; prefix?: string; publicUrl?: string; uploads?: UploadPolicy };
 export type ListenerConfig = { version: 1; listeners: Listener[] };
 export const LISTENERS_FILE = join(homedir(), ".rechrome", "listeners.json");
 export const isLoopback = (host: string) => host === "::1" || /^127\./.test(host);
@@ -54,6 +55,7 @@ export function validateListeners(value: unknown): ListenerConfig {
     } else if (!Array.isArray(l.profiles) || !l.profiles.length || l.profiles.some(p => typeof p !== "string" || !p.trim() || p.includes("\0") || p === "*")) {
       throw new Error("Listener profiles must be a nonempty list of registered profile keys");
     }
+    if (l.uploads !== undefined) validateUploadPolicy(l.uploads);
     const address = listenerAddress(l);
     if (names.has(l.name) || addresses.has(address) || keys.has(l.key)) throw new Error("Listener names, addresses, and credentials must be unique");
     names.add(l.name); addresses.add(address); keys.add(l.key);
@@ -85,9 +87,12 @@ export function authorizeProfileRequest(listener: Listener, body: any): string {
   if (typeof profile !== "string" || listener.profiles === "*" || !listener.profiles.includes(profile)) throw new Error("Profile is not allowed on this listener");
   if (body.env?.PLAYWRIGHT_MCP_PROFILE_DIRECTORY && body.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY !== profile) throw new Error("Profile override does not match request identity");
   const args = body.args.filter((a: string) => /^-s=[a-zA-Z0-9_-]{1,64}$/.test(a) === false);
-  if (!SCOPED_COMMANDS.has(args[0])) throw new Error("Command is unavailable on profile-scoped listeners; use the local management listener for arbitrary code or host access");
+  if (!(args[0] === "upload" && listener.uploads !== undefined) && !SCOPED_COMMANDS.has(args[0])) throw new Error("Command is unavailable on profile-scoped listeners; use the local management listener for arbitrary code or host access");
   if (body.args.filter((a: string) => a.startsWith("-s=")).length > 1 || args.slice(1).some((a: string) => a.startsWith("-") && !(args[0] === "screenshot" && a === "--full-page"))) throw new Error("CLI option overrides are unavailable on profile-scoped listeners");
   if (["open", "goto", "tab-new"].includes(args[0]) && args[1] && !/^https?:\/\//i.test(args[1]) && args[1] !== "about:blank") throw new Error("Scoped navigation accepts only HTTP(S) or about:blank");
+  // Upload is handled by the byte-only receiver; the caller cannot supply host paths.
+  if (args[0] === "upload" && (args.length !== 1 || !body.upload)) throw new Error("Upload requires stdin bytes; host paths are unavailable");
+  if (args[0] !== "upload" && body.upload !== undefined) throw new Error("Unexpected upload payload");
   return profile;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rechrome",
-  "version": "1.35.1",
+  "version": "1.36.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/rechrome.git"
@@ -25,7 +25,9 @@
     "rechrome.ts",
     "serve.js",
     "serve.ts",
-    "vendor"
+    "vendor",
+    "scoped-upload.ts",
+    "scoped-upload.js"
   ],
   "type": "module",
   "scripts": {
@@ -34,7 +36,7 @@
     "vendor-cli": "bash scripts/vendor-cli.sh",
     "prepare": "bash scripts/vendor-cli.sh --prepare",
     "check-pack": "bash scripts/check-pack.sh",
-    "prepublishOnly": "bash scripts/vendor-cli.sh && sed 's/\\.ts/\\.js/g' rechrome.ts > rechrome.js && sed 's/\\.ts/\\.js/g' serve.ts > serve.js && bun build extension-token.ts --target=bun --outfile=extension-token.js && bun build daemon-manager.ts --target=bun --outfile=daemon-manager.js && bun build listeners.ts --target=bun --outfile=listeners.js && bash scripts/check-pack.sh"
+    "prepublishOnly": "bash scripts/vendor-cli.sh && sed 's/\\.ts/\\.js/g' rechrome.ts > rechrome.js && sed 's/\\.ts/\\.js/g' serve.ts > serve.js && bun build extension-token.ts --target=bun --outfile=extension-token.js && bun build daemon-manager.ts --target=bun --outfile=daemon-manager.js && bun build listeners.ts --target=bun --outfile=listeners.js && bun build scoped-upload.ts --target=bun --outfile=scoped-upload.js && bash scripts/check-pack.sh"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/rechrome.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { prepareStdinUpload, type UploadPayload } from "./scoped-upload.js";
 import { readListeners, writeListeners, listenerAddress, isLoopback, normalizePrefix, serviceUrl, allowProfiles, denyProfiles, rotateListenerKey, setPublicUrl, canonicalProfileKeys, planProfileRemoval, type Listener } from "./listeners.js";
 
 import { file } from "bun";
@@ -827,18 +828,53 @@ const CHROME_LOCAL_STATE_PATHS = () => {
 
 type ChromeProfileInfo = { user_name?: string; name?: string };
 
+/**
+ * macOS privacy (TCC) blocks a process launched by launchd/oxmgr from Chrome's data folder unless
+ * its binary has Full Disk Access; a Terminal or agent session inherits the grant. Turn that EPERM
+ * into the fix. Undefined for any other error (or platform).
+ */
+export function chromeDataAccessHint(error: unknown, execPath = process.execPath, platform = process.platform): string | undefined {
+  const code = (error as { code?: string } | null)?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  if (platform !== "darwin" || !(code === "EPERM" || code === "EACCES" || /EPERM|operation not permitted/i.test(message))) return undefined;
+  return `macOS privacy settings (TCC) block ${execPath} from reading Chrome's profile folder. ` +
+    `Grant it Full Disk Access: System Settings → Privacy & Security → Full Disk Access → +, press ⌘⇧G, paste ${execPath}, ` +
+    `then restart rech serve. Or run rech serve from Terminal, which already has access (see docs/macos-daemon.md).`;
+}
+
+/** Why the last readChromeProfileCache() returned null (undefined when it succeeded). */
+let profileCacheProblem: string | undefined;
+
 export async function readChromeProfileCache(): Promise<Record<string, ChromeProfileInfo> | null> {
+  profileCacheProblem = undefined;
+  const problems: string[] = [];
   for (const statePath of CHROME_LOCAL_STATE_PATHS()) {
     const f = file(statePath);
     if (!(await f.exists())) continue;
     try {
       const data = JSON.parse(await f.text());
-      return data?.profile?.info_cache ?? null;
-    } catch {}
+      if (data?.profile?.info_cache) return data.profile.info_cache;
+      problems.push(`${statePath} has no profile list`);
+    } catch (error) {
+      const hint = chromeDataAccessHint(error);
+      problems.push(`${statePath} is unreadable (${error instanceof Error ? error.message : String(error)})${hint ? `. ${hint}` : ""}`);
+    }
   }
+  profileCacheProblem = problems.join("; ") || "Chrome's Local State file was not found";
   return null;
 }
 
+/**
+ * Say so (once per process) when profile emails/names are unavailable, so a bare folder name
+ * like "Profile 1" is never mistaken for the whole story.
+ */
+let warnedProfileCache = false;
+export function warnIfProfileNamesUnavailable(cache: Record<string, ChromeProfileInfo> | null): void {
+  if (cache || warnedProfileCache) return;
+  warnedProfileCache = true;
+  console.error(`[rech] Chrome profile emails and names are unavailable (${profileCacheProblem ?? "Local State not read"}); profiles are shown by folder name only.`);
+}
+
 export function resolveChromeProfileSelector(
   profiles: Array<[string, ChromeProfileInfo]>,
   selector: string,
@@ -1306,6 +1342,7 @@ async function listRemoteProfiles(url: string): Promise<void> {
 
 async function listProfiles(): Promise<void> {
   const [cache, registry, root] = await Promise.all([readChromeProfileCache(), readTokenRegistry(), findChromeUserDataDir()]);
+  warnIfProfileNamesUnavailable(cache);
   const profiles = buildProfileRows(cache, registry, root);
   const listeners = await readListeners();
   const url = process.env[ENV_KEY];
@@ -1405,7 +1442,7 @@ export function registeredProfileChoices(registry: Record<string, TokenEntry>, c
     const info = !userDataDir || defaultDirs.includes(userDataDir) ? cache?.[dir] : undefined;
     const names = [info?.name, info?.user_name, key].filter((n): n is string => !!n && n !== dir);
     const shown = [...new Set(names)];
-    return { label: shown.length ? `${shown.join(" · ")}  [${dir}]` : dir, value: key };
+    return { label: shown.length ? `${shown.join(" · ")}  [${dir}]` : `${dir}  (no email or name known)`, value: key };
   });
 }
 
@@ -1639,6 +1676,7 @@ async function printProfileUri(selector?: string, listener?: string, opts: { loc
   const interactive = isInteractive();
   const registry = await readTokenRegistry();
   const cache = await readChromeProfileCache();
+  warnIfProfileNamesUnavailable(cache);
   const cancelled = () => new Error("Cancelled; nothing shared.");
   let config = await readListeners();
   const current = resolveEffectiveProfile(url ? parseUrl(url).profileDirectory : undefined);
@@ -1808,6 +1846,7 @@ async function callServe(
   overrideEnv?: Record<string, string>,
   precomputedIdentity?: { key: string; label: string; profile?: string },
   throwOnFailure = false,
+  upload?: UploadPayload,
 ): Promise<{ status: number; stdout: string; stderr: string; files?: string[]; existingSession?: boolean }> {
   const { key, host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
   // Reuse the caller's identity when provided — computing it shells out to `git` several times,
@@ -1826,7 +1865,7 @@ async function callServe(
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
     // dataDir is a client-local path; the daemon (possibly remote) only needs the session identity.
-    body: JSON.stringify({ args, identity: { key: identity.key, label: identity.label, profile: identity.profile }, env }),
+    body: JSON.stringify({ args, identity: { key: identity.key, label: identity.label, profile: identity.profile }, env, ...(upload ? { upload } : {}) }),
     signal: AbortSignal.timeout(70_000),
   }).catch(async (e) => {
     if (throwOnFailure) throw new Error("Cannot reach the rechrome daemon. Check that it is running.");
@@ -1997,7 +2036,16 @@ export function unknownCommandHint(output: string, rechCommands: Iterable<string
   ].join("\n");
 }
 
-async function run(url: string, args: string[], overrideEnv?: Record<string, string>, opts: { verbatim?: boolean } = {}) {
+/**
+ * An `open` whose extension bridge never connected. Typical right after Chrome restarts: the
+ * relay's connect page reaches no live worker, yet a fresh bridge moments later connects at once
+ * (seen 2026-10-17: a timeout, then `rech setup`'s probe connected in 0.1s). Worth one retry.
+ */
+export function isBridgeTimeout(args: string[], result: { status: number; stderr?: string }): boolean {
+  return args.find(a => !a.startsWith("-")) === "open" && result.status !== 0 && /Extension connection timeout/i.test(result.stderr ?? "");
+}
+
+async function run(url: string, args: string[], overrideEnv?: Record<string, string>, opts: { verbatim?: boolean; bridgeRetried?: boolean } = {}) {
   // 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);
@@ -2012,7 +2060,19 @@ async function run(url: string, args: string[], overrideEnv?: Record<string, str
 
   const resolvedEnv = await getClientEnv({ extensionId, extensionToken, profileDirectory: effectiveProfile, userDataDir, loadExtension });
   const effectiveEnv = { ...resolvedEnv, ...overrideEnv };
-  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, overrideEnv, identity);
+  let upload: UploadPayload | undefined;
+  if (args.find(a => !/^-s=[a-zA-Z0-9_-]{1,64}$/.test(a)) === "upload") {
+    if (process.stdin.isTTY) throw new Error("upload reads stdin; redirect a PNG/SVG file with < icon.png");
+    ({ args, upload } = await prepareStdinUpload(args, process.stdin));
+  }
+  const { status, stdout, stderr, files, existingSession } = await callServe(url, args, overrideEnv, identity, false, upload);
+  if (!opts.bridgeRetried && isBridgeTimeout(args, { status, stderr })) {
+    // Close the failed session so the retry gets a fresh cliDaemon and relay. callServe re-reads
+    // the extension's live token from the profile, so a re-minted token heals here too.
+    console.error(`[rech] the Chrome extension bridge did not answer (common right after Chrome restarts); retrying once with a fresh connection…`);
+    await callServe(url, [...args.filter(a => /^-s=/.test(a)), "close"], overrideEnv, identity).catch(() => {});
+    return run(url, args, overrideEnv, { ...opts, bridgeRetried: true });
+  }
 
   const isOpenWithUrl = args[0] === "open" && args.length > 1;
   if (existingSession && isOpenWithUrl) {
@@ -2032,9 +2092,12 @@ async function run(url: string, args: string[], overrideEnv?: Record<string, str
       // The daemon resolves registered profiles' bridge tokens itself and then asks for a reload;
       // only blame a missing install when neither side had credentials.
       const hasToken = !!effectiveEnv["PLAYWRIGHT_MCP_EXTENSION_TOKEN"] || /reload the .*extension/i.test(stderr);
+      const profileArg = displayProfile ? ` --profile ${JSON.stringify(displayProfile)}` : "";
       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)`;
+        ? `  -x: extension did not connect${opts.bridgeRetried ? " (also after an automatic retry)" : ""} -> extension[degraded]\n` +
+          `[rech] reload "Playwright MCP Bridge" at chrome://extensions${displayProfile ? ` in ${displayProfile}'s window` : ""}, then retry; ` +
+          `or run \`rech setup${profileArg}\`, which re-detects the extension and token and verifies the connection.`
+        : `  -> extension[not installed]  (run: rech setup${profileArg})`;
       console.error(`[rech] rech-client -> rech-server[ok] -> playwright[ok]\n${last}`);
     }
     if (stderr.includes("Browser '") && stderr.includes("is not open")) {
@@ -2069,6 +2132,26 @@ async function run(url: string, args: string[], overrideEnv?: Record<string, str
   process.exit(status);
 }
 
+/** The daemon's Playwright CLI predates `open --wait` (rechrome <= 1.35.1 bundled one). */
+export function cliRejectsWaitOption(output: string): boolean {
+  return /Unknown options?:?[^\n]*?['"`]?--wait\b/i.test(output);
+}
+
+/**
+ * setup's bridge probe: open about:blank without waiting for a load. The daemon owns the CLI and
+ * may be older than this client, so feature-check by behavior: if the CLI rejects `--wait`, probe
+ * again without it rather than reporting a broken bridge.
+ */
+export async function probeBridgeOpen<T extends { status: number; stdout: string; stderr: string }>(
+  call: (args: string[]) => Promise<T>,
+  note: (message: string) => void = () => {},
+): Promise<T> {
+  const probe = await call(["open", "about:blank", "--wait", "none"]);
+  if (probe.status === 0 || !cliRejectsWaitOption(`${probe.stderr}\n${probe.stdout}`)) return probe;
+  note("The daemon's Playwright CLI does not support `open --wait`; probing without it (update rechrome on the daemon host).");
+  return call(["open", "about:blank"]);
+}
+
 export type SetupPhase = "extension" | "token" | "bridge" | "error" | "save" | "ready";
 
 export function createSetupGuide(extDistDir: string, profileDisplay: string) {
@@ -2529,6 +2612,7 @@ export async function daemonInstall(serveUrl: string): Promise<void> {
     [ENV_KEY]: serveUrl,
     PWMCP_TEST_CONNECTION_TIMEOUT: process.env.PWMCP_TEST_CONNECTION_TIMEOUT || "30000",
     PLAYWRIGHT_CLI: resolvedPlaywrightCli,
+    RECH_SERVE_MANAGED: "1", // the manager restarts it; never idle-self-exit (see serve.js)
   };
   if (process.env.RECH_HOST) daemonEnv.RECH_HOST = process.env.RECH_HOST;
   if (isReadable(process.env.RECH_TLS_CERT)) daemonEnv.RECH_TLS_CERT = process.env.RECH_TLS_CERT!;
@@ -3287,7 +3371,7 @@ async function setup(opts: SetupOptions = {}): Promise<void> {
   console.log(`✓ [1/5] Local management daemon verified; requested profile access: ${desiredBind}`);
 
   const cache = await readChromeProfileCache();
-  if (!cache) { console.error("      Chrome profiles not found"); rl?.close(); process.exit(1); }
+  if (!cache) { console.error(`      Chrome profiles not found: ${profileCacheProblem ?? "Local State not read"}`); rl?.close(); process.exit(1); }
   const userDataDir = await findChromeUserDataDir();
 
   async function pickProfile(exclude: Set<string>): Promise<[string, ChromeProfileInfo] | null> {
@@ -3413,12 +3497,9 @@ async function setup(opts: SetupOptions = {}): Promise<void> {
     guide?.takeRetry();
     guide?.update("bridge", "Extension and token detected. Testing the browser connection…");
     try {
-      const probe = await callServe(
-        rechUrl.toString(),
-        [`-s=${probeSession}`, "open", "about:blank", "--wait", "none"],
-        probeEnv,
-        probeIdentity,
-        true,
+      const probe = await probeBridgeOpen(
+        args => callServe(rechUrl.toString(), [`-s=${probeSession}`, ...args], probeEnv, probeIdentity, true),
+        note => console.log(`      ${note}`),
       );
       bridgeVerified = probe.status === 0;
       if (bridgeVerified) {
@@ -3574,7 +3655,7 @@ async function status(): Promise<void> {
     ? await fetch(serviceUrl(url, "ping"), { headers: { Authorization: `Bearer ${parsed.key}` }, signal: AbortSignal.timeout(2000) }).catch(() => null)
     : null;
   const pingBody = pingResponse?.ok
-    ? await pingResponse.json().catch(() => null) as { bind?: string; listener?: string; profiles?: string[] | "*"; degraded?: boolean; consecutiveTimeouts?: number } | null
+    ? await pingResponse.json().catch(() => null) as { bind?: string; listener?: string; profiles?: string[] | "*"; degraded?: boolean; consecutiveTimeouts?: number; chromeAccessProblem?: string } | null
     : null;
   // Show the URL this client connects to; through a proxy, the daemon's bind is on another port.
   const details = [pingBody?.listener && `listener ${pingBody.listener}`, pingBody?.bind && `bind ${pingBody.bind}`].filter(Boolean).join(", ");
@@ -3595,6 +3676,8 @@ async function status(): Promise<void> {
   // No oxmgr/pm2 on PATH must not take down `rech status`: report it instead of throwing.
   let mgr: DaemonManager | undefined;
   if (isHost) try { mgr = daemonManager(); } catch { /* reported below */ }
+  if (pingBody?.chromeAccessProblem)
+    console.log(`chrome:   ⚠ daemon ${pingBody.chromeAccessProblem}`);
   if (pingBody?.degraded)
     console.log(`relay:    ⚠ degraded (${pingBody.consecutiveTimeouts} consecutive command timeouts) — if it persists, the daemon self-restarts; ${isHost ? `force it now with \`${mgr?.id ?? "oxmgr"} restart ${PM_PROCESS_NAME}\`` : "the daemon host can restart it"}`);
   if (isHost) {
@@ -3658,6 +3741,7 @@ const HELP_EPILOGUE = `Browser commands (sent to this project's Chrome session):
 
 Environment:
   ${ENV_KEY}      connection URL; read from the nearest .rechrome/.env.local or .env.local
+  RECHROME_PROFILE  default browser profile selector; --profile overrides it
   RECH_IDENTITY     session key: worktree (default) | branch | cwd
   RECH_TOKEN        extension token for \`rech setup\` (same as --token)
   RECH_SETUP_AGENT  setup hints: codex | claude | none (auto-detected)
@@ -3848,7 +3932,7 @@ if (import.meta.main) {
     if (separator !== -1) args = args.slice(0, separator);
     try {
       const extracted = extractGlobalProfileArg(args);
-      profileSelector = extracted.selector;
+      profileSelector = extracted.selector ?? (process.env.RECHROME_PROFILE?.trim() || undefined);
       args = extracted.args;
     } catch (err) {
       console.error(err instanceof Error ? err.message : String(err));