@ricsam/r5d-browser 0.0.51 → 0.0.53

package/dist/cjs/main.cjs

@@ -25,35 +25,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
-var import_node_child_process = require("node:child_process");
-var import_promises = require("node:timers/promises");
 var import_ws = __toESM(require("ws"), 1);
-var import_playwright_install = require("./playwright-install.cjs");
+var import_browser_runtime = require("./browser-runtime.cjs");
+var import_cli_options = require("./cli-options.cjs");
+var import_chrome_launcher = require("./chrome-launcher.cjs");
 var import_port_forward_manager = require("./port-forward-manager.cjs");
 const DEFAULT_BASE_URL = "https://r5d.dev";
 const PACKAGE_NAME = "@ricsam/r5d-browser";
 const RECONNECT_DELAY_MS = 2e3;
 const SERVER_HEARTBEAT_TIMEOUT_MS = 45e3;
-const MAX_DOWNLOAD_CHUNK_BYTES = 1024 * 1024;
+const CHROME_DISCONNECT_EXIT_GRACE_MS = 2e3;
 function browserRoot() {
   return import_node_path.default.join(import_node_os.default.homedir(), ".r5d", "browser");
 }
-function defaultConfigPath() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".config", "r5d", "r5dctl", "config.json");
-}
 function printHelp() {
   process.stdout.write(`Usage:
   r5d-browser start [--base-url <url>] [--token <token>] [--api-key <key>]
-  r5d-browser install
   r5d-browser --version
 
 Options:
   --base-url <url>      r5d.dev base URL (default from r5dctl config or ${DEFAULT_BASE_URL})
-  --token <token>       Interactive r5d token
+  --token <token>       r5d device credential
   --api-key <key>       r5d API key
   --config <path>       Shared r5dctl config path
-  --profile <path>      Chromium profile path (default ~/.r5d/browser/profile)
-  --browsers-path <dir> Playwright browser binaries (default ~/.r5d/browser/browsers)
+  --profile <path>      Google Chrome profile path (default ~/.r5d/browser/chrome-profile)
+  --chrome-path <path>  Google Chrome executable (default: auto-detect stable Chrome)
   -v, --version         Show r5d-browser version
   -h, --help            Show this help
 `);
@@ -77,53 +73,6 @@ function findVersion() {
   }
   return "unknown";
 }
-function parseArgs(argv) {
-  const options = { configPath: defaultConfigPath(), help: false, version: false };
-  const rest = [];
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) continue;
-    if (arg === "-h" || arg === "--help") {
-      options.help = true;
-      continue;
-    }
-    if (arg === "-v" || arg === "--version") {
-      options.version = true;
-      continue;
-    }
-    const readOption = (name) => {
-      if (arg === name) {
-        index += 1;
-        const value = argv[index];
-        if (!value) throw new Error(`Missing value for ${name}`);
-        return value;
-      }
-      return arg.startsWith(`${name}=`) ? arg.slice(name.length + 1) : void 0;
-    };
-    const entries = [
-      ["--base-url", "baseUrl"],
-      ["--token", "token"],
-      ["--api-key", "apiKey"],
-      ["--config", "configPath"],
-      ["--profile", "profilePath"],
-      ["--browsers-path", "browsersPath"]
-    ];
-    let matched = false;
-    for (const [name, key] of entries) {
-      const value = readOption(name);
-      if (value !== void 0) {
-        options[key] = value;
-        matched = true;
-        break;
-      }
-    }
-    if (!matched) rest.push(arg);
-  }
-  if (options.version) return { command: "version", options };
-  if (options.help || rest.length === 0) return { command: "help", options };
-  if (rest[0] !== "start" && rest[0] !== "install") throw new Error(`Unknown command: ${rest[0]}`);
-  return { command: rest[0], options };
-}
 function readConfig(configPath) {
   if (!import_node_fs.default.existsSync(configPath)) return {};
   const parsed = JSON.parse(import_node_fs.default.readFileSync(configPath, "utf8"));
@@ -145,18 +94,6 @@ function resolveConnection(options) {
     token
   };
 }
-function installChromium(browsersPath) {
-  import_node_fs.default.mkdirSync(browsersPath, { recursive: true });
-  process.env.PLAYWRIGHT_BROWSERS_PATH = browsersPath;
-  const cliPath = (0, import_playwright_install.resolvePlaywrightCliPath)();
-  process.stdout.write(`[r5d-browser] Installing Chromium under ${browsersPath}...
-`);
-  const result = (0, import_node_child_process.spawnSync)(process.execPath, [cliPath, "install", "chromium"], {
-    stdio: "inherit",
-    env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: browsersPath }
-  });
-  if (result.status !== 0) throw new Error(`Chromium installation failed with exit code ${result.status ?? "unknown"}.`);
-}
 function loadInstanceId() {
   const instancePath = import_node_path.default.join(browserRoot(), "instance-id");
   import_node_fs.default.mkdirSync(import_node_path.default.dirname(instancePath), { recursive: true });
@@ -170,271 +107,37 @@ function loadInstanceId() {
 `, { mode: 384 });
   return id;
 }
-class BrowserRuntime {
-  constructor(context, downloadsPath) {
-    this.context = context;
-    this.downloadsPath = downloadsPath;
-    import_node_fs.default.mkdirSync(downloadsPath, { recursive: true });
-    for (const page of context.pages()) this.track(page);
-    context.on("page", (page) => this.track(page));
-  }
-  context;
-  downloadsPath;
-  ids = /* @__PURE__ */ new WeakMap();
-  pages = /* @__PURE__ */ new Map();
-  cursor = /* @__PURE__ */ new Map();
-  downloadSaveQueue = Promise.resolve();
-  track(page) {
-    const existing = this.ids.get(page);
-    if (existing) return existing;
-    const id = crypto.randomUUID();
-    this.ids.set(page, id);
-    this.pages.set(id, page);
-    page.on("download", (download) => {
-      this.downloadSaveQueue = this.downloadSaveQueue.then(() => this.persistDownload(download)).catch((error) => {
-        process.stderr.write(`[r5d-browser] failed to save download: ${error instanceof Error ? error.message : String(error)}
-`);
-      });
-    });
-    page.once("close", () => {
-      this.pages.delete(id);
-      this.cursor.delete(id);
-    });
-    return id;
-  }
-  safeDownloadFilename(suggestedFilename) {
-    const basename = import_node_path.default.basename(suggestedFilename).replace(/[\\/\0]/g, "-").trim();
-    if (!basename || basename === "." || basename === "..") return "download";
-    const extension = import_node_path.default.extname(basename).slice(0, 30);
-    let stem = basename.slice(0, basename.length - import_node_path.default.extname(basename).length) || "download";
-    while (Buffer.byteLength(`${stem}${extension}`) > 200) stem = stem.slice(0, -1);
-    return `${stem || "download"}${extension}`;
-  }
-  availableDownloadPath(suggestedFilename) {
-    const filename = this.safeDownloadFilename(suggestedFilename);
-    const extension = import_node_path.default.extname(filename);
-    const stem = filename.slice(0, filename.length - extension.length) || "download";
-    for (let suffix = 1; ; suffix += 1) {
-      const candidate = suffix === 1 ? filename : `${stem}-${suffix}${extension}`;
-      const candidatePath = import_node_path.default.join(this.downloadsPath, candidate);
-      if (!import_node_fs.default.existsSync(candidatePath)) return candidatePath;
-    }
-  }
-  async persistDownload(download) {
-    const failure = await download.failure();
-    if (failure) throw new Error(failure);
-    const targetPath = this.availableDownloadPath(download.suggestedFilename());
-    await download.saveAs(targetPath);
-    process.stdout.write(`[r5d-browser] downloaded ${import_node_path.default.basename(targetPath)}
-`);
-  }
-  downloadId(filename) {
-    return Buffer.from(filename, "utf8").toString("base64url");
-  }
-  resolveDownload(downloadId) {
-    if (typeof downloadId !== "string" || !downloadId) throw new Error("downloadId is required.");
-    const filename = Buffer.from(downloadId, "base64url").toString("utf8");
-    if (this.downloadId(filename) !== downloadId || filename !== import_node_path.default.basename(filename) || filename.includes("\0")) {
-      throw new Error("Invalid downloadId.");
-    }
-    const filePath = import_node_path.default.join(this.downloadsPath, filename);
-    let stats;
-    try {
-      stats = import_node_fs.default.lstatSync(filePath);
-    } catch {
-      throw new Error(`Browser download ${downloadId} no longer exists.`);
-    }
-    if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Browser download is not a regular file.");
-    return { filename, filePath, stats };
-  }
-  async listDownloads() {
-    await this.downloadSaveQueue;
-    return import_node_fs.default.readdirSync(this.downloadsPath, { withFileTypes: true }).flatMap((entry) => {
-      if (!entry.isFile() || entry.name.startsWith(".")) return [];
-      const { filename, stats } = this.resolveDownload(this.downloadId(entry.name));
-      return [
-        {
-          downloadId: this.downloadId(filename),
-          filename,
-          size: stats.size,
-          modifiedAt: stats.mtime.toISOString()
-        }
-      ];
-    }).sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt) || left.filename.localeCompare(right.filename));
-  }
-  async getDownloadChunk(input) {
-    await this.downloadSaveQueue;
-    const { filename, filePath, stats } = this.resolveDownload(input.downloadId);
-    const offset = input.offset === void 0 ? 0 : Number(input.offset);
-    const requestedBytes = input.maxBytes === void 0 ? MAX_DOWNLOAD_CHUNK_BYTES : Number(input.maxBytes);
-    if (!Number.isSafeInteger(offset) || offset < 0 || offset > stats.size) throw new Error("Invalid download offset.");
-    if (!Number.isSafeInteger(requestedBytes) || requestedBytes < 1) throw new Error("Invalid download chunk size.");
-    const chunkSize = Math.min(requestedBytes, MAX_DOWNLOAD_CHUNK_BYTES, stats.size - offset);
-    const bytes = Buffer.alloc(chunkSize);
-    const handle = import_node_fs.default.openSync(filePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
-    let bytesRead = 0;
-    try {
-      const openedStats = import_node_fs.default.fstatSync(handle);
-      if (!openedStats.isFile() || openedStats.dev !== stats.dev || openedStats.ino !== stats.ino) {
-        throw new Error("Browser download changed before it could be read.");
-      }
-      bytesRead = import_node_fs.default.readSync(handle, bytes, 0, chunkSize, offset);
-      const completedStats = import_node_fs.default.fstatSync(handle);
-      if (completedStats.size !== stats.size || completedStats.mtimeMs !== stats.mtimeMs) {
-        throw new Error("Browser download changed while it was being read.");
-      }
-    } finally {
-      import_node_fs.default.closeSync(handle);
-    }
-    const nextOffset = offset + bytesRead;
-    return {
-      downloadId: this.downloadId(filename),
-      filename,
-      size: stats.size,
-      modifiedAt: stats.mtime.toISOString(),
-      offset,
-      nextOffset,
-      eof: nextOffset === stats.size,
-      base64: bytes.subarray(0, bytesRead).toString("base64")
+async function waitForReconnectDelay(signal) {
+  if (signal.aborted) return;
+  await new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
     };
-  }
-  page(tabId) {
-    if (typeof tabId !== "string") throw new Error("tabId is required.");
-    const page = this.pages.get(tabId);
-    if (!page || page.isClosed()) throw new Error(`Browser tab ${tabId} is no longer open.`);
-    return page;
-  }
-  async tabInfo(page) {
-    const tabId = this.track(page);
-    let windowId = "unknown";
-    try {
-      const cdp = await this.context.newCDPSession(page);
-      const result = await cdp.send("Browser.getWindowForTarget");
-      windowId = String(result.windowId);
-      await cdp.detach();
-    } catch {
-    }
-    return { tabId, windowId, title: await page.title().catch(() => ""), url: page.url() };
-  }
-  async listTabs() {
-    return await Promise.all([...this.pages.values()].filter((page) => !page.isClosed()).map((page) => this.tabInfo(page)));
-  }
-  async execute(action, input) {
-    if (action === "list_tabs") return { tabs: await this.listTabs() };
-    if (action === "list_downloads") return { downloads: await this.listDownloads() };
-    if (action === "get_download") return await this.getDownloadChunk(input);
-    if (action === "open_tab") {
-      const previous = this.context.pages().findLast((candidate) => !candidate.isClosed());
-      let page2;
-      if (previous) {
-        const cdp = await this.context.newCDPSession(previous);
-        const pagePromise = this.context.waitForEvent("page");
-        await cdp.send("Target.createTarget", {
-          url: "about:blank",
-          newWindow: input.disposition === "window",
-          background: true
-        });
-        page2 = await pagePromise;
-        await cdp.detach();
-        if (input.disposition === "window") {
-          const pageCdp = await this.context.newCDPSession(page2);
-          const { windowId } = await pageCdp.send("Browser.getWindowForTarget");
-          await pageCdp.send("Browser.setWindowBounds", { windowId, bounds: { windowState: "minimized" } });
-          await pageCdp.detach();
-        }
-      } else {
-        page2 = await this.context.newPage();
-      }
-      const url = typeof input.url === "string" ? input.url : "about:blank";
-      if (url !== "about:blank") await page2.goto(url, { waitUntil: "domcontentloaded" });
-      return { tab: await this.tabInfo(page2) };
-    }
-    const page = this.page(input.tabId);
-    const tabId = input.tabId;
-    switch (action) {
-      case "close_tab":
-        await page.close();
-        return { closed: true, tabId };
-      case "navigate":
-        await page.goto(String(input.url), { waitUntil: "domcontentloaded" });
-        return { tab: await this.tabInfo(page) };
-      case "screenshot": {
-        const bytes = await page.screenshot({ type: "png" });
-        const viewport = page.viewportSize();
-        const cursor = this.cursor.get(tabId);
-        return {
-          base64: bytes.toString("base64"),
-          width: viewport?.width ?? Number(await page.evaluate(() => window.innerWidth)),
-          height: viewport?.height ?? Number(await page.evaluate(() => window.innerHeight)),
-          cursorX: cursor?.x,
-          cursorY: cursor?.y
-        };
-      }
-      case "move_mouse": {
-        const x = Number(input.x);
-        const y = Number(input.y);
-        if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("move_mouse requires numeric x and y coordinates.");
-        await page.mouse.move(x, y);
-        this.cursor.set(tabId, { x, y });
-        return { tabId, x, y };
-      }
-      case "mouse_click": {
-        const cursor = this.cursor.get(tabId);
-        if (!cursor) throw new Error("Move the mouse in this tab before clicking.");
-        const button = input.button === "middle" || input.button === "right" ? input.button : "left";
-        await page.mouse.click(cursor.x, cursor.y, { button, clickCount: input.clickCount === 2 ? 2 : 1 });
-        return { tabId, ...cursor, button };
-      }
-      case "keyboard": {
-        const keys = Array.isArray(input.keys) ? input.keys : [];
-        const modifiers = Array.isArray(input.modifiers) ? input.modifiers.filter((value) => typeof value === "string") : [];
-        for (const modifier of modifiers) await page.keyboard.down(modifier);
-        try {
-          for (const key of keys) {
-            if (typeof key !== "string") throw new Error("keyboard keys must all be strings.");
-            await page.keyboard.press(key);
-          }
-        } finally {
-          for (const modifier of modifiers.toReversed()) await page.keyboard.up(modifier);
-        }
-        return { tabId, keys, modifiers };
-      }
-      case "keyboard_type":
-        if (typeof input.text !== "string") throw new Error("keyboard_type requires text.");
-        await page.keyboard.insertText(input.text);
-        return { tabId, characters: input.text.length };
-      case "run_js": {
-        if (typeof input.code !== "string") throw new Error("run_js requires code.");
-        const result = await page.evaluate(async (code) => {
-          const invoke = new Function(`"use strict"; return (async () => {
-${code}
-})()`);
-          return await invoke();
-        }, input.code);
-        const serialized = JSON.stringify(result);
-        if (serialized && Buffer.byteLength(serialized) > 1024 * 1024) {
-          throw new Error("Browser JavaScript result exceeded the 1 MiB limit.");
-        }
-        return { tabId, result };
-      }
-      default:
-        throw new Error(`Unsupported browser operation: ${action}`);
-    }
-  }
+    const timer = setTimeout(finish, RECONNECT_DELAY_MS);
+    signal.addEventListener("abort", finish, { once: true });
+  });
 }
 async function connectLoop(params) {
-  for (; ; ) {
+  while (!params.signal.aborted) {
     const url = new URL("/browser/ws", params.baseUrl);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     url.searchParams.set("instance", params.instanceId);
     url.searchParams.set("version", findVersion());
     let socket = null;
+    let watchdog;
+    const closeForAbort = () => socket?.close(1e3, "r5d-browser shutting down");
     try {
       socket = new import_ws.default(url, { headers: { Authorization: `Bearer ${params.token}` } });
+      socket.on("error", () => void 0);
+      params.signal.addEventListener("abort", closeForAbort, { once: true });
       await new Promise((resolve, reject) => {
         socket.addEventListener("open", () => resolve(), { once: true });
         socket.addEventListener("error", () => reject(new Error("WebSocket connection failed.")), { once: true });
+        socket.addEventListener("close", () => reject(new Error("WebSocket closed before connecting.")), { once: true });
       });
+      if (params.signal.aborted) break;
       process.stdout.write(`[r5d-browser] connected to ${params.baseUrl}
 `);
       socket.send(
@@ -454,11 +157,12 @@ async function connectLoop(params) {
         })
       );
       let lastServerMessageAt = Date.now();
-      const watchdog = setInterval(() => {
+      watchdog = setInterval(() => {
         if (Date.now() - lastServerMessageAt >= SERVER_HEARTBEAT_TIMEOUT_MS) socket?.close();
       }, 5e3);
       await new Promise((resolve) => {
         socket.addEventListener("message", (event) => {
+          if (params.signal.aborted) return;
           lastServerMessageAt = Date.now();
           void (async () => {
             const message = JSON.parse(String(event.data));
@@ -469,9 +173,7 @@ async function connectLoop(params) {
             if (message.type === "port_forward_start") {
               try {
                 await params.portForwards.start(message.forward);
-                socket?.send(
-                  JSON.stringify({ type: "port_forward_result", requestId: message.requestId, forward: message.forward })
-                );
+                socket?.send(JSON.stringify({ type: "port_forward_result", requestId: message.requestId, forward: message.forward }));
               } catch (error) {
                 socket?.send(
                   JSON.stringify({
@@ -521,69 +223,174 @@ async function connectLoop(params) {
         });
         socket.addEventListener("close", () => resolve(), { once: true });
       });
-      clearInterval(watchdog);
     } catch (error) {
-      process.stderr.write(`[r5d-browser] ${error instanceof Error ? error.message : String(error)}
+      if (!params.signal.aborted) process.stderr.write(`[r5d-browser] ${error instanceof Error ? error.message : String(error)}
 `);
     } finally {
+      if (watchdog) clearInterval(watchdog);
+      params.signal.removeEventListener("abort", closeForAbort);
       socket?.close();
     }
+    if (params.signal.aborted) break;
     process.stdout.write(`[r5d-browser] disconnected; reconnecting...
 `);
-    await (0, import_promises.setTimeout)(RECONNECT_DELAY_MS);
+    await waitForReconnectDelay(params.signal);
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function waitUpTo(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise.then(() => true),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function resultWithin(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
   }
 }
 async function start(options) {
   if (process.platform !== "darwin") throw new Error("r5d-browser currently supports macOS only.");
   const { baseUrl, token } = resolveConnection(options);
-  const browsersPath = import_node_path.default.resolve(options.browsersPath ?? import_node_path.default.join(browserRoot(), "browsers"));
-  const profilePath = import_node_path.default.resolve(options.profilePath ?? import_node_path.default.join(browserRoot(), "profile"));
+  const requestedProfilePath = import_node_path.default.resolve(options.profilePath ?? (0, import_chrome_launcher.defaultChromeProfilePath)());
   const downloadsPath = import_node_path.default.join(browserRoot(), "downloads");
   const playwrightDownloadsPath = import_node_path.default.join(downloadsPath, ".playwright");
-  process.env.PLAYWRIGHT_BROWSERS_PATH = browsersPath;
-  let playwright = await import("playwright");
-  if (!import_node_fs.default.existsSync(playwright.chromium.executablePath())) {
-    installChromium(browsersPath);
-    playwright = await import("playwright");
-  }
-  import_node_fs.default.mkdirSync(profilePath, { recursive: true });
-  import_node_fs.default.mkdirSync(playwrightDownloadsPath, { recursive: true });
-  const context = await playwright.chromium.launchPersistentContext(profilePath, {
-    headless: false,
-    viewport: { width: 1440, height: 900 },
-    acceptDownloads: true,
-    downloadsPath: playwrightDownloadsPath
+  import_node_fs.default.mkdirSync(playwrightDownloadsPath, { recursive: true, mode: 448 });
+  let requestedSignalOutcome;
+  let requestStop = () => void 0;
+  const requestedStop = new Promise((resolve) => {
+    requestStop = resolve;
   });
-  if (context.pages().length === 0) await context.newPage();
-  const runtime = new BrowserRuntime(context, downloadsPath);
-  const instanceId = loadInstanceId();
-  const portForwards = new import_port_forward_manager.BrowserPortForwardManager(baseUrl, token, instanceId);
-  process.stdout.write(`[r5d-browser] profile: ${profilePath}
+  const signalHandlers = /* @__PURE__ */ new Map();
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    const handler = () => {
+      requestedSignalOutcome ??= { exitCode: 0 };
+      requestStop(requestedSignalOutcome);
+    };
+    signalHandlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  let launch;
+  try {
+    launch = await (0, import_chrome_launcher.launchStableChrome)({
+      chromePath: options.chromePath,
+      profilePath: requestedProfilePath,
+      playwrightDownloadsPath,
+      lockPath: (0, import_chrome_launcher.defaultChromeLockPath)()
+    });
+  } catch (error) {
+    for (const [signal, handler] of signalHandlers) process.off(signal, handler);
+    throw error;
+  }
+  if (requestedSignalOutcome) {
+    try {
+      await launch.close();
+    } finally {
+      for (const [signal, handler] of signalHandlers) process.off(signal, handler);
+    }
+    return;
+  }
+  try {
+    const profilePath = launch.profilePath;
+    const runtime = new import_browser_runtime.BrowserRuntime(launch.context, downloadsPath);
+    const instanceId = loadInstanceId();
+    const portForwards = new import_port_forward_manager.BrowserPortForwardManager(baseUrl, token, instanceId);
+    process.stdout.write(`[r5d-browser] profile: ${profilePath}
 `);
-  process.stdout.write(`[r5d-browser] downloads: ${downloadsPath}
+    process.stdout.write(`[r5d-browser] downloads: ${downloadsPath}
 `);
-  process.stdout.write(`[r5d-browser] agents use synthetic Chromium input; your system pointer and keyboard stay untouched.
+    process.stdout.write(`[r5d-browser] Google Chrome ${launch.chromeVersion}; navigator.webdriver is disabled.
 `);
-  const shutdown = () => void Promise.all([portForwards.close(), context.close()]).finally(() => process.exit(0));
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  return connectLoop({
-    runtime,
-    portForwards,
-    baseUrl,
-    token,
-    instanceId,
-    profilePath,
-    chromiumVersion: context.browser()?.version() ?? "unknown"
-  });
+    process.stdout.write(`[r5d-browser] agents use synthetic Chrome input; your system pointer and keyboard stay untouched.
+`);
+    const abortController = new AbortController();
+    const controlLoop = connectLoop({
+      runtime,
+      portForwards,
+      baseUrl,
+      token,
+      instanceId,
+      profilePath,
+      chromiumVersion: launch.chromeVersion,
+      signal: abortController.signal
+    });
+    const controlStopped = controlLoop.then(
+      () => ({ exitCode: abortController.signal.aborted ? 0 : 1, message: "The r5d.dev browser control loop stopped unexpectedly." }),
+      (error) => ({
+        exitCode: 1,
+        message: `The r5d.dev browser control loop failed: ${error instanceof Error ? error.message : String(error)}`
+      })
+    );
+    const chromeExited = launch.exited.then(({ code, signal }) => ({
+      exitCode: code === 0 ? 0 : 1,
+      message: code === 0 ? void 0 : `Google Chrome exited unexpectedly (${signal ? `signal ${signal}` : `code ${code ?? "unknown"}`}).`
+    }));
+    const chromeDisconnected = launch.disconnected.then(async () => {
+      const exitOutcome = await resultWithin(chromeExited, CHROME_DISCONNECT_EXIT_GRACE_MS);
+      if (exitOutcome) return exitOutcome;
+      if (!isProcessAlive(launch.chromePid)) return await chromeExited;
+      return { exitCode: 1, message: "The Google Chrome control connection closed unexpectedly." };
+    });
+    const outcome = await Promise.race([requestedStop, chromeExited, chromeDisconnected, controlStopped]);
+    abortController.abort();
+    let cleanupError;
+    try {
+      await portForwards.close();
+    } catch (error) {
+      cleanupError = error;
+    }
+    try {
+      if (!await waitUpTo(runtime.drainDownloads(), 5e3)) {
+        process.stderr.write("[r5d-browser] timed out waiting for active downloads during shutdown.\n");
+      }
+    } catch (error) {
+      cleanupError ??= error;
+    }
+    try {
+      await launch.close();
+    } catch (error) {
+      cleanupError ??= error;
+    }
+    await controlStopped;
+    for (const [signal, handler] of signalHandlers) process.off(signal, handler);
+    if (outcome.exitCode !== 0) throw new Error(outcome.message ?? "Google Chrome stopped unexpectedly.");
+    if (cleanupError) throw cleanupError;
+  } catch (error) {
+    try {
+      await launch.close().catch(() => void 0);
+    } finally {
+      for (const [signal, handler] of signalHandlers) process.off(signal, handler);
+    }
+    throw error;
+  }
 }
 async function main() {
-  const { command, options } = parseArgs(process.argv.slice(2));
+  const { command, options } = (0, import_cli_options.parseBrowserArgs)(process.argv.slice(2));
   if (command === "help") return printHelp();
   if (command === "version") return void process.stdout.write(`r5d-browser ${findVersion()}
 `);
-  const browsersPath = import_node_path.default.resolve(options.browsersPath ?? import_node_path.default.join(browserRoot(), "browsers"));
-  if (command === "install") return installChromium(browsersPath);
   await start(options);
 }
 main().catch((error) => {

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-browser",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "type": "commonjs"
 }

package/dist/cjs/port-forward-manager.cjs

@@ -205,7 +205,7 @@ class BrowserPortForwardManager {
         socket.once("drain", () => relay.resume());
       }
     });
-    relay.once("error", cleanup);
+    relay.on("error", cleanup);
     relay.once("close", cleanup);
     socket.on("data", (chunk) => {
       if (!ready || relay.readyState !== import_ws.default.OPEN) {