@browserbridge/bbx 1.7.5 → 1.7.7

package/packages/native-host/src/daemon-process.js

@@ -260,8 +260,9 @@ export async function stopBridgeDaemon(options = {}) {
     previousPid = endpointOwnerPid;
     previouslyRunning = true;
   } else if (reachable) {
-    // TCP endpoints do not expose an owner pid. In that case daemon
-    // reachability is the evidence supporting the recorded pid.
+    // When the endpoint owner is not discoverable (no verified TCP listener,
+    // lsof and ss both unavailable), daemon reachability is the evidence
+    // supporting the recorded pid.
     previousPid = pidFromFile;
     previouslyRunning = true;
   }
@@ -407,10 +408,17 @@ async function restartBridgeDaemonAfterStop(stopResult, options = {}) {
     throw new Error('Timed out waiting for Browser Bridge daemon to start.');
   }
 
+  let pid = await readPidFn(pidPath);
+  if (pid === null) {
+    // The daemon starts listening immediately before it persists its PID.
+    await sleepFn(pollIntervalMs);
+    pid = await readPidFn(pidPath);
+  }
+
   return {
     ...stopResult,
     pidPath,
-    pid: await readPidFn(pidPath),
+    pid,
   };
 }
 
@@ -435,28 +443,40 @@ function resolveDaemonTransport(options) {
   return getBridgeTransport(env);
 }
 
+/**
+ * @typedef {{
+ *   execFileFn?: typeof execFileAsync,
+ *   platform?: NodeJS.Platform,
+ *   readFileFn?: typeof fs.promises.readFile,
+ * }} FindDaemonPidOptions
+ */
+
 /**
  * @param {BridgeTransport} transport
+ * @param {FindDaemonPidOptions} [options={}]
  * @returns {Promise<number | null>}
  */
-export async function findDaemonPidByTransport(transport) {
-  if (transport.type !== 'socket') {
-    return null;
+export async function findDaemonPidByTransport(transport, options = {}) {
+  if (transport.type === 'socket') {
+    return findDaemonPidBySocket(transport.socketPath, options);
   }
-  return findDaemonPidBySocket(transport.socketPath);
+  return findDaemonPidByTcpPort(transport.port, options);
 }
 
 /**
  * @param {string} socketPath
+ * @param {FindDaemonPidOptions} [options={}]
  * @returns {Promise<number | null>}
  */
-export async function findDaemonPidBySocket(socketPath) {
-  if (process.platform === 'win32') {
+export async function findDaemonPidBySocket(socketPath, options = {}) {
+  const { execFileFn = execFileAsync, platform = process.platform } = options;
+  if (platform === 'win32') {
+    // Named pipes do not expose an owner pid through a filesystem path.
     return null;
   }
 
   try {
-    const { stdout } = await execFileAsync('lsof', ['-t', '--', socketPath]);
+    const { stdout } = await execFileFn('lsof', ['-t', '--', socketPath]);
     const pid = Number.parseInt(
       stdout
         .split(/\r?\n/u)
@@ -466,13 +486,208 @@ export async function findDaemonPidBySocket(socketPath) {
     );
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch (error) {
-    if (isCommandNotFoundError(error) || isLsofNoResultsError(error)) {
+    if (isCommandNotFoundError(error)) {
+      // macOS always ships lsof; minimal Linux installs often do not, so fall
+      // back to iproute2's ss which is effectively universal there.
+      return platform === 'linux' ? findLinuxSocketOwnerPidWithSs(socketPath, execFileFn) : null;
+    }
+    if (isLsofNoResultsError(error)) {
       return null;
     }
     throw error;
   }
 }
 
+/**
+ * @param {string} socketPath
+ * @param {typeof execFileAsync} execFileFn
+ * @returns {Promise<number | null>}
+ */
+async function findLinuxSocketOwnerPidWithSs(socketPath, execFileFn) {
+  try {
+    const { stdout } = await execFileFn('ss', ['-x', '-l', '-p', 'src', socketPath]);
+    for (const line of stdout.split(/\r?\n/u)) {
+      if (!line.includes(socketPath)) {
+        continue;
+      }
+      const match = /pid=(\d+)/u.exec(line);
+      const pid = match ? Number.parseInt(match[1], 10) : Number.NaN;
+      if (Number.isInteger(pid) && pid > 0) {
+        return pid;
+      }
+    }
+    return null;
+  } catch {
+    // ss is a best-effort fallback; the caller degrades to the pid file.
+    return null;
+  }
+}
+
+/**
+ * Find the pid of the bridge daemon listening on a local TCP port (the default
+ * transport on Windows and the opt-in proxy transport elsewhere). Unlike a
+ * bridge-owned socket path, a TCP port could be held by an unrelated process,
+ * so a candidate pid is only returned after its command line is confirmed to
+ * reference the bridge daemon entrypoint. Discovery is opportunistic: any
+ * tooling failure yields null and the caller degrades to the pid file.
+ *
+ * @param {number} port
+ * @param {FindDaemonPidOptions} [options={}]
+ * @returns {Promise<number | null>}
+ */
+export async function findDaemonPidByTcpPort(port, options = {}) {
+  const {
+    execFileFn = execFileAsync,
+    platform = process.platform,
+    readFileFn = fs.promises.readFile,
+  } = options;
+
+  if (platform === 'win32') {
+    return findWindowsTcpDaemonPid(port, execFileFn);
+  }
+
+  const candidatePids = await findPosixTcpListenerPids(port, execFileFn, platform);
+  for (const pid of candidatePids) {
+    const command = await getPosixProcessCommand(pid, execFileFn, platform, readFileFn);
+    if (command.includes(DAEMON_ENTRY_BASENAME)) {
+      return pid;
+    }
+  }
+  return null;
+}
+
+const DAEMON_ENTRY_BASENAME = 'bridge-daemon';
+
+/**
+ * @returns {string}
+ */
+function getWindowsPowerShellExe() {
+  const systemRoot = process.env.SystemRoot || process.env.WINDIR;
+  return systemRoot
+    ? path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+    : 'powershell.exe';
+}
+
+/**
+ * Resolve and verify the listening daemon pid in a single PowerShell call.
+ * Get-NetTCPConnection is locale-independent, unlike netstat's state column.
+ * `$listenerPid` deliberately avoids PowerShell's reserved `$PID` variable.
+ *
+ * @param {number} port
+ * @param {typeof execFileAsync} execFileFn
+ * @returns {Promise<number | null>}
+ */
+async function findWindowsTcpDaemonPid(port, execFileFn) {
+  const script = [
+    `$listenerPids = @(Get-NetTCPConnection -State Listen -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { $_.OwningProcess } | Sort-Object -Unique)`,
+    'foreach ($listenerPid in $listenerPids) {',
+    `  $commandLine = (Get-CimInstance Win32_Process -Filter "ProcessId=$listenerPid" -ErrorAction SilentlyContinue).CommandLine`,
+    `  if ($commandLine -like '*${DAEMON_ENTRY_BASENAME}*') { Write-Output $listenerPid; break }`,
+    '}',
+  ].join(' ');
+
+  try {
+    const { stdout } = await execFileFn(getWindowsPowerShellExe(), [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      script,
+    ]);
+    const pid = Number.parseInt(
+      stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find(Boolean) ?? '',
+      10
+    );
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {number} port
+ * @param {typeof execFileAsync} execFileFn
+ * @param {NodeJS.Platform} platform
+ * @returns {Promise<number[]>}
+ */
+async function findPosixTcpListenerPids(port, execFileFn, platform) {
+  try {
+    const { stdout } = await execFileFn('lsof', ['-nP', '-t', `-iTCP:${port}`, '-sTCP:LISTEN']);
+    return parsePidLines(stdout);
+  } catch (error) {
+    if (isCommandNotFoundError(error) && platform === 'linux') {
+      return findLinuxTcpListenerPidsWithSs(port, execFileFn);
+    }
+    return [];
+  }
+}
+
+/**
+ * @param {number} port
+ * @param {typeof execFileAsync} execFileFn
+ * @returns {Promise<number[]>}
+ */
+async function findLinuxTcpListenerPidsWithSs(port, execFileFn) {
+  try {
+    const { stdout } = await execFileFn('ss', ['-t', '-l', '-n', '-p', 'sport', '=', `:${port}`]);
+    /** @type {number[]} */
+    const pids = [];
+    for (const match of stdout.matchAll(/pid=(\d+)/gu)) {
+      const pid = Number.parseInt(match[1], 10);
+      if (Number.isInteger(pid) && pid > 0 && !pids.includes(pid)) {
+        pids.push(pid);
+      }
+    }
+    return pids;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * @param {number} pid
+ * @param {typeof execFileAsync} execFileFn
+ * @param {NodeJS.Platform} platform
+ * @param {typeof fs.promises.readFile} readFileFn
+ * @returns {Promise<string>}
+ */
+async function getPosixProcessCommand(pid, execFileFn, platform, readFileFn) {
+  if (platform === 'linux') {
+    // /proc avoids depending on a full procps ps (busybox lacks -ww/command=).
+    try {
+      const cmdline = await readFileFn(`/proc/${pid}/cmdline`, 'utf8');
+      return String(cmdline).replaceAll('\0', ' ');
+    } catch {
+      return '';
+    }
+  }
+  try {
+    const { stdout } = await execFileFn('ps', ['-ww', '-p', String(pid), '-o', 'command=']);
+    return stdout;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * @param {string} stdout
+ * @returns {number[]}
+ */
+function parsePidLines(stdout) {
+  /** @type {number[]} */
+  const pids = [];
+  for (const line of stdout.split(/\r?\n/u)) {
+    const pid = Number.parseInt(line.trim(), 10);
+    if (Number.isInteger(pid) && pid > 0 && !pids.includes(pid)) {
+      pids.push(pid);
+    }
+  }
+  return pids;
+}
+
 /**
  * @param {{
  *   transport: BridgeTransport,

package/packages/native-host/src/daemon.js

@@ -39,11 +39,7 @@ import {
   getBridgeTransport,
   getSocketPath,
 } from './config.js';
-import {
-  ensureBridgeAuthToken,
-  normalizeBridgeAuthToken,
-  readBridgeAuthToken,
-} from './auth-token.js';
+import { bridgeAuthTokensEqual, ensureBridgeAuthToken, readBridgeAuthToken } from './auth-token.js';
 import { normalizeDaemonLogger } from './daemon-logger.js';
 import { writeJsonLine } from './framing.js';
 
@@ -341,7 +337,7 @@ export class BridgeDaemon {
       return;
     }
 
-    if (this.isAuthRequired() && normalizeBridgeAuthToken(message.authToken) !== this.authToken) {
+    if (this.isAuthRequired() && !bridgeAuthTokensEqual(message.authToken, this.authToken)) {
       this.logger.error('socket registration rejected', { role: message.role ?? null });
       void writeJsonLine(socket, {
         type: 'registration_failed',

package/packages/protocol/src/capabilities.js

@@ -1,122 +1,45 @@
 // @ts-check
 
+import { CAPABILITIES, DEFAULT_CAPABILITIES } from './capability-values.js';
+import { BRIDGE_METHODS, BRIDGE_METHOD_REGISTRY } from './registry.js';
+
 /** @typedef {import('./types.js').BridgeMethod} CapabilityMethod */
 /** @typedef {import('./types.js').Capability} Capability */
 
-export const CAPABILITIES = Object.freeze({
-  PAGE_READ: 'page.read',
-  PAGE_EVALUATE: 'page.evaluate',
-  DOM_READ: 'dom.read',
-  STYLES_READ: 'styles.read',
-  LAYOUT_READ: 'layout.read',
-  VIEWPORT_CONTROL: 'viewport.control',
-  NAVIGATION_CONTROL: 'navigation.control',
-  SCREENSHOT_PARTIAL: 'screenshot.partial',
-  PATCH_DOM: 'patch.dom',
-  PATCH_STYLES: 'patch.styles',
-  CDP_DOM_SNAPSHOT: 'cdp.dom_snapshot',
-  CDP_BOX_MODEL: 'cdp.box_model',
-  CDP_STYLES: 'cdp.styles',
-  CDP_INPUT: 'cdp.input',
-  AUTOMATION_INPUT: 'automation.input',
-  TABS_MANAGE: 'tabs.manage',
-  PERFORMANCE_READ: 'performance.read',
-  NETWORK_READ: 'network.read',
-  NETWORK_INTERCEPT: 'network.intercept',
-});
+export { CAPABILITIES, DEFAULT_CAPABILITIES };
+
+/** @type {readonly CapabilityMethod[]} */
+const LEGACY_METHOD_CAPABILITY_PREFIX = [
+  'access.request',
+  'tabs.list',
+  'tabs.create',
+  'tabs.close',
+  'tabs.activate',
+  'skill.get_runtime_context',
+  'setup.get_status',
+  'setup.install',
+];
+
+/** @type {readonly CapabilityMethod[]} */
+const LEGACY_METHOD_CAPABILITY_SUFFIX = ['log.tail', 'health.ping', 'daemon.metrics'];
 
-export const DEFAULT_CAPABILITIES = Object.freeze([
-  CAPABILITIES.PAGE_READ,
-  CAPABILITIES.PAGE_EVALUATE,
-  CAPABILITIES.DOM_READ,
-  CAPABILITIES.STYLES_READ,
-  CAPABILITIES.LAYOUT_READ,
-  CAPABILITIES.VIEWPORT_CONTROL,
-  CAPABILITIES.NAVIGATION_CONTROL,
-  CAPABILITIES.SCREENSHOT_PARTIAL,
-  CAPABILITIES.PATCH_DOM,
-  CAPABILITIES.PATCH_STYLES,
-  CAPABILITIES.AUTOMATION_INPUT,
-  CAPABILITIES.CDP_DOM_SNAPSHOT,
-  CAPABILITIES.CDP_BOX_MODEL,
-  CAPABILITIES.CDP_STYLES,
-  CAPABILITIES.CDP_INPUT,
-  CAPABILITIES.TABS_MANAGE,
-  CAPABILITIES.PERFORMANCE_READ,
-  CAPABILITIES.NETWORK_READ,
-  CAPABILITIES.NETWORK_INTERCEPT,
+const LEGACY_POSITIONED_METHODS = new Set([
+  ...LEGACY_METHOD_CAPABILITY_PREFIX,
+  ...LEGACY_METHOD_CAPABILITY_SUFFIX,
 ]);
 
 /** @type {Readonly<Record<CapabilityMethod, Capability | null>>} */
-export const METHOD_CAPABILITIES = Object.freeze({
-  'access.request': null,
-  'tabs.list': null,
-  'tabs.create': CAPABILITIES.TABS_MANAGE,
-  'tabs.close': CAPABILITIES.TABS_MANAGE,
-  'tabs.activate': CAPABILITIES.TABS_MANAGE,
-  'skill.get_runtime_context': null,
-  'setup.get_status': null,
-  'setup.install': null,
-  'page.get_state': CAPABILITIES.PAGE_READ,
-  'page.evaluate': CAPABILITIES.PAGE_EVALUATE,
-  'page.get_console': CAPABILITIES.PAGE_READ,
-  'page.wait_for_load_state': CAPABILITIES.PAGE_READ,
-  'page.get_storage': CAPABILITIES.PAGE_READ,
-  'page.get_text': CAPABILITIES.PAGE_READ,
-  'page.get_network': CAPABILITIES.NETWORK_READ,
-  // Interception mutates traffic (block/forge responses) - distinct from
-  // passive network reads so hosts can gate it independently.
-  'network.intercept.add': CAPABILITIES.NETWORK_INTERCEPT,
-  'network.intercept.remove': CAPABILITIES.NETWORK_INTERCEPT,
-  'network.intercept.list': CAPABILITIES.NETWORK_INTERCEPT,
-  'network.intercept.clear': CAPABILITIES.NETWORK_INTERCEPT,
-  'navigation.navigate': CAPABILITIES.NAVIGATION_CONTROL,
-  'navigation.reload': CAPABILITIES.NAVIGATION_CONTROL,
-  'navigation.go_back': CAPABILITIES.NAVIGATION_CONTROL,
-  'navigation.go_forward': CAPABILITIES.NAVIGATION_CONTROL,
-  'dom.query': CAPABILITIES.DOM_READ,
-  'dom.describe': CAPABILITIES.DOM_READ,
-  'dom.get_text': CAPABILITIES.DOM_READ,
-  'dom.get_attributes': CAPABILITIES.DOM_READ,
-  'dom.wait_for': CAPABILITIES.DOM_READ,
-  'dom.find_by_text': CAPABILITIES.DOM_READ,
-  'dom.find_by_role': CAPABILITIES.DOM_READ,
-  'dom.get_html': CAPABILITIES.DOM_READ,
-  'dom.get_accessibility_tree': CAPABILITIES.DOM_READ,
-  'layout.get_box_model': CAPABILITIES.LAYOUT_READ,
-  'layout.hit_test': CAPABILITIES.LAYOUT_READ,
-  'styles.get_computed': CAPABILITIES.STYLES_READ,
-  'styles.get_matched_rules': CAPABILITIES.STYLES_READ,
-  'viewport.scroll': CAPABILITIES.VIEWPORT_CONTROL,
-  'viewport.resize': CAPABILITIES.VIEWPORT_CONTROL,
-  'input.click': CAPABILITIES.AUTOMATION_INPUT,
-  'input.focus': CAPABILITIES.AUTOMATION_INPUT,
-  'input.type': CAPABILITIES.AUTOMATION_INPUT,
-  'input.fill': CAPABILITIES.AUTOMATION_INPUT,
-  'input.press_key': CAPABILITIES.AUTOMATION_INPUT,
-  'input.set_checked': CAPABILITIES.AUTOMATION_INPUT,
-  'input.select_option': CAPABILITIES.AUTOMATION_INPUT,
-  'input.hover': CAPABILITIES.AUTOMATION_INPUT,
-  'input.drag': CAPABILITIES.AUTOMATION_INPUT,
-  'input.scroll_into_view': CAPABILITIES.AUTOMATION_INPUT,
-  'screenshot.capture_region': CAPABILITIES.SCREENSHOT_PARTIAL,
-  'screenshot.capture_element': CAPABILITIES.SCREENSHOT_PARTIAL,
-  'screenshot.capture_full_page': CAPABILITIES.SCREENSHOT_PARTIAL,
-  'patch.apply_styles': CAPABILITIES.PATCH_STYLES,
-  'patch.apply_dom': CAPABILITIES.PATCH_DOM,
-  'patch.list': CAPABILITIES.PATCH_DOM,
-  'patch.rollback': CAPABILITIES.PATCH_DOM,
-  'patch.commit_session_baseline': CAPABILITIES.PATCH_DOM,
-  'cdp.get_document': CAPABILITIES.CDP_DOM_SNAPSHOT,
-  'cdp.get_dom_snapshot': CAPABILITIES.CDP_DOM_SNAPSHOT,
-  'cdp.get_box_model': CAPABILITIES.CDP_BOX_MODEL,
-  'cdp.get_computed_styles_for_node': CAPABILITIES.CDP_STYLES,
-  'cdp.dispatch_key_event': CAPABILITIES.CDP_INPUT,
-  'performance.get_metrics': CAPABILITIES.PERFORMANCE_READ,
-  'log.tail': null,
-  'health.ping': null,
-  'daemon.metrics': null,
-});
+export const METHOD_CAPABILITIES = Object.freeze(
+  /** @type {Record<CapabilityMethod, Capability | null>} */ (
+    Object.fromEntries(
+      [
+        ...LEGACY_METHOD_CAPABILITY_PREFIX,
+        ...BRIDGE_METHODS.filter((method) => !LEGACY_POSITIONED_METHODS.has(method)),
+        ...LEGACY_METHOD_CAPABILITY_SUFFIX,
+      ].map((method) => [method, BRIDGE_METHOD_REGISTRY[method].capability])
+    )
+  )
+);
 
 /**
  * @param {unknown} value

package/packages/protocol/src/capability-values.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+export const CAPABILITIES = Object.freeze({
+  PAGE_READ: 'page.read',
+  PAGE_EVALUATE: 'page.evaluate',
+  DOM_READ: 'dom.read',
+  STYLES_READ: 'styles.read',
+  LAYOUT_READ: 'layout.read',
+  VIEWPORT_CONTROL: 'viewport.control',
+  NAVIGATION_CONTROL: 'navigation.control',
+  SCREENSHOT_PARTIAL: 'screenshot.partial',
+  PATCH_DOM: 'patch.dom',
+  PATCH_STYLES: 'patch.styles',
+  CDP_DOM_SNAPSHOT: 'cdp.dom_snapshot',
+  CDP_BOX_MODEL: 'cdp.box_model',
+  CDP_STYLES: 'cdp.styles',
+  CDP_INPUT: 'cdp.input',
+  AUTOMATION_INPUT: 'automation.input',
+  TABS_MANAGE: 'tabs.manage',
+  PERFORMANCE_READ: 'performance.read',
+  NETWORK_READ: 'network.read',
+  NETWORK_INTERCEPT: 'network.intercept',
+});
+
+export const DEFAULT_CAPABILITIES = Object.freeze([
+  CAPABILITIES.PAGE_READ,
+  CAPABILITIES.PAGE_EVALUATE,
+  CAPABILITIES.DOM_READ,
+  CAPABILITIES.STYLES_READ,
+  CAPABILITIES.LAYOUT_READ,
+  CAPABILITIES.VIEWPORT_CONTROL,
+  CAPABILITIES.NAVIGATION_CONTROL,
+  CAPABILITIES.SCREENSHOT_PARTIAL,
+  CAPABILITIES.PATCH_DOM,
+  CAPABILITIES.PATCH_STYLES,
+  CAPABILITIES.AUTOMATION_INPUT,
+  CAPABILITIES.CDP_DOM_SNAPSHOT,
+  CAPABILITIES.CDP_BOX_MODEL,
+  CAPABILITIES.CDP_STYLES,
+  CAPABILITIES.CDP_INPUT,
+  CAPABILITIES.TABS_MANAGE,
+  CAPABILITIES.PERFORMANCE_READ,
+  CAPABILITIES.NETWORK_READ,
+  CAPABILITIES.NETWORK_INTERCEPT,
+]);

package/packages/protocol/src/defaults.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import { BRIDGE_METHODS, BRIDGE_METHOD_REGISTRY } from './registry.js';
+
 /**
  * Shared Browser Bridge defaults used by the protocol, MCP layer, and runtime
  * guidance. Keep this as the source of truth for default limits and presets.
@@ -70,8 +72,8 @@ export const BUDGET_PRESETS = Object.freeze({
   deep: { maxNodes: 100, maxDepth: 8, textBudget: 2000, tokenBudget: 4000 },
 });
 
-/** @type {ReadonlySet<string>} */
-export const DEBUGGER_BACKED_METHODS = new Set([
+/** @type {readonly import('./types.js').BridgeMethod[]} */
+const LEGACY_DEBUGGER_BACKED_METHOD_ORDER = [
   'page.evaluate',
   'dom.get_accessibility_tree',
   'viewport.resize',
@@ -88,6 +90,19 @@ export const DEBUGGER_BACKED_METHODS = new Set([
   'cdp.get_box_model',
   'cdp.get_computed_styles_for_node',
   'cdp.dispatch_key_event',
+];
+
+const LEGACY_DEBUGGER_BACKED_METHODS = new Set(LEGACY_DEBUGGER_BACKED_METHOD_ORDER);
+
+/** @type {ReadonlySet<string>} */
+export const DEBUGGER_BACKED_METHODS = new Set([
+  ...LEGACY_DEBUGGER_BACKED_METHOD_ORDER.filter(
+    (method) => BRIDGE_METHOD_REGISTRY[method].debuggerBacked
+  ),
+  ...BRIDGE_METHODS.filter(
+    (method) =>
+      BRIDGE_METHOD_REGISTRY[method].debuggerBacked && !LEGACY_DEBUGGER_BACKED_METHODS.has(method)
+  ),
 ]);
 
 /**