@monoes/monobrowse 1.0.27 → 1.0.30

package/src/__tests__/profile-dir.test.ts

@@ -0,0 +1,196 @@
+/**
+ * #395: the crash sweep and ownership checks for the temp Chrome profiles
+ * monobrowse creates (profile-dir.ts).
+ *
+ * Every test sweeps a root of its own made with mkdtemp — never the real
+ * /tmp, where other sessions' live Chrome profiles live. (The whole package
+ * run also gets a throwaway TMPDIR, see setup/isolated-tmpdir.global.ts.)
+ */
+
+import { type ChildProcess, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { lutimes, mkdir, mkdtemp, rm, symlink, utimes, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  isOwnedProfileDir,
+  isProfileDirInUse,
+  profileDirOwnerPid,
+  removeOwnedProfileDir,
+  sweepStaleProfileDirs,
+} from '../browser/profile-dir.js';
+
+let root: string;
+let outside: string;
+const children: ChildProcess[] = [];
+const HOUR_AGO = new Date(Date.now() - 60 * 60 * 1000);
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'monobrowse-sweep-root-'));
+  outside = await mkdtemp(join(tmpdir(), 'monobrowse-sweep-outside-'));
+});
+
+afterEach(async () => {
+  for (const child of children.splice(0)) child.kill('SIGKILL');
+  await rm(root, { recursive: true, force: true });
+  await rm(outside, { recursive: true, force: true });
+});
+
+/** A pid that belonged to a process which has since exited. */
+async function deadPid(): Promise<number> {
+  const child = spawn(process.execPath, ['-e', ''], { stdio: 'ignore' });
+  await new Promise((resolve) => child.once('exit', resolve));
+  return child.pid!;
+}
+
+/** A live process whose command line passes `--user-data-dir=<dir>`, the way
+ *  Chrome's own does. */
+async function holder(dir: string): Promise<ChildProcess> {
+  const child = spawn(
+    process.execPath,
+    ['-e', 'setInterval(() => {}, 1000)', '--', `--user-data-dir=${dir}`],
+    { stdio: 'ignore' },
+  );
+  children.push(child);
+  await new Promise((resolve) => child.once('spawn', resolve));
+  return child;
+}
+
+/** A profile-looking directory with some content, backdated past the grace. */
+async function profile(name: string, opts: { young?: boolean } = {}): Promise<string> {
+  const dir = join(root, name);
+  await mkdir(join(dir, 'Default'), { recursive: true });
+  await writeFile(join(dir, 'Default', 'Preferences'), '{}');
+  if (!opts.young) await utimes(dir, HOUR_AGO, HOUR_AGO);
+  return dir;
+}
+
+describe('#395 profileDirOwnerPid', () => {
+  it('reads the pid from exactly our two name patterns', () => {
+    expect(profileDirOwnerPid('monomind-browser-9222-1234-0a1b2c3d')).toBe(1234);
+    expect(profileDirOwnerPid('monomind-browse-4321-0a1b2c3d')).toBe(4321);
+    for (const name of [
+      'monomind-browse-4321-0A1B2C3D',
+      'monomind-browse-4321-0a1b2c3d0',
+      'monomind-browse-x-0a1b2c3d',
+      'monomind-browser-4321-0a1b2c3d',
+      'xmonomind-browse-4321-0a1b2c3d',
+      'org.chromium.Chromium.abc123',
+    ]) {
+      expect(profileDirOwnerPid(name), name).toBeNull();
+    }
+  });
+});
+
+describe('#395 sweepStaleProfileDirs', () => {
+  it('deletes stale dirs whose owner is dead and nothing uses', async () => {
+    const pid = await deadPid();
+    const a = await profile(`monomind-browser-9222-${pid}-aaaaaaaa`);
+    const b = await profile(`monomind-browse-${pid}-bbbbbbbb`);
+
+    const removed = await sweepStaleProfileDirs({ root });
+
+    expect(removed.sort()).toEqual([a, b].sort());
+    expect(existsSync(a)).toBe(false);
+    expect(existsSync(b)).toBe(false);
+  });
+
+  it('keeps young dirs, dirs whose pid is alive, non-matching names, symlinks and files', async () => {
+    const pid = await deadPid();
+    const young = await profile(`monomind-browse-${pid}-cccccccc`, { young: true });
+    const alive = await profile(`monomind-browse-${process.pid}-dddddddd`);
+    const foreign = [
+      await profile('org.chromium.Chromium.abc123'),
+      await profile(`monomind-browse-${pid}-ABCDEF12`),
+      await profile(`monomind-browse-${pid}-abcdef12-extra`),
+      await profile(`other-monomind-browse-${pid}-abcdef12`),
+    ];
+    // A symlink with our name, pointing out of the root at a real profile.
+    const target = join(outside, 'victim');
+    await mkdir(target);
+    await writeFile(join(target, 'keep.txt'), 'keep');
+    const link = join(root, `monomind-browse-${pid}-11111111`);
+    await symlink(target, link);
+    await lutimes(link, HOUR_AGO, HOUR_AGO);
+    // A plain file with our name.
+    const file = join(root, `monomind-browse-${pid}-22222222`);
+    await writeFile(file, 'not a dir');
+    await utimes(file, HOUR_AGO, HOUR_AGO);
+
+    expect(await sweepStaleProfileDirs({ root })).toEqual([]);
+
+    for (const kept of [young, alive, ...foreign, link, file]) expect(existsSync(kept)).toBe(true);
+    expect(existsSync(join(target, 'keep.txt'))).toBe(true);
+  });
+
+  it.skipIf(process.platform !== 'linux')(
+    'keeps a dir a live process uses as --user-data-dir, though its named pid is dead',
+    async () => {
+      // A CLI `open` exits right after launching, so the pid in the name is
+      // dead while its Chrome runs on: only the live user of the dir says so.
+      const pid = await deadPid();
+      const inUse = await profile(`monomind-browse-${pid}-eeeeeeee`);
+      await holder(inUse);
+
+      expect(await sweepStaleProfileDirs({ root })).toEqual([]);
+      expect(existsSync(inUse)).toBe(true);
+    },
+  );
+
+  it('without /proc, keeps a dir whose SingletonLock names a live pid', async () => {
+    const pid = await deadPid();
+    const locked = await profile(`monomind-browse-${pid}-ffffffff`);
+    await symlink(`somehost-${process.pid}`, join(locked, 'SingletonLock'));
+    await utimes(locked, HOUR_AGO, HOUR_AGO);
+    const staleLock = await profile(`monomind-browse-${pid}-99999999`);
+    await symlink(`somehost-${pid}`, join(staleLock, 'SingletonLock'));
+    await utimes(staleLock, HOUR_AGO, HOUR_AGO);
+
+    expect(await sweepStaleProfileDirs({ root, procDir: null })).toEqual([staleLock]);
+    expect(existsSync(locked)).toBe(true);
+  });
+
+  it('never throws, and sweeps nothing, when the root is missing', async () => {
+    await expect(sweepStaleProfileDirs({ root: join(root, 'missing') })).resolves.toEqual([]);
+  });
+});
+
+describe('#395 isOwnedProfileDir / removeOwnedProfileDir', () => {
+  it('refuses a caller-supplied dir, a dir outside the root, and a symlink', async () => {
+    const caller = join(root, 'my-profile');
+    await mkdir(caller);
+    const nested = join(root, 'sub', `monomind-browse-${process.pid}-aaaaaaaa`);
+    await mkdir(nested, { recursive: true });
+    const target = join(outside, 'victim');
+    await mkdir(target);
+    const link = join(root, `monomind-browse-${process.pid}-bbbbbbbb`);
+    await symlink(target, link);
+
+    for (const dir of [caller, nested, link]) {
+      expect(await isOwnedProfileDir(dir, root), dir).toBe(false);
+      expect(await removeOwnedProfileDir(dir, { root }), dir).toBe(false);
+      expect(existsSync(dir), dir).toBe(true);
+    }
+    expect(existsSync(target)).toBe(true);
+  });
+
+  it('removes an owned dir once its browser pid has exited', async () => {
+    const dir = await profile(`monomind-browse-${process.pid}-cccccccc`, { young: true });
+    const pid = await deadPid();
+    expect(await removeOwnedProfileDir(dir, { root, pid })).toBe(true);
+    expect(existsSync(dir)).toBe(false);
+  });
+
+  it.skipIf(process.platform !== 'linux')(
+    'keeps an owned dir while a live process still uses it',
+    async () => {
+      const dir = await profile(`monomind-browse-${process.pid}-dddddddd`, { young: true });
+      const child = await holder(dir);
+      expect(await isProfileDirInUse(dir)).toBe(true);
+      expect(await removeOwnedProfileDir(dir, { root, pid: child.pid })).toBe(false);
+      expect(existsSync(dir)).toBe(true);
+    },
+    15_000,
+  );
+});

