@browserbridge/bbx 1.2.0 → 1.3.0

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

@@ -527,6 +527,7 @@ export function createBridgeMcpServer() {
           .optional()
           .describe('Element reference (for element action, preferred)'),
         selector: z.string().optional().describe('CSS selector (used if no elementRef)'),
+        nodeId: z.number().optional().describe('CDP node id for cdp_box_model/cdp_computed_styles'),
         rect: z
           .object({
             x: z.number().describe('Region left edge (viewport pixels)'),

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

@@ -16,28 +16,49 @@ import { installNativeManifest } from '../src/install-manifest.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, '../../..');
 
-try {
-  await installNativeManifest({ repoRoot, preserveCustomExtensionId: true });
-  process.stdout.write('Browser Bridge: native host installed. Run `bbx doctor` to verify.\n');
-} catch (err) {
-  // Non-fatal - user can run `bbx install` manually.
-  const message = err instanceof Error ? err.message : String(err);
-  process.stderr.write(
-    `Browser Bridge: native host auto-install skipped (${message}).\nRun \`bbx install\` manually if needed.\n`
-  );
-  process.exit(0);
-}
+/**
+ * @param {{
+ *   installNativeManifestFn?: typeof installNativeManifest,
+ *   restartBridgeDaemonIfRunningFn?: typeof restartBridgeDaemonIfRunning,
+ *   stdout?: Pick<NodeJS.WriteStream, 'write'>,
+ *   stderr?: Pick<NodeJS.WriteStream, 'write'>,
+ *   exit?: (code?: number) => void,
+ * }} [deps]
+ * @returns {Promise<void>}
+ */
+export async function runPostinstall({
+  installNativeManifestFn = installNativeManifest,
+  restartBridgeDaemonIfRunningFn = restartBridgeDaemonIfRunning,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  exit = (code) => process.exit(code),
+} = {}) {
+  try {
+    await installNativeManifestFn({ repoRoot, preserveCustomExtensionId: true });
+    stdout.write('Browser Bridge: native host installed. Run `bbx doctor` to verify.\n');
+  } catch (err) {
+    // Non-fatal - user can run `bbx install` manually.
+    const message = err instanceof Error ? err.message : String(err);
+    stderr.write(
+      `Browser Bridge: native host auto-install skipped (${message}).\nRun \`bbx install\` manually if needed.\n`
+    );
+    exit(0);
+    return;
+  }
 
-try {
-  const restartResult = await restartBridgeDaemonIfRunning();
-  if (restartResult) {
-    process.stdout.write(
-      'Browser Bridge: restarted the local daemon to use the updated install.\n'
+  try {
+    const restartResult = await restartBridgeDaemonIfRunningFn();
+    if (restartResult) {
+      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);
+    stderr.write(
+      `Browser Bridge: native host installed, but daemon restart failed (${message}).\nRun \`bbx restart\` if needed.\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`
-  );
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await runPostinstall();
 }

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

@@ -10,7 +10,6 @@ import { pingExistingDaemon } from './daemon.js';
 import {
   createSocketBridgeTransport,
   formatBridgeTransport,
-  getBridgeDir,
   getBridgeTransport,
   getDaemonPidPath,
 } from './config.js';
@@ -74,7 +73,7 @@ export function spawnBridgeDaemonProcess() {
  * @returns {Promise<void>}
  */
 export async function writeDaemonPidFile(pid = process.pid, pidPath = getDaemonPidPath()) {
-  await fs.promises.mkdir(getBridgeDir(), { recursive: true });
+  await fs.promises.mkdir(path.dirname(pidPath), { recursive: true });
   await fs.promises.writeFile(pidPath, `${pid}\n`, 'utf8');
 }
 

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

@@ -261,7 +261,6 @@ 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);
@@ -541,8 +540,10 @@ export class BridgeDaemon {
     }
 
     if (request.method === 'log.tail') {
+      const limit =
+        typeof request.params.limit === 'number' ? request.params.limit : DEFAULT_LOG_TAIL_LIMIT;
       const response = createSuccess(request.id, {
-        entries: this.recentLog.slice(-DEFAULT_LOG_TAIL_LIMIT),
+        entries: this.recentLog.slice(-limit),
       });
       await writeJsonLine(socket, { type: 'agent.response', response });
       return;
@@ -678,7 +679,30 @@ export class BridgeDaemon {
       targetCount: targets.length,
     });
     const broadcastPayload = { type: 'extension.request', request };
-    await Promise.all(targets.map((extSocket) => writeJsonLine(extSocket, broadcastPayload)));
+    await Promise.all(
+      targets.map(async (extSocket) => {
+        try {
+          await writeJsonLine(extSocket, broadcastPayload);
+        } catch (error) {
+          this.logger.error('request route failed', {
+            requestId: request.id,
+            method: request.method,
+            message: error instanceof Error ? error.message : String(error),
+          });
+          const pending = this.pendingRequests.get(request.id);
+          if (!pending) {
+            return;
+          }
+          this.removePendingTarget(request.id, pending, extSocket);
+          if (extSocket.__extensionId) {
+            this.extensionSockets.delete(extSocket.__extensionId);
+            this.invalidateConnectedExtensionsCache();
+          }
+          extSocket.destroy(error instanceof Error ? error : undefined);
+          await this.finishPendingRequestIfExhausted(request.id, pending);
+        }
+      })
+    );
   }
 
   /**
@@ -902,6 +926,7 @@ export class BridgeDaemon {
    */
   recordRequestCompletion(requestId, ok) {
     const startedAt = this.requestStartTimes.get(requestId);
+    this.requestStartTimes.delete(requestId);
     this.requestsProcessed += 1;
     if (!ok) {
       this.requestsFailed += 1;

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

@@ -24,6 +24,19 @@ export async function writeNativeMessage(stream, message) {
   }
 }
 
+/**
+ * @param {NodeJS.WritableStream} stream
+ * @returns {(message: unknown) => Promise<void>}
+ */
+export function createNativeMessageWriter(stream) {
+  let queue = Promise.resolve();
+  return (message) => {
+    const writePromise = queue.then(() => writeNativeMessage(stream, message));
+    queue = writePromise.catch(() => {});
+    return writePromise;
+  };
+}
+
 /**
  * @param {NodeJS.ReadableStream} stream
  * @param {(message: unknown) => void} onMessage

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

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { createFailure, ERROR_CODES } from '../../protocol/src/index.js';
 import { createSocketBridgeTransport, getBridgeTransport } from './config.js';
 import { spawnBridgeDaemonProcess } from './daemon-process.js';
-import { createNativeMessageReader, writeJsonLine, writeNativeMessage } from './framing.js';
+import { createNativeMessageReader, createNativeMessageWriter, writeJsonLine } from './framing.js';
 
 /** @typedef {import('./config.js').BridgeTransport} BridgeTransport */
 
@@ -117,11 +117,13 @@ export async function runNativeHost({
   socketPath = undefined,
 } = {}) {
   const resolvedTransport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
+  const writeNativeMessageQueued = createNativeMessageWriter(process.stdout);
+
   let socket;
   try {
     socket = await connectWithBootstrap(resolvedTransport);
   } catch (error) {
-    await writeNativeMessage(process.stdout, {
+    await writeNativeMessageQueued({
       type: 'agent.response',
       response: createFailure(
         'native_bootstrap',
@@ -164,11 +166,11 @@ export async function runNativeHost({
       }
       void (async () => {
         if (message.type === 'extension.request') {
-          await writeNativeMessage(process.stdout, message.request);
+          await writeNativeMessageQueued(message.request);
           return;
         }
         if (message.type === 'agent.response') {
-          await writeNativeMessage(process.stdout, {
+          await writeNativeMessageQueued({
             type: 'host.bridge_response',
             response: message.response,
           });
@@ -178,7 +180,7 @@ export async function runNativeHost({
           message.type === 'extension.setup_status.response' ||
           message.type === 'extension.setup_status.error'
         ) {
-          await writeNativeMessage(process.stdout, {
+          await writeNativeMessageQueued({
             type:
               message.type === 'extension.setup_status.response'
                 ? 'host.setup_status.response'

package/packages/protocol/src/protocol.js

@@ -7,6 +7,7 @@ import {
   DEFAULT_A11Y_MAX_NODES,
   DEFAULT_CONSOLE_LIMIT,
   DEFAULT_EVAL_TIMEOUT_MS,
+  DEFAULT_LOG_TAIL_LIMIT,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_HTML_LENGTH,
   DEFAULT_MAX_NODES,
@@ -29,6 +30,7 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').BridgeSuccessResponse} BridgeSuccessResponse */
 /** @typedef {import('./types.js').CheckedActionParams} CheckedActionParams */
 /** @typedef {import('./types.js').CdpDispatchKeyEventParams} CdpDispatchKeyEventParams */
+/** @typedef {import('./types.js').CdpNodeIdParams} CdpNodeIdParams */
 /** @typedef {import('./types.js').ConsoleParams} ConsoleParams */
 /** @typedef {import('./types.js').DomQueryParams} DomQueryParams */
 /** @typedef {import('./types.js').DragParams} DragParams */
@@ -38,11 +40,13 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').GetHtmlParams} GetHtmlParams */
 /** @typedef {import('./types.js').HoverParams} HoverParams */
 /** @typedef {import('./types.js').InputActionParams} InputActionParams */
+/** @typedef {import('./types.js').LogTailParams} LogTailParams */
 /** @typedef {import('./types.js').NavigationActionParams} NavigationActionParams */
 /** @typedef {import('./types.js').NetworkParams} NetworkParams */
 /** @typedef {import('./types.js').NormalizedAccessibilityTreeParams} NormalizedAccessibilityTreeParams */
 /** @typedef {import('./types.js').NormalizedCheckedAction} NormalizedCheckedAction */
 /** @typedef {import('./types.js').NormalizedCdpDispatchKeyEventParams} NormalizedCdpDispatchKeyEventParams */
+/** @typedef {import('./types.js').NormalizedCdpNodeIdParams} NormalizedCdpNodeIdParams */
 /** @typedef {import('./types.js').NormalizedConsoleParams} NormalizedConsoleParams */
 /** @typedef {import('./types.js').NormalizedDomQuery} NormalizedDomQuery */
 /** @typedef {import('./types.js').NormalizedDragParams} NormalizedDragParams */
@@ -52,6 +56,7 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').NormalizedGetHtmlParams} NormalizedGetHtmlParams */
 /** @typedef {import('./types.js').NormalizedHoverParams} NormalizedHoverParams */
 /** @typedef {import('./types.js').NormalizedInputAction} NormalizedInputAction */
+/** @typedef {import('./types.js').NormalizedLogTailParams} NormalizedLogTailParams */
 /** @typedef {import('./types.js').NormalizedNavigationAction} NormalizedNavigationAction */
 /** @typedef {import('./types.js').NormalizedNetworkParams} NormalizedNetworkParams */
 /** @typedef {import('./types.js').NormalizedPageTextParams} NormalizedPageTextParams */
@@ -209,6 +214,12 @@ export function validateBridgeRequest(request) {
       'session_id is no longer supported. Use tab_id or window-scoped default routing.'
     );
   }
+  if (
+    candidate.params != null &&
+    (typeof candidate.params !== 'object' || Array.isArray(candidate.params))
+  ) {
+    throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'Request params must be an object.');
+  }
   const parsedTabId = Number(candidate.tab_id);
 
   const method = /** @type {BridgeMethod} */ (candidate.method);
@@ -242,6 +253,8 @@ export function validateBridgeRequest(request) {
  */
 function normalizeRequestParams(method, params) {
   switch (method) {
+    case 'log.tail':
+      return normalizeLogTailParams(params);
     case 'dom.query':
       return normalizeDomQuery(params);
     case 'page.evaluate':
@@ -285,6 +298,9 @@ function normalizeRequestParams(method, params) {
       return normalizeInputAction(params);
     case 'cdp.dispatch_key_event':
       return normalizeCdpDispatchKeyEventParams(params);
+    case 'cdp.get_box_model':
+    case 'cdp.get_computed_styles_for_node':
+      return normalizeCdpNodeIdParams(params);
     case 'input.set_checked':
       return normalizeCheckedAction(params);
     case 'input.select_option':
@@ -429,6 +445,20 @@ export function normalizeCdpDispatchKeyEventParams(params = {}) {
   };
 }
 
+/**
+ * @param {CdpNodeIdParams} [params={}]
+ * @returns {NormalizedCdpNodeIdParams}
+ */
+export function normalizeCdpNodeIdParams(params = {}) {
+  if (typeof params.nodeId !== 'number' || !Number.isFinite(params.nodeId)) {
+    throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'nodeId must be a finite number.');
+  }
+
+  return {
+    nodeId: params.nodeId,
+  };
+}
+
 /**
  * @param {CheckedActionParams} [params={}]
  * @returns {NormalizedCheckedAction}
@@ -763,6 +793,16 @@ export function normalizePageTextParams(params = {}) {
   };
 }
 
+/**
+ * @param {LogTailParams} [params={}]
+ * @returns {NormalizedLogTailParams}
+ */
+export function normalizeLogTailParams(params = {}) {
+  return {
+    limit: clampInt(params.limit, 1, 200, DEFAULT_LOG_TAIL_LIMIT),
+  };
+}
+
 /**
  * @param {ViewportResizeParams} [params={}]
  * @returns {NormalizedViewportResizeParams}

package/packages/protocol/src/registry.js

@@ -123,7 +123,7 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
     ['kind', 'target'],
     'trivial'
   ),
-  'log.tail': createRegistryEntry('log.tail', 'system', false, [], 'trivial'),
+  'log.tail': createRegistryEntry('log.tail', 'system', false, ['limit'], 'trivial'),
   'health.ping': createRegistryEntry('health.ping', 'system', false, [], 'trivial'),
   'daemon.metrics': createRegistryEntry('daemon.metrics', 'system', false, [], 'trivial'),
   // tabs — trivial
@@ -413,18 +413,12 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
   // cdp — high (raw protocol, large payloads)
   'cdp.get_document': createRegistryEntry('cdp.get_document', 'cdp', true, [], 'high'),
   'cdp.get_dom_snapshot': createRegistryEntry('cdp.get_dom_snapshot', 'cdp', true, [], 'high'),
-  'cdp.get_box_model': createRegistryEntry(
-    'cdp.get_box_model',
-    'cdp',
-    true,
-    ['elementRef'],
-    'high'
-  ),
+  'cdp.get_box_model': createRegistryEntry('cdp.get_box_model', 'cdp', true, ['nodeId'], 'high'),
   'cdp.get_computed_styles_for_node': createRegistryEntry(
     'cdp.get_computed_styles_for_node',
     'cdp',
     true,
-    ['elementRef'],
+    ['nodeId'],
     'high'
   ),
   'cdp.dispatch_key_event': createRegistryEntry(