@browserbridge/bbx 1.11.1 → 1.11.3

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

@@ -1,4 +1,5 @@
 // @ts-check
+import { isProtocolVersionSupported } from '../../protocol/src/index.js';
 
 import fs from 'node:fs';
 import net from 'node:net';
@@ -132,6 +133,7 @@ export const DAEMON_REGISTRATION_TIMEOUT_MS = 5_000;
 export const MAX_DAEMON_CONNECTIONS = 64;
 export const MAX_DAEMON_PENDING_REQUESTS = 128;
 export const MAX_DAEMON_PENDING_REQUESTS_PER_CLIENT = 16;
+export const MAX_DAEMON_ACTIVE_HANDLERS_PER_CLIENT = 32;
 export const MAX_DAEMON_INVALID_LINES = 3;
 const MAX_CLIENT_ID_LENGTH = 128;
 const MAX_ROUTING_LABEL_LENGTH = 128;
@@ -360,7 +362,11 @@ function createHealthRecoveryPayload(daemon, extensionResult) {
 function getVersionNegotiationPayload(requestedVersion) {
   const supportedVersions = getSupportedProtocolVersions();
   const latestSupported = supportedVersions[0];
-  if (!requestedVersion || !latestSupported || supportedVersions.includes(requestedVersion)) {
+  if (
+    !requestedVersion ||
+    !latestSupported ||
+    isProtocolVersionSupported(requestedVersion, supportedVersions)
+  ) {
     return { supported_versions: supportedVersions };
   }
 
@@ -462,6 +468,11 @@ export class BridgeDaemon {
     this.extensionSockets = new Map();
     /** @type {Map<string, ClientSocket>} */
     this.agentSockets = new Map();
+    /** @type {Set<ClientSocket>} */
+    this.clientSockets = new Set();
+    /** @type {Map<ClientSocket, number>} */
+    this.activeHandlers = new Map();
+    this.activeHandlerCount = 0;
     /** @type {Map<string, PendingEntry>} */
     this.pendingRequests = new Map();
     /** @type {Map<ClientSocket, Set<string>>} */
@@ -568,7 +579,7 @@ export class BridgeDaemon {
     pending = this.pendingRequests.get(requestId),
     preserveArtifacts = false
   ) {
-    if (!pending) {
+    if (!pending || this.pendingRequests.get(requestId) !== pending) {
       return undefined;
     }
     clearTimeout(pending.timeoutId);
@@ -621,6 +632,7 @@ export class BridgeDaemon {
    * @returns {void}
    */
   registerSocket(socket, message) {
+    this.clientSockets.add(socket);
     if (socket.__role) {
       void writeJsonLine(socket, {
         type: 'registration_failed',
@@ -628,7 +640,7 @@ export class BridgeDaemon {
           code: ERROR_CODES.INVALID_REQUEST,
           message: `Socket is already registered as ${socket.__role}.`,
         },
-      });
+      }).catch(() => socket.destroy());
       return;
     }
 
@@ -639,7 +651,7 @@ export class BridgeDaemon {
           code: ERROR_CODES.INVALID_REQUEST,
           message: 'Socket role must be "agent" or "extension".',
         },
-      });
+      }).catch(() => socket.destroy());
       return;
     }
 
@@ -657,7 +669,9 @@ export class BridgeDaemon {
           code: ERROR_CODES.ACCESS_DENIED,
           message: 'Bridge daemon authentication failed.',
         },
-      }).finally(() => socket.destroy());
+      })
+        .catch(() => {})
+        .finally(() => socket.destroy());
       return;
     }
 
@@ -686,7 +700,9 @@ export class BridgeDaemon {
         browserName: socket.__browserName ?? null,
         profileLabel: socket.__profileLabel ?? null,
       });
-      void writeJsonLine(socket, { type: 'registered', role: 'extension' });
+      void writeJsonLine(socket, { type: 'registered', role: 'extension' }).catch(() =>
+        socket.destroy()
+      );
       return;
     }
 