package/src/__tests__/setup/isolated-tmpdir.global.ts

@@ -0,0 +1,28 @@
+/**
+ * Vitest globalSetup: run every monobrowse test worker against a throwaway
+ * TMPDIR (#395).
+ *
+ * launchBrowser() sweeps stale `monomind-browser-*` / `monomind-browse-*`
+ * profile dirs out of os.tmpdir() on every launch. The sweep only removes
+ * dead, idle, unused dirs, but a test run must never touch the real /tmp at
+ * all: other sessions' live Chrome profiles live there. Set in the main
+ * process before any worker starts, so workers and the CLI processes tests
+ * spawn inherit it.
+ */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export default function setup(): () => void {
+  const saved = process.env.TMPDIR;
+  // Short on purpose: real-Chrome tests nest their own dirs under it, and
+  // Chrome aborts at startup (SIGABRT) once the unix socket path it makes in
+  // TMPDIR (…/org.chromium.Chromium.XXXXXX/SingletonSocket) passes ~107 bytes.
+  const dir = mkdtempSync(join(tmpdir(), 'mb-'));
+  process.env.TMPDIR = dir;
+  return () => {
+    if (saved === undefined) delete process.env.TMPDIR;
+    else process.env.TMPDIR = saved;
+    rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+  };
+}

package/src/browser/browser-discovery.ts

@@ -25,11 +25,36 @@ export function findChrome(executablePath?: string): string {
   } catch {
     // ignore
   }
+  // A browser some other tool fetched for us (monomind sets this for its own
+  // child processes). Last, so an installed browser always wins.
+  const fromEnv = process.env.MONOBROWSE_CHROME_PATH;
+  if (fromEnv && existsSync(fromEnv)) return fromEnv;
   throw new Error(
     'No supported browser found. Install Google Chrome, Microsoft Edge, or Chromium — or pass executablePath in BrowserConfig.',
   );
 }
 
+let chromeFallback: (() => Promise<string>) | undefined;
+
+/**
+ * Registers where launchBrowser() gets a browser when findChrome() finds none
+ * (monomind downloads one on first use). Pass undefined to clear it.
+ */
+export function setChromeFallback(fallback: (() => Promise<string>) | undefined): void {
+  chromeFallback = fallback;
+}
+
+/** findChrome(), then the registered fallback when no browser is installed.
+ *  An explicit executablePath never falls back. */
+export async function resolveChrome(executablePath?: string): Promise<string> {
+  try {
+    return findChrome(executablePath);
+  } catch (err) {
+    if (executablePath || !chromeFallback) throw err;
+    return chromeFallback();
+  }
+}
+
 export async function isPortOpen(port: number): Promise<boolean> {
   try {
     await fetchTargets(port);

package/src/browser/browser-launch.ts

@@ -3,20 +3,24 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import {
   browserIdOf,
   chromeIdentity,
   fetchBrowserWebSocketUrl,
-  findChrome,
   isChromeIdentity,
   isPortOpen,
   isTcpPortOpen,
   readDevToolsActivePort,
+  resolveChrome,
 } from './browser-discovery.js';
 import { reapIdleLaunchedBrowser } from './browser-lifecycle.js';
-import { launchedPids, launchedUserDataDirs } from './browser-state.js';
+import { launchedPids, launchedUserDataDirs, ownedUserDataDirPorts } from './browser-state.js';
+import {
+  launchProfileDirPath,
+  removeOwnedProfileDir,
+  sweepStaleProfileDirs,
+} from './profile-dir.js';
 import type { BrowserConfig } from './types.js';
 
 const DEFAULT_PORT = 9222;
@@ -32,6 +36,9 @@ const POLL_INTERVAL = 200;
  *  behavior). */
 const LAUNCH_PORT_SCAN_TRIES = 10;
 
+/** Chrome's process exited before its CDP endpoint opened. */
+class ChromeExitedEarlyError extends Error {}
+
 export async function launchBrowser(config: BrowserConfig = {}): Promise<number> {
   const rawPort = config.port ?? DEFAULT_PORT;
   // Port 0 means "let Chrome bind a free port and tell us which" — see
@@ -52,6 +59,10 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
   // is no daemon to do it on a timer. Bounded and non-throwing; a stale
   // instance on the port we are about to use is freed before we probe it.
   await reapIdleLaunchedBrowser();
+  // Same reasoning for temp profile dirs (#395): a process that crashed or
+  // was killed never deleted the one its browser used. Only dead, idle,
+  // unused dirs of our own naming go — see sweepStaleProfileDirs.
+  await sweepStaleProfileDirs();
 
   if (rawPort === 0) return launchOnFreePort(config, 0);
 
@@ -74,6 +85,9 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
   for (let i = 0; i < LAUNCH_PORT_SCAN_TRIES && rawPort + i <= 65535; i++)
     candidates.push(rawPort + i);
 
+  // See the catch below: one early Chrome exit on a candidate nobody holds
+  // afterwards is read as a lost port race, not a broken Chrome.
+  let toleratedEarlyExit: ChromeExitedEarlyError | null = null;
   for (const candidate of candidates) {
     // TCP-level check for "is anything at all listening" — isPortOpen()
     // does a full CDP /json fetch, which returns false BOTH for a genuinely
@@ -110,10 +124,25 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
       // was not a moment ago — a losing race, not a broken Chrome install —
       // so try the next candidate exactly like an already-occupied one,
       // instead of failing the whole launch outright. A candidate that
-      // fails with nothing now listening (a real launch failure — bad
-      // executable, sandbox refusal, etc.) is not a race: retrying the
-      // next candidate would only fail the same way, so surface it as-is.
+      // fails with nothing now listening is usually a real launch failure
+      // (bad executable, sandbox refusal, etc.) that the next candidate would
+      // only repeat, so it is surfaced as-is.
       if (!isLastCandidate && (await isTcpPortOpen(candidate))) continue;
+      // Usually, but not always (#491): two launches that call listen() on
+      // the same port at the same instant can BOTH lose it on Linux — each
+      // socket is marked LISTEN before the kernel checks the port for
+      // conflicts, so each sees the other and gets EADDRINUSE. Both Chromes
+      // exit early and the port is free again, which is indistinguishable
+      // from a Chrome that cannot start. Move on once; a Chrome that really
+      // cannot start exits the same way on the next candidate, and the first
+      // of the two identical failures is surfaced.
+      if (err instanceof ChromeExitedEarlyError) {
+        if (!isLastCandidate && !toleratedEarlyExit) {
+          toleratedEarlyExit = err;
+          continue;
+        }
+        throw toleratedEarlyExit ?? err;
+      }
       throw err;
     }
   }
@@ -150,16 +179,17 @@ export async function launchBrowser(config: BrowserConfig = {}): Promise<number>
  * doomed pid there. It also covers Chrome's [::1] fallback described above.
  */
 async function launchOnFreePort(config: BrowserConfig, port: number): Promise<number> {
-  const chromePath = findChrome(config.executablePath);
+  const chromePath = await resolveChrome(config.executablePath);
   // Unique per launch, not just per port and pid: two concurrent launches
   // that both probe the same candidate port as free (the race this function
   // exists to survive — see the retry-on-collision caller above) would
   // otherwise share one profile directory (lock files, preferences, the
   // DevToolsActivePort file itself) — including two launches from the same
   // process, where a pid suffix alone is identical.
-  const userDataDir =
-    config.userDataDir ??
-    join(tmpdir(), `monomind-browser-${port}-${process.pid}-${randomUUID().slice(0, 8)}`);
+  const userDataDir = config.userDataDir ?? launchProfileDirPath(port, randomUUID().slice(0, 8));
+  // A dir we created is deleted once its browser is gone (#395); a
+  // caller-supplied one only when the caller says it made it for us.
+  const ownsUserDataDir = config.userDataDir === undefined || config.ownsUserDataDir === true;
   const activePortFile = join(userDataDir, 'DevToolsActivePort');
   // A reused profile dir may hold a previous run's file naming a port some
   // other process now owns.
@@ -246,7 +276,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
     earlyFailure ??= new Error(`Chrome failed to start on port ${port}: ${err.message}`);
   });
   child.on('exit', (code, signal) => {
-    earlyFailure ??= new Error(
+    earlyFailure ??= new ChromeExitedEarlyError(
       `Chrome exited before the CDP endpoint opened on port ${port} ` +
         `(code=${code ?? 'null'}, signal=${signal ?? 'null'})`,
     );
@@ -257,6 +287,8 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
     if (!child.pid) return;
     launchedPids.set(boundPort, child.pid);
     launchedUserDataDirs.set(boundPort, userDataDir);
+    if (ownsUserDataDir) ownedUserDataDirPorts.add(boundPort);
+    else ownedUserDataDirPorts.delete(boundPort);
   };
   // Tracked only once Chrome is CONFIRMED up on `boundPort`, not right after
   // spawn(). For port !== 0 this used to track(port) unconditionally the
@@ -291,6 +323,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
 
   const launchTimeout = config.launchTimeoutMs ?? LAUNCH_TIMEOUT;
   const deadline = Date.now() + launchTimeout;
+  let launched = false;
   try {
     while (Date.now() < deadline) {
       if (earlyFailure) throw earlyFailure;
@@ -302,6 +335,7 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
         if (identity === 'chrome') {
           if (await isOwnEndpoint(boundPort)) {
             track(boundPort);
+            launched = true;
             return boundPort;
           }
           // Some Chrome answers on the port, but not the one we started: a
@@ -350,6 +384,10 @@ async function launchOnFreePort(config: BrowserConfig, port: number): Promise<nu
     throw new Error(`Chrome failed to start on port ${port} within ${launchTimeout}ms`);
   } finally {
     child.stderr?.destroy();
+    // A failed launch (lost port race, refusal, timeout) is never tracked,
+    // so no close will ever clean its profile — and the port-scan retry in
+    // launchBrowser can make several of these per call.
+    if (!launched && ownsUserDataDir) await removeOwnedProfileDir(userDataDir, { pid: child.pid });
   }
 }
 

package/src/browser/browser-lifecycle.ts

@@ -1,8 +1,9 @@
 // Split out of browser.ts (file-size sweep). Pure move: no behaviour change.
 
 import { fetchBrowserWebSocketUrl } from './browser-discovery.js';
-import { launchedPids, launchedUserDataDirs } from './browser-state.js';
+import { launchedPids, launchedUserDataDirs, ownedUserDataDirPorts } from './browser-state.js';
 import { CdpClient, fetchTargets } from './cdp.js';
+import { removeOwnedProfileDir } from './profile-dir.js';
 import {
   listSessionRecords,
   loadSessionRecord,
@@ -41,6 +42,11 @@ const REAP_CONNECT_TIMEOUT_MS = 3000;
  * singleton lock, and if the caller's process exited first the kill never
  * happened at all. Callers reasonably read a resolved close() as "that
  * browser is gone"; on the graceful path it now means that.
+ *
+ * A profile directory monobrowse created for that browser (the default temp
+ * profile, or a CLI session's — never a caller-supplied one) is deleted once
+ * the process is gone, on both paths (#395). In a fresh process the dir and
+ * its ownership come from the persisted session record.
  */
 export async function closeBrowser(client: CdpClient, port: number): Promise<void> {
   let gracefullyClosed = false;
@@ -71,6 +77,7 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
   }
 
   let pid = launchedPids.get(port);
+  let profileDir = ownedUserDataDirPorts.has(port) ? launchedUserDataDirs.get(port) : undefined;
   if (pid === undefined) {
     // Fresh process (each CLI invocation is its own node process — see
     // module header) — launchedPids is per-process and empty here even
@@ -89,6 +96,7 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
         const age = persisted.savedAt !== undefined ? Date.now() - persisted.savedAt : undefined;
         if (age === undefined || age <= PERSISTED_PID_MAX_AGE_MS) {
           pid = persisted.pid;
+          if (persisted.ownsUserDataDir) profileDir = persisted.userDataDir;
         }
       }
     } catch {
@@ -97,6 +105,7 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
   }
   if (pid === undefined) return; // not a process we launched, or too stale to trust — nothing to kill
   launchedPids.delete(port);
+  ownedUserDataDirPorts.delete(port);
 
   // Liveness-check before every SIGKILL (not just the safety-net path below)
   // — process.kill(pid, 0) throws ESRCH if the PID is no longer running,
@@ -109,17 +118,18 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
     } catch {
       /* already exited, or never was — nothing to do */
     }
-    return;
+  } else if (!(await waitForProcessExit(pid))) {
+    // Browser.close was acknowledged — wait for the process to actually go
+    // away, then force-kill as a safety net in case it hung.
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      /* raced us to exit — expected */
+    }
   }
 
-  // Browser.close was acknowledged — wait for the process to actually go away,
-  // then force-kill as a safety net in case it hung.
-  if (await waitForProcessExit(pid)) return;
-  try {
-    process.kill(pid, 'SIGKILL');
-  } catch {
-    /* raced us to exit — expected */
-  }
+  // Waits (bounded) for the killed process to be gone before deleting.
+  if (profileDir) await removeOwnedProfileDir(profileDir, { pid });
 }
 
 /** Poll until `pid` is gone or PROCESS_EXIT_TIMEOUT_MS elapses. Returns

package/src/browser/browser-state.ts

@@ -6,9 +6,12 @@
 // to (already-running browser) are never recorded here — we only ever kill
 // processes we launched ourselves.
 export const launchedPids = new Map<number, number>();
-// userDataDir per launched port — informational, persisted alongside the pid
-// so a later process could clean up the temp profile dir too if ever needed.
+// userDataDir per launched port, persisted alongside the pid so a later
+// process can clean up the temp profile dir too (#395).
 export const launchedUserDataDirs = new Map<number, string>();
+// Launched ports whose userDataDir monobrowse created itself (not one the
+// caller supplied). Only these profile dirs are ever deleted on close.
+export const ownedUserDataDirPorts = new Set<number>();
 
 /** PID of the Chrome instance *this process* launched on `port`, if any. */
 export function getLaunchedPid(port: number): number | undefined {
@@ -19,3 +22,9 @@ export function getLaunchedPid(port: number): number | undefined {
 export function getLaunchedUserDataDir(port: number): string | undefined {
   return launchedUserDataDirs.get(port);
 }
+
+/** Whether the userDataDir of the Chrome *this process* launched on `port`
+ *  was created by monobrowse, and so is deleted when that browser closes. */
+export function ownsLaunchedUserDataDir(port: number): boolean {
+  return ownedUserDataDirPorts.has(port);
+}

package/src/browser/browser.ts

@@ -3,7 +3,7 @@
 // re-exports everything it used to define, so every existing import path
 // keeps working.
 
-export { isPortOpen } from './browser-discovery.js';
+export { findChrome, isPortOpen, setChromeFallback } from './browser-discovery.js';
 export { launchBrowser } from './browser-launch.js';
 export { closeBrowser, reapIdleLaunchedBrowser } from './browser-lifecycle.js';
 export {
@@ -14,4 +14,8 @@ export {
   openUrl,
   waitForLoad,
 } from './browser-page.js';
-export { getLaunchedPid, getLaunchedUserDataDir } from './browser-state.js';
+export {
+  getLaunchedPid,
+  getLaunchedUserDataDir,
+  ownsLaunchedUserDataDir,
+} from './browser-state.js';