@browserbridge/bbx 1.1.0 → 1.2.0

package/packages/mcp-server/src/server.js

@@ -401,7 +401,7 @@ export function createBridgeMcpServer() {
           .optional()
           .describe('Mouse button for click (default: left)'),
         clickCount: z.number().optional().describe('Click count (1=single, 2=double)'),
-        text: z.string().optional().describe('Text to type (for type action)'),
+        text: z.string().max(100000).optional().describe('Text to type (for type action)'),
         clear: z.boolean().optional().describe('Clear field before typing (default: false)'),
         submit: z.boolean().optional().describe('Press Enter after typing (default: false)'),
         key: z

package/packages/native-host/bin/bridge-daemon.js

@@ -6,11 +6,12 @@ import {
   formatBridgeTransport,
   getBridgeTransport,
 } from '../src/config.js';
+import { DaemonLogger } from '../src/daemon-logger.js';
 import { clearDaemonPidFile, writeDaemonPidFile } from '../src/daemon-process.js';
 
 applyWindowsTcpTransportDefaults();
 const transport = getBridgeTransport();
-const daemon = new BridgeDaemon({ transport });
+const daemon = new BridgeDaemon({ transport, logger: new DaemonLogger() });
 
 /**
  * @param {unknown} error

package/packages/native-host/bin/install-manifest.js

@@ -3,6 +3,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { restartBridgeDaemonIfRunning } from '../src/daemon-process.js';
 import {
   installNativeManifest,
   parseExtensionId,
@@ -77,3 +78,10 @@ for (const [index, target] of targets.entries()) {
     browser: target,
   });
 }
+
+if (!uninstall) {
+  const restartResult = await restartBridgeDaemonIfRunning();
+  if (restartResult) {
+    process.stdout.write('Restarted Browser Bridge daemon to use the updated install.\n');
+  }
+}

package/packages/native-host/bin/postinstall.js

@@ -10,6 +10,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { restartBridgeDaemonIfRunning } from '../src/daemon-process.js';
 import { installNativeManifest } from '../src/install-manifest.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -24,4 +25,19 @@ try {
   process.stderr.write(
     `Browser Bridge: native host auto-install skipped (${message}).\nRun \`bbx install\` manually if needed.\n`
   );
+  process.exit(0);
+}
+
+try {
+  const restartResult = await restartBridgeDaemonIfRunning();
+  if (restartResult) {
+    process.stdout.write(
+      'Browser Bridge: restarted the local daemon to use the updated install.\n'
+    );
+  }
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(
+    `Browser Bridge: native host installed, but daemon restart failed (${message}).\nRun \`bbx restart\` if needed.\n`
+  );
 }

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

@@ -0,0 +1,157 @@
+// @ts-check
+
+/** @typedef {{ write: (chunk: string) => void }} LogStream */
+
+/**
+ * @enum {number}
+ * @private
+ */
+const LOG_LEVELS = /** @type {const} */ ({
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+});
+
+/** @typedef {keyof typeof LOG_LEVELS} LogLevel */
+
+/**
+ * @typedef {{
+ *   debug(message: string, extra?: Record<string, unknown>): void;
+ *   info(message: string, extra?: Record<string, unknown>): void;
+ *   warn(message: string, extra?: Record<string, unknown>): void;
+ *   error(message: string, extra?: Record<string, unknown>): void;
+ * }} DaemonLoggerLike
+ */
+
+/**
+ * Structured JSON logger for the daemon. Each call emits a single NDJSON line
+ * with a timestamp, level, message, and optional structured fields.
+ */
+export class DaemonLogger {
+  /** @type {LogStream} */
+  #stream;
+  /** @type {LogLevel} */
+  #minLevel;
+  /** @type {Record<string, unknown>} */
+  #defaults;
+
+  /**
+   * @param {{ stream?: LogStream, minLevel?: LogLevel, defaults?: Record<string, unknown> }} [options]
+   */
+  constructor({ stream, minLevel = 'info', defaults = {} } = {}) {
+    this.#stream = stream ?? /** @type {LogStream} */ (process.stderr);
+    this.#minLevel = minLevel;
+    this.#defaults = defaults;
+  }
+
+  /**
+   * @param {LogLevel} level
+   * @param {string} message
+   * @param {Record<string, unknown>} [extra]
+   * @returns {void}
+   */
+  #write(level, message, extra) {
+    if (LOG_LEVELS[level] < LOG_LEVELS[this.#minLevel]) {
+      return;
+    }
+    const entry = {
+      ...this.#defaults,
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      ...extra,
+    };
+    this.#stream.write(`${JSON.stringify(entry)}\n`);
+  }
+
+  /**
+   * @param {string} message
+   * @param {Record<string, unknown>} [extra]
+   * @returns {void}
+   */
+  debug(message, extra) {
+    this.#write('debug', message, extra);
+  }
+
+  /**
+   * @param {string} message
+   * @param {Record<string, unknown>} [extra]
+   * @returns {void}
+   */
+  info(message, extra) {
+    this.#write('info', message, extra);
+  }
+
+  /**
+   * @param {string} message
+   * @param {Record<string, unknown>} [extra]
+   * @returns {void}
+   */
+  warn(message, extra) {
+    this.#write('warn', message, extra);
+  }
+
+  /**
+   * @param {string} message
+   * @param {Record<string, unknown>} [extra]
+   * @returns {void}
+   */
+  error(message, extra) {
+    this.#write('error', message, extra);
+  }
+}
+
+/**
+ * A silent logger that discards all output. Useful in tests.
+ * @type {DaemonLoggerLike}
+ */
+export const silentLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {},
+};
+
+/**
+ * Wrap a legacy `Pick<Console, 'log' | 'error'>` logger into the new
+ * `DaemonLoggerLike` interface. Used for backward compatibility with
+ * callers that still pass `{ log() {}, error() {} }`.
+ *
+ * @param {Pick<Console, 'log' | 'error'>} legacy
+ * @returns {DaemonLoggerLike}
+ */
+export function wrapLegacyLogger(legacy) {
+  return {
+    debug(message, extra) {
+      legacy.log?.(`[debug] ${message}`, extra ?? '');
+    },
+    info(message, extra) {
+      legacy.log?.(`[info] ${message}`, extra ?? '');
+    },
+    warn(message, extra) {
+      legacy.log?.(`[warn] ${message}`, extra ?? '');
+    },
+    error(message, extra) {
+      legacy.error?.(`[error] ${message}`, extra ?? '');
+    },
+  };
+}
+
+/**
+ * Accept either a `DaemonLoggerLike` or a legacy `Pick<Console, 'log' | 'error'>`
+ * and return a normalized `DaemonLoggerLike`. If the input already has an `info`
+ * method it is returned as-is; otherwise it is wrapped via `wrapLegacyLogger`.
+ *
+ * @param {DaemonLoggerLike | Pick<Console, 'log' | 'error'> | undefined} logger
+ * @returns {DaemonLoggerLike}
+ */
+export function normalizeDaemonLogger(logger) {
+  if (logger === undefined) {
+    return new DaemonLogger();
+  }
+  if (typeof (/** @type {any} */ (logger).info) === 'function') {
+    return /** @type {DaemonLoggerLike} */ (logger);
+  }
+  return wrapLegacyLogger(/** @type {Pick<Console, 'log' | 'error'>} */ (logger));
+}

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

@@ -196,6 +196,48 @@ export async function stopBridgeDaemon(options = {}) {
  * }>}
  */
 export async function restartBridgeDaemon(options = {}) {
+  const stopResult = await stopBridgeDaemon(options);
+  return restartBridgeDaemonAfterStop(stopResult, options);
+}
+
+/**
+ * Restart the daemon only when one is already running. This is useful during
+ * package upgrades where the launcher changed and the in-memory daemon should
+ * pick up the new install, without eagerly starting a fresh background process.
+ *
+ * @param {RestartBridgeDaemonOptions} [options={}]
+ * @returns {Promise<{
+ *   transport: string,
+ *   socketPath: string,
+ *   pidPath: string,
+ *   pid: number | null,
+ *   previouslyRunning: boolean,
+ *   previousPid: number | null,
+ *   removedStaleSocket: boolean,
+ * } | null>}
+ */
+export async function restartBridgeDaemonIfRunning(options = {}) {
+  const stopResult = await stopBridgeDaemon(options);
+  if (!stopResult.previouslyRunning) {
+    return null;
+  }
+  return restartBridgeDaemonAfterStop(stopResult, options);
+}
+
+/**
+ * @param {Awaited<ReturnType<typeof stopBridgeDaemon>>} stopResult
+ * @param {RestartBridgeDaemonOptions} [options={}]
+ * @returns {Promise<{
+ *   transport: string,
+ *   socketPath: string,
+ *   pidPath: string,
+ *   pid: number | null,
+ *   previouslyRunning: boolean,
+ *   previousPid: number | null,
+ *   removedStaleSocket: boolean,
+ * }>}
+ */
+async function restartBridgeDaemonAfterStop(stopResult, options = {}) {
   const {
     transport = getBridgeTransport(),
     socketPath = undefined,
@@ -204,27 +246,11 @@ export async function restartBridgeDaemon(options = {}) {
     pollIntervalMs = DEFAULT_DAEMON_POLL_INTERVAL_MS,
     pingDaemonFn = pingExistingDaemon,
     readPidFn = readDaemonPidFile,
-    findPidByTransportFn = findDaemonPidByTransport,
-    killFn = process.kill.bind(process),
-    rmFn = fs.promises.rm,
     sleepFn = sleep,
     spawnDaemonFn = spawnBridgeDaemonProcess,
   } = options;
   const resolvedTransport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
 
-  const stopResult = await stopBridgeDaemon({
-    transport: resolvedTransport,
-    pidPath,
-    timeoutMs,
-    pollIntervalMs,
-    pingDaemonFn,
-    readPidFn,
-    findPidByTransportFn,
-    killFn,
-    rmFn,
-    sleepFn,
-  });
-
   spawnDaemonFn();
 
   const started = await waitForDaemonReachability({

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

@@ -36,13 +36,17 @@ import {
   getBridgeTransport,
   getSocketPath,
 } from './config.js';
+import { normalizeDaemonLogger } from './daemon-logger.js';
 import { writeJsonLine } from './framing.js';
 
+const DAEMON_VERSION = loadDaemonVersion();
+
 /** @typedef {import('../../protocol/src/types.js').BridgeRequest} BridgeRequest */
 /** @typedef {import('../../protocol/src/types.js').SetupInstallParams} SetupInstallParams */
 /** @typedef {import('../../protocol/src/types.js').SetupInstallResult} SetupInstallResult */
 /** @typedef {import('../../protocol/src/types.js').SetupStatus} SetupStatus */
 /** @typedef {import('./config.js').BridgeTransport} BridgeTransport */
+/** @typedef {import('./daemon-logger.js').DaemonLoggerLike} DaemonLoggerLike */
 /** @typedef {import('node:net').Socket & { __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
 /** @typedef {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, method?: string, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
 /**
@@ -95,11 +99,24 @@ function getVersionNegotiationPayload(requestedVersion) {
   };
 }
 
+/**
+ * @returns {string | null}
+ */
+function loadDaemonVersion() {
+  try {
+    const raw = fs.readFileSync(new URL('../../../package.json', import.meta.url), 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * @param {string} socketPath
  * @returns {boolean}
  */
-function isWindowsNamedPipePath(socketPath) {
+export function isWindowsNamedPipePath(socketPath) {
   return socketPath.startsWith('\\\\.\\pipe\\');
 }
 
@@ -129,7 +146,7 @@ export class BridgeDaemon {
    *   listenOptions?: import('node:net').ListenOptions | null,
    *   setupStatusLoader?: () => Promise<SetupStatus>,
    *   setupInstaller?: (params: Record<string, unknown>) => Promise<SetupInstallResult>,
-   *   logger?: Pick<Console, 'log' | 'error'>
+   *   logger?: DaemonLoggerLike | Pick<Console, 'log' | 'error'>
    * }} [options={}]
    */
   constructor({
@@ -138,7 +155,7 @@ export class BridgeDaemon {
     listenOptions = null,
     setupStatusLoader = collectSetupStatus,
     setupInstaller = installSetupTarget,
-    logger = console,
+    logger = undefined,
   } = {}) {
     this.transport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
     this.socketPath =
@@ -146,7 +163,8 @@ export class BridgeDaemon {
     this.listenOptions = listenOptions ?? getBridgeListenTarget(this.transport);
     this.setupStatusLoader = setupStatusLoader;
     this.setupInstaller = setupInstaller;
-    this.logger = logger;
+    /** @type {DaemonLoggerLike} */
+    this.logger = normalizeDaemonLogger(logger);
     /** @type {net.Server | null} */
     this.server = null;
     /** @type {net.AddressInfo | string | null} */
@@ -168,6 +186,16 @@ export class BridgeDaemon {
     this.connectedExtensionsCache = null;
     /** @type {Promise<void> | null} */
     this.stopPromise = null;
+    /** @type {number} */
+    this.startedAt = 0;
+    /** @type {number} */
+    this.requestsProcessed = 0;
+    /** @type {number} */
+    this.requestsFailed = 0;
+    /** @type {number} */
+    this.totalResponseTimeMs = 0;
+    /** @type {Map<string, number>} */
+    this.requestStartTimes = new Map();
   }
 
   /**
@@ -216,6 +244,7 @@ export class BridgeDaemon {
    */
   trackPendingRequest(requestId, pending) {
     this.pendingRequests.set(requestId, pending);
+    this.requestStartTimes.set(requestId, Date.now());
     this.addPendingRequestIndex(this.pendingRequestsByOwnerSocket, pending.socket, requestId);
     for (const targetSocket of pending.targets) {
       this.addPendingRequestIndex(this.pendingRequestsByTargetSocket, targetSocket, requestId);
@@ -232,6 +261,7 @@ export class BridgeDaemon {
       return undefined;
     }
     this.pendingRequests.delete(requestId);
+    this.requestStartTimes.delete(requestId);
     this.removePendingRequestIndex(this.pendingRequestsByOwnerSocket, pending.socket, requestId);
     for (const targetSocket of pending.targets) {
       this.removePendingRequestIndex(this.pendingRequestsByTargetSocket, targetSocket, requestId);
@@ -287,6 +317,11 @@ export class BridgeDaemon {
       socket.__lastActiveAt = Date.now();
       this.extensionSockets.set(extensionId, socket);
       this.invalidateConnectedExtensionsCache();
+      this.logger.info('extension registered', {
+        extensionId,
+        browserName: socket.__browserName ?? null,
+        profileLabel: socket.__profileLabel ?? null,
+      });
       void writeJsonLine(socket, { type: 'registered', role: 'extension' });
       return;
     }
@@ -295,6 +330,7 @@ export class BridgeDaemon {
       const clientId = message.clientId || randomUUID();
       this.agentSockets.set(clientId, socket);
       socket.__clientId = clientId;
+      this.logger.info('agent registered', { clientId });
       void writeJsonLine(socket, {
         type: 'registered',
         role: 'agent',
@@ -320,7 +356,9 @@ export class BridgeDaemon {
             `Another daemon is already running on ${this.socketPath}. Stop it before starting a new one.`
           );
         }
-        this.logger.log('[daemon] Removing stale socket from previous run:', this.socketPath);
+        this.logger.info('Removing stale socket from previous run', {
+          socketPath: this.socketPath,
+        });
       } catch (error) {
         if (error instanceof Error && error.message.startsWith('Another daemon')) {
           throw error;
@@ -333,15 +371,14 @@ export class BridgeDaemon {
     this.server = net.createServer((socket) => {
       const typedSocket = /** @type {ClientSocket} */ (socket);
       typedSocket.on('error', (err) => {
-        this.logger.error?.('[daemon] socket error:', err.message);
+        this.logger.error('socket error', { message: err.message });
       });
       parseJsonLines(typedSocket, (raw) => {
         const message = /** @type {DaemonMessage} */ (raw);
         void this.handleClientMessage(typedSocket, message).catch((err) => {
-          this.logger.error?.(
-            '[daemon] handler error:',
-            err instanceof Error ? err.message : String(err)
-          );
+          this.logger.error('handler error', {
+            message: err instanceof Error ? err.message : String(err),
+          });
         });
       });
       typedSocket.on('close', () => this.handleSocketClose(typedSocket));
@@ -362,6 +399,13 @@ export class BridgeDaemon {
       await fs.promises.chmod(this.socketPath, 0o600);
     }
 
+    this.logger.info('Daemon listening', {
+      transport: formatBridgeTransport(this.transport),
+      socketPath: this.socketPath ?? null,
+    });
+
+    this.startedAt = Date.now();
+
     return this;
   }
 
@@ -483,10 +527,12 @@ export class BridgeDaemon {
       if (this.extensionSockets.size === 0) {
         const response = createSuccess(request.id, {
           daemon: 'ok',
+          daemonVersion: DAEMON_VERSION,
           extensionConnected: false,
           socketPath: this.socketPath,
           transport: formatBridgeTransport(this.transport),
           connectedExtensions: [],
+          daemon_supported_versions: SUPPORTED_VERSIONS,
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
         await writeJsonLine(socket, { type: 'agent.response', response });
@@ -502,6 +548,26 @@ export class BridgeDaemon {
       return;
     }
 
+    if (request.method === 'daemon.metrics') {
+      const now = Date.now();
+      const uptimeMs = this.startedAt > 0 ? now - this.startedAt : 0;
+      const avgResponseTimeMs =
+        this.requestsProcessed > 0
+          ? Math.round(this.totalResponseTimeMs / this.requestsProcessed)
+          : 0;
+      const response = createSuccess(request.id, {
+        uptimeMs,
+        activeAgents: this.agentSockets.size,
+        activeExtensions: this.extensionSockets.size,
+        pendingRequests: this.pendingRequests.size,
+        requestsProcessed: this.requestsProcessed,
+        requestsFailed: this.requestsFailed,
+        avgResponseTimeMs,
+      });
+      await writeJsonLine(socket, { type: 'agent.response', response });
+      return;
+    }
+
     if (request.method === 'setup.get_status') {
       const response = createSuccess(request.id, await this.setupStatusLoader(), {
         method: request.method,
@@ -593,6 +659,7 @@ export class BridgeDaemon {
         const pending = this.pendingRequests.get(request.id);
         if (!pending) return;
         this.clearPendingRequest(request.id, pending);
+        this.recordRequestCompletion(request.id, false);
         const response = createFailure(
           request.id,
           ERROR_CODES.TIMEOUT,
@@ -604,6 +671,12 @@ export class BridgeDaemon {
         });
       }, this.pendingTimeoutMs),
     });
+    this.logger.info('request routed', {
+      requestId: request.id,
+      method: request.method,
+      clientId: socket.__clientId ?? null,
+      targetCount: targets.length,
+    });
     const broadcastPayload = { type: 'extension.request', request };
     await Promise.all(targets.map((extSocket) => writeJsonLine(extSocket, broadcastPayload)));
   }
@@ -697,6 +770,7 @@ export class BridgeDaemon {
     if (responseMessage.ok) {
       clearTimeout(pending.timeoutId);
       this.clearPendingRequest(responseMessage.id, pending);
+      this.recordRequestCompletion(responseMessage.id, true);
       this.pushLog({
         at: new Date().toISOString(),
         method: responseMessage.meta?.method ?? null,
@@ -715,6 +789,8 @@ export class BridgeDaemon {
                 transport: formatBridgeTransport(this.transport),
                 connectedExtensions: this.getConnectedExtensionsSnapshot(),
                 .../** @type {Record<string, unknown>} */ (responseMessage.result),
+                daemonVersion: DAEMON_VERSION,
+                daemon_supported_versions: SUPPORTED_VERSIONS,
               },
               {
                 ...responseMessage.meta,
@@ -742,11 +818,13 @@ export class BridgeDaemon {
    */
   handleSocketClose(socket) {
     if (socket.__extensionId) {
+      this.logger.info('extension disconnected', { extensionId: socket.__extensionId });
       this.extensionSockets.delete(socket.__extensionId);
       this.invalidateConnectedExtensionsCache();
     }
 
     if (socket.__clientId) {
+      this.logger.info('agent disconnected', { clientId: socket.__clientId });
       this.agentSockets.delete(socket.__clientId);
     }
 
@@ -759,6 +837,7 @@ export class BridgeDaemon {
         }
         clearTimeout(pending.timeoutId);
         this.clearPendingRequest(id, pending);
+        this.recordRequestCompletion(id, false);
       }
     }
 
@@ -790,6 +869,7 @@ export class BridgeDaemon {
 
     clearTimeout(pending.timeoutId);
     this.clearPendingRequest(requestId, pending);
+    this.recordRequestCompletion(requestId, false);
 
     const response =
       pending.lastErrorResponse ??
@@ -815,6 +895,22 @@ export class BridgeDaemon {
     });
   }
 
+  /**
+   * @param {string} requestId
+   * @param {boolean} ok
+   * @returns {void}
+   */
+  recordRequestCompletion(requestId, ok) {
+    const startedAt = this.requestStartTimes.get(requestId);
+    this.requestsProcessed += 1;
+    if (!ok) {
+      this.requestsFailed += 1;
+    }
+    if (typeof startedAt === 'number') {
+      this.totalResponseTimeMs += Date.now() - startedAt;
+    }
+  }
+
   /**
    * @param {Record<string, unknown>} entry
    * @returns {void}

package/packages/protocol/src/capabilities.js

@@ -105,6 +105,7 @@ export const METHOD_CAPABILITIES = Object.freeze({
   'performance.get_metrics': CAPABILITIES.PERFORMANCE_READ,
   'log.tail': null,
   'health.ping': null,
+  'daemon.metrics': null,
 });
 
 /**

package/packages/protocol/src/registry.js

@@ -82,6 +82,7 @@ const BRIDGE_METHOD_DESCRIPTIONS = Object.freeze({
   'performance.get_metrics': 'Read browser performance metrics.',
   'log.tail': 'Tail recent bridge log entries.',
   'health.ping': 'Check daemon, extension, and access-routing health.',
+  'daemon.metrics': 'Daemon health and performance metrics.',
 });
 
 /**
@@ -124,6 +125,7 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
   ),
   'log.tail': createRegistryEntry('log.tail', 'system', false, [], 'trivial'),
   'health.ping': createRegistryEntry('health.ping', 'system', false, [], 'trivial'),
+  'daemon.metrics': createRegistryEntry('daemon.metrics', 'system', false, [], 'trivial'),
   // tabs — trivial
   'tabs.list': createRegistryEntry('tabs.list', 'tabs', false, [], 'trivial'),
   'tabs.create': createRegistryEntry('tabs.create', 'tabs', false, ['url', 'active'], 'trivial'),

package/packages/protocol/src/types.js

@@ -15,7 +15,7 @@ export {};
  */
 
 /**
- * @typedef {'access.request' | 'tabs.list' | 'tabs.create' | 'tabs.close' | 'skill.get_runtime_context' | 'setup.get_status' | 'setup.install' | 'page.get_state' | 'page.evaluate' | 'page.get_console' | 'page.wait_for_load_state' | 'page.get_storage' | 'page.get_text' | 'page.get_network' | 'navigation.navigate' | 'navigation.reload' | 'navigation.go_back' | 'navigation.go_forward' | 'dom.query' | 'dom.describe' | 'dom.get_text' | 'dom.get_attributes' | 'dom.wait_for' | 'dom.find_by_text' | 'dom.find_by_role' | 'dom.get_html' | 'dom.get_accessibility_tree' | 'layout.get_box_model' | 'layout.hit_test' | 'styles.get_computed' | 'styles.get_matched_rules' | 'viewport.scroll' | 'viewport.resize' | 'input.click' | 'input.focus' | 'input.type' | 'input.press_key' | 'input.set_checked' | 'input.select_option' | 'input.hover' | 'input.drag' | 'input.scroll_into_view' | 'screenshot.capture_region' | 'screenshot.capture_element' | 'screenshot.capture_full_page' | 'patch.apply_styles' | 'patch.apply_dom' | 'patch.list' | 'patch.rollback' | 'patch.commit_session_baseline' | 'cdp.get_document' | 'cdp.get_dom_snapshot' | 'cdp.get_box_model' | 'cdp.get_computed_styles_for_node' | 'cdp.dispatch_key_event' | 'performance.get_metrics' | 'log.tail' | 'health.ping'} BridgeMethod
+ * @typedef {'access.request' | 'tabs.list' | 'tabs.create' | 'tabs.close' | 'skill.get_runtime_context' | 'setup.get_status' | 'setup.install' | 'page.get_state' | 'page.evaluate' | 'page.get_console' | 'page.wait_for_load_state' | 'page.get_storage' | 'page.get_text' | 'page.get_network' | 'navigation.navigate' | 'navigation.reload' | 'navigation.go_back' | 'navigation.go_forward' | 'dom.query' | 'dom.describe' | 'dom.get_text' | 'dom.get_attributes' | 'dom.wait_for' | 'dom.find_by_text' | 'dom.find_by_role' | 'dom.get_html' | 'dom.get_accessibility_tree' | 'layout.get_box_model' | 'layout.hit_test' | 'styles.get_computed' | 'styles.get_matched_rules' | 'viewport.scroll' | 'viewport.resize' | 'input.click' | 'input.focus' | 'input.type' | 'input.press_key' | 'input.set_checked' | 'input.select_option' | 'input.hover' | 'input.drag' | 'input.scroll_into_view' | 'screenshot.capture_region' | 'screenshot.capture_element' | 'screenshot.capture_full_page' | 'patch.apply_styles' | 'patch.apply_dom' | 'patch.list' | 'patch.rollback' | 'patch.commit_session_baseline' | 'cdp.get_document' | 'cdp.get_dom_snapshot' | 'cdp.get_box_model' | 'cdp.get_computed_styles_for_node' | 'cdp.dispatch_key_event' | 'performance.get_metrics' | 'log.tail' | 'health.ping' | 'daemon.metrics'} BridgeMethod
  */
 
 /**