@@ -700,7 +716,9 @@ export class BridgeDaemon {
             code: ERROR_CODES.INVALID_REQUEST,
             message: 'Agent clientId is invalid.',
           },
-        }).finally(() => socket.destroy());
+        })
+          .catch(() => {})
+          .finally(() => socket.destroy());
         return;
       }
       this.agentSockets.set(clientId, socket);
@@ -710,7 +728,7 @@ export class BridgeDaemon {
         type: 'registered',
         role: 'agent',
         clientId,
-      });
+      }).catch(() => socket.destroy());
       return;
     }
   }
@@ -734,7 +752,7 @@ export class BridgeDaemon {
       }
       try {
         await fs.promises.access(this.socketPath);
-        if (await pingExistingDaemon(this.transport)) {
+        if (await hasLiveListener(this.transport)) {
           throw new Error(
             `Another daemon is already running on ${this.socketPath}. Stop it before starting a new one.`
           );
@@ -742,17 +760,17 @@ export class BridgeDaemon {
         this.logger.info('Removing stale socket from previous run', {
           socketPath: this.socketPath,
         });
+        await fs.promises.rm(this.socketPath, { force: true });
       } catch (error) {
-        if (error instanceof Error && error.message.startsWith('Another daemon')) {
+        if (!error || typeof error !== 'object' || !('code' in error) || error.code !== 'ENOENT')
           throw error;
-        }
         // Socket does not exist - normal startup.
       }
-      await fs.promises.rm(this.socketPath, { force: true });
     }
 
     this.server = net.createServer((socket) => {
       const typedSocket = /** @type {ClientSocket} */ (socket);
+      this.clientSockets.add(typedSocket);
       typedSocket.__invalidLineCount = 0;
       typedSocket.__registrationTimeoutId = setTimeout(() => {
         if (!typedSocket.__role) {
@@ -767,12 +785,37 @@ export class BridgeDaemon {
       parseJsonLines(
         typedSocket,
         (raw) => {
+          if (typedSocket.destroyed) return;
           const message = /** @type {DaemonMessage} */ (raw);
-          void this.handleClientMessage(typedSocket, message).catch((err) => {
-            this.logger.error('handler error', {
-              message: err instanceof Error ? err.message : String(err),
+          const admitted =
+            message?.type === 'agent.request' || message?.type === 'extension.setup_status.request';
+          const active = this.activeHandlers.get(typedSocket) ?? 0;
+          if (
+            admitted &&
+            (active >= MAX_DAEMON_ACTIVE_HANDLERS_PER_CLIENT ||
+              this.activeHandlerCount >= MAX_DAEMON_PENDING_REQUESTS)
+          ) {
+            typedSocket.destroy();
+            return;
+          }
+          if (admitted) {
+            this.activeHandlers.set(typedSocket, active + 1);
+            this.activeHandlerCount += 1;
+          }
+          void this.handleClientMessage(typedSocket, message)
+            .catch((err) => {
+              this.logger.error('handler error', {
+                message: err instanceof Error ? err.message : String(err),
+              });
+            })
+            .finally(() => {
+              if (admitted) {
+                const remaining = (this.activeHandlers.get(typedSocket) ?? 1) - 1;
+                if (remaining) this.activeHandlers.set(typedSocket, remaining);
+                else this.activeHandlers.delete(typedSocket);
+                this.activeHandlerCount -= 1;
+              }
             });
-          });
         },
         {
           onProtocolError: (error) => {
@@ -845,6 +888,10 @@ export class BridgeDaemon {
     this.pendingRequests.clear();
     this.pendingRequestsByOwnerSocket.clear();
     this.pendingRequestsByTargetSocket.clear();
+    this.requestStartTimes.clear();
+
+    for (const socket of this.clientSockets) socket.destroy();
+    this.clientSockets.clear();
 
     for (const socket of this.agentSockets.values()) {
       socket.destroy();
@@ -864,6 +911,7 @@ export class BridgeDaemon {
 
     if (this.server) {
       const server = this.server;
+      const ownedListener = server.listening;
       this.server = null;
       try {
         await new Promise((resolve, reject) => {
@@ -876,7 +924,11 @@ export class BridgeDaemon {
           });
         });
       } finally {
-        if (this.transport.type === 'socket' && !isWindowsNamedPipePath(this.socketPath)) {
+        if (
+          ownedListener &&
+          this.transport.type === 'socket' &&
+          !isWindowsNamedPipePath(this.socketPath)
+        ) {
           await fs.promises.rm(this.socketPath, { force: true });
         }
       }
@@ -1321,7 +1373,7 @@ export class BridgeDaemon {
         message: error instanceof Error ? error.message : String(error),
       });
       const pending = this.pendingRequests.get(request.id);
-      if (!pending) {
+      if (!pending || !pending.targets.has(target)) {
         return;
       }
       this.removePendingTarget(request.id, pending, target);
@@ -1496,6 +1548,20 @@ export class BridgeDaemon {
     const ownerId = pending.socket.__clientId;
     if (!ownerId) return;
     try {
+      if (
+        message.type === 'extension.artifact.chunk' ||
+        message.type === 'extension.artifact.commit'
+      ) {
+        const transfer = this.artifactStore.transfers.get(String(message.artifactId ?? ''));
+        if (
+          !transfer ||
+          transfer.requestId !== requestId ||
+          transfer.ownerId !== ownerId ||
+          transfer.extensionId !== socket.__extensionId
+        ) {
+          throw new Error('Artifact transfer does not belong to this request and extension.');
+        }
+      }
       if (message.type === 'extension.artifact.begin') {
         this.artifactStore.begin({
           artifactId: String(artifact.artifactId ?? ''),
@@ -1591,6 +1657,7 @@ export class BridgeDaemon {
     }
 
     this.removePendingTarget(responseMessage.id, pending, socket);
+    clearTimeout(pending.timeoutId);
 
     if (responseMessage.ok) {
       const result =
@@ -1636,7 +1703,7 @@ export class BridgeDaemon {
           }
         }
         if (!this.domBaselines.register(baselineId, socket, result.expiresAt)) {
-          await this.releaseOrphanDomBaseline(socket, responseMessage);
+          await this.releaseOrphanDomBaseline(socket, responseMessage).catch(() => {});
           pending.lastErrorResponse = createFailure(
             responseMessage.id,
             ERROR_CODES.DOM_BASELINE_INVALIDATED,
@@ -1688,11 +1755,12 @@ export class BridgeDaemon {
           if (baselineId) this.domBaselines.delete(baselineId);
           await this.releaseOrphanDomBaseline(socket, responseMessage).catch(() => {});
         }
-        this.clearPendingRequest(responseMessage.id, pending);
-        this.recordRequestCompletion(responseMessage.id, false, pending);
+        if (this.clearPendingRequest(responseMessage.id, pending)) {
+          this.recordRequestCompletion(responseMessage.id, false, pending);
+        }
         throw error;
       }
-      this.clearPendingRequest(responseMessage.id, pending, true);
+      if (!this.clearPendingRequest(responseMessage.id, pending, true)) return;
       this.recordRequestCompletion(responseMessage.id, true, pending);
       this.pushLog({
         at: new Date().toISOString(),
@@ -1719,6 +1787,7 @@ export class BridgeDaemon {
    * @returns {void}
    */
   handleSocketClose(socket) {
+    this.clientSockets.delete(socket);
     if (socket.__registrationTimeoutId) {
       clearTimeout(socket.__registrationTimeoutId);
       socket.__registrationTimeoutId = undefined;
@@ -1781,7 +1850,7 @@ export class BridgeDaemon {
    * @returns {Promise<void>}
    */
   async finishPendingRequestIfExhausted(requestId, pending) {
-    if (pending.targets.size > 0 || !this.pendingRequests.has(requestId)) {
+    if (pending.targets.size > 0 || this.pendingRequests.get(requestId) !== pending) {
       return;
     }
 
@@ -1975,6 +2044,37 @@ export async function pingExistingDaemon(transport) {
   });
 }
 
+/**
+ * Only a refused or missing endpoint proves a Unix socket is stale.
+ * @param {BridgeTransport} transport
+ * @returns {Promise<boolean>}
+ */
+export function hasLiveListener(transport) {
+  return new Promise((resolve, reject) => {
+    const socket =
+      transport.type === 'tcp'
+        ? net.createConnection({ host: transport.host, port: transport.port })
+        : net.createConnection(transport.socketPath);
+    const timer = setTimeout(() => finish(true), DAEMON_EXISTING_SOCKET_PING_TIMEOUT_MS);
+    /** @param {boolean} live @param {Error} [error] */
+    function finish(live, error) {
+      clearTimeout(timer);
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(live);
+    }
+    socket.once('connect', () => finish(true));
+    socket.once('error', (error) => {
+      if (
+        'code' in error &&
+        (error.code === 'ENOENT' || error.code === 'ECONNREFUSED' || error.code === 'ENOTSOCK')
+      )
+        finish(false);
+      else finish(true, error);
+    });
+  });
+}
+
 /**
  * @param {Record<string, unknown>} params
  * @returns {SetupInstallParams & { action: 'install' | 'uninstall', kind: 'mcp' | 'skill', target: string }}

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

@@ -1,9 +1,111 @@
 // @ts-check
 
-import { once } from 'node:events';
-
 import { MAX_JSON_LINE_BYTES, MAX_NATIVE_MESSAGE_BYTES } from '../../protocol/src/index.js';
 
+export const MAX_OUTPUT_QUEUE_BYTES = 4 * MAX_JSON_LINE_BYTES;
+export const MAX_OUTPUT_QUEUE_MESSAGES = 128;
+export const OUTPUT_DRAIN_TIMEOUT_MS = 30_000;
+
+/** @typedef {NodeJS.WritableStream & { destroyed?: boolean, writableEnded?: boolean, destroy?: () => unknown }} OutputStream */
+/** @typedef {{ parts: Array<string | Buffer>, bytes: number, resolve: () => void, reject: (error: Error) => void }} QueuedWrite */
+
+/** @param {OutputStream} stream @returns {(parts: Array<string | Buffer>) => Promise<void>} */
+function createBoundedWriter(stream) {
+  /** @type {QueuedWrite[]} */
+  const queue = [];
+  let bytes = 0;
+  let running = false;
+  /** @type {Error | null} */
+  let failure = null;
+  /** @type {((error: Error) => void) | null} */
+  let cancelDrain = null;
+
+  /** @param {Error} error */
+  function fail(error) {
+    failure ??= error;
+    cancelDrain?.(error);
+    for (const entry of queue.splice(0)) entry.reject(error);
+    bytes = 0;
+    stream.destroy?.();
+  }
+
+  async function pump() {
+    if (running) return;
+    running = true;
+    try {
+      while (queue.length && !failure) {
+        const entry = queue[0];
+        for (const part of entry.parts) {
+          if (failure) throw failure;
+          if (stream.destroyed || stream.writableEnded) throw new Error('Output stream closed.');
+          if (!stream.write(part)) {
+            await new Promise((resolve, reject) => {
+              const timer = setTimeout(
+                () => finish(new Error('Output drain timed out.')),
+                OUTPUT_DRAIN_TIMEOUT_MS
+              );
+              timer.unref?.();
+              /** @param {Error} [error] */
+              function finish(error) {
+                clearTimeout(timer);
+                stream.removeListener('drain', drained);
+                stream.removeListener('close', closed);
+                stream.removeListener('error', finish);
+                cancelDrain = null;
+                if (error) reject(error);
+                else resolve(undefined);
+              }
+              const drained = () => finish();
+              const closed = () => finish(new Error('Output stream closed while writing.'));
+              cancelDrain = finish;
+              stream.once('drain', drained);
+              stream.once('close', closed);
+              stream.once('error', finish);
+            });
+          }
+        }
+        if (failure) break;
+        queue.shift();
+        bytes -= entry.bytes;
+        entry.resolve();
+      }
+    } catch (error) {
+      fail(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      running = false;
+    }
+  }
+
+  return (parts) => {
+    if (failure) return Promise.reject(failure);
+    const size = parts.reduce((total, part) => total + Buffer.byteLength(part), 0);
+    if (queue.length >= MAX_OUTPUT_QUEUE_MESSAGES || bytes + size > MAX_OUTPUT_QUEUE_BYTES) {
+      const error = new Error('Output queue limit exceeded.');
+      fail(error);
+      return Promise.reject(error);
+    }
+    const result = new Promise((resolve, reject) => {
+      queue.push({ parts, bytes: size, resolve: () => resolve(undefined), reject });
+      bytes += size;
+    });
+    void pump();
+    return result;
+  };
+}
+
+/** @type {WeakMap<OutputStream, ReturnType<typeof createBoundedWriter>>} */
+const outputWriters = new WeakMap();
+
+/** @param {OutputStream} stream @param {Array<string | Buffer>} parts */
+function writeParts(stream, parts) {
+  let writer = outputWriters.get(stream);
+  if (!writer) {
+    writer = createBoundedWriter(stream);
+    outputWriters.set(stream, writer);
+  }
+  return writer(parts);
+}
+
 /**
  * @param {NodeJS.WritableStream} stream
  * @param {unknown} message
@@ -16,12 +118,7 @@ export async function writeNativeMessage(stream, message) {
   }
   const header = Buffer.alloc(4);
   header.writeUInt32LE(payload.length, 0);
-  if (!stream.write(header)) {
-    await once(stream, 'drain');
-  }
-  if (!stream.write(payload)) {
-    await once(stream, 'drain');
-  }
+  await writeParts(stream, [header, payload]);
 }
 
 /**
@@ -29,12 +126,7 @@ export async function writeNativeMessage(stream, message) {
  * @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;
-  };
+  return (message) => writeNativeMessage(stream, message);
 }
 
 /**
@@ -198,7 +290,5 @@ export async function writeJsonLine(socket, message) {
   if (byteLength > MAX_JSON_LINE_BYTES) {
     throw new Error(`JSON line exceeds ${MAX_JSON_LINE_BYTES} bytes: ${byteLength}`);
   }
-  if (!socket.write(line)) {
-    await once(socket, 'drain');
-  }
+  await writeParts(socket, [line]);
 }

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

@@ -173,6 +173,7 @@ export async function runNativeHost({
   parseJsonLines(
     socket,
     (raw) => {
+      if (socket.destroyed) return;
       const message = /** @type {Record<string, unknown>} */ (raw);
       void (async () => {
         if (message.type === 'extension.request') {
@@ -201,6 +202,7 @@ export async function runNativeHost({
           });
         }
       })().catch((err) => {
+        socket.destroy();
         console.error(
           'native-host: socket message handler failed:',
           err instanceof Error ? err.message : err
@@ -220,6 +222,7 @@ export async function runNativeHost({
   createNativeMessageReader(
     process.stdin,
     (message) => {
+      if (socket.destroyed) return;
       void (async () => {
         if (isHostBridgeRequest(message)) {
           await writeJsonLine(socket, {
@@ -271,6 +274,7 @@ export async function runNativeHost({
           response: message,
         });
       })().catch((err) => {
+        socket.destroy();
         console.error(
           'native-host: stdin message handler failed:',
           err instanceof Error ? err.message : err

package/packages/protocol/src/protocol.js

@@ -133,6 +133,20 @@ export function deriveProtocolVersion(packageVersion) {
   return match ? `${match[1]}.${match[2]}` : '0.0';
 }
 
+/**
+ * Minor and patch releases are compatible in either direction within a major.
+ * @param {string} requestedVersion
+ * @param {readonly string[]} supportedVersions
+ * @returns {boolean}
+ */
+export function isProtocolVersionSupported(requestedVersion, supportedVersions) {
+  const major = /^(\d+)\.\d+$/.exec(requestedVersion)?.[1];
+  return (
+    major !== undefined &&
+    supportedVersions.some((version) => /^(\d+)\.\d+$/.exec(version)?.[1] === major)
+  );
+}
+
 /**
  * @returns {string | null}
  */