@browserbridge/bbx 1.1.0 → 1.3.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
@@ -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/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,18 +10,55 @@
 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));
 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`
-  );
+/**
+ * @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 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`
+    );
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await runPostinstall();
 }

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

@@ -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');
 }
 
@@ -196,6 +195,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 +245,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);
@@ -287,6 +316,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 +329,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 +355,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 +370,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 +398,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 +526,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 });
@@ -495,8 +540,30 @@ 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;
+    }
+
+    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;
@@ -593,6 +660,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,8 +672,37 @@ 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)));
+    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);
+        }
+      })
+    );
   }
 
   /**
@@ -697,6 +794,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 +813,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 +842,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 +861,7 @@ export class BridgeDaemon {
         }
         clearTimeout(pending.timeoutId);
         this.clearPendingRequest(id, pending);
+        this.recordRequestCompletion(id, false);
       }
     }
 
@@ -790,6 +893,7 @@ export class BridgeDaemon {
 
     clearTimeout(pending.timeoutId);
     this.clearPendingRequest(requestId, pending);
+    this.recordRequestCompletion(requestId, false);
 
     const response =
       pending.lastErrorResponse ??
@@ -815,6 +919,23 @@ export class BridgeDaemon {
     });
   }
 
+  /**
+   * @param {string} requestId
+   * @param {boolean} ok
+   * @returns {void}
+   */
+  recordRequestCompletion(requestId, ok) {
+    const startedAt = this.requestStartTimes.get(requestId);
+    this.requestStartTimes.delete(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}