@browserbridge/bbx 1.11.0 → 1.11.2

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/install-manifest.js

@@ -184,7 +184,8 @@ export function getDefaultExtensionId(env = process.env) {
 
 /**
  * Build the allowed_origins list.
- * If an extension ID was provided, ensures its origin is present.
+ * If an extension ID was provided, it is the complete allowlist so stale
+ * origins from an earlier installation do not retain native-host access.
  * Otherwise falls back to existing origins or a placeholder.
  *
  * @param {{allowed_origins?: string[]} | null} existingManifest
@@ -199,14 +200,7 @@ export function getAllowedOrigins(existingManifest, extensionId) {
 
   if (extensionId) {
     const origin = `chrome-extension://${extensionId}/`;
-    const merged = new Set(existing);
-    merged.add(origin);
-    for (const item of [...merged]) {
-      if (item.includes('__REPLACE_WITH_EXTENSION_ID__')) {
-        merged.delete(item);
-      }
-    }
-    return [...merged];
+    return [origin];
   }
 
   if (existing.length > 0) return existing;

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

@@ -8,7 +8,7 @@ import {
   parseJsonLines,
   sanitizeIncidentalText,
 } from '../../protocol/src/index.js';
-import { readBridgeAuthToken } from './auth-token.js';
+import { readBridgeExtensionAuthToken } from './auth-token.js';
 import { createSocketBridgeTransport, getBridgeTransport } from './config.js';
 import { spawnBridgeDaemonProcess } from './daemon-process.js';
 import { createNativeMessageReader, createNativeMessageWriter, writeJsonLine } from './framing.js';
@@ -163,16 +163,17 @@ export async function runNativeHost({
   socket.once('close', cleanupStdinEndListener);
   socket.once('end', cleanupStdinEndListener);
   socket.once('error', cleanupStdinEndListener);
-  const authToken = resolvedTransport.type === 'tcp' ? await readBridgeAuthToken() : null;
+  const authToken = await readBridgeExtensionAuthToken();
   await writeJsonLine(socket, {
     type: 'register',
     role: 'extension',
-    ...(authToken ? { authToken } : {}),
+    authToken,
   });
 
   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/defaults.js

@@ -45,6 +45,12 @@ export const MAX_BATCH_CALLS = 20;
 
 /** Maximum read-only batch calls executing concurrently. */
 export const MAX_BATCH_CONCURRENCY = 5;
+export const MAX_INTERCEPT_RULES_PER_TAB = 32;
+export const MAX_INTERCEPT_URL_PATTERN_LENGTH = 2_048;
+export const MAX_INTERCEPT_BODY_BYTES = 262_144;
+export const MAX_INTERCEPT_HEADERS = 64;
+export const MAX_INTERCEPT_HEADER_VALUE_BYTES = 8_192;
+export const MAX_INTERCEPT_HEADER_BYTES = 65_536;
 export const SCREENSHOT_AUTO_INLINE_BYTES = 262_144;
 export const SCREENSHOT_MAX_INLINE_BYTES = 524_288;
 export const ARTIFACT_CHUNK_BYTES = 196_608;

package/packages/protocol/src/protocol.js

@@ -26,6 +26,11 @@ import {
   MAX_EXTRACT_SETTLE_TIMEOUT_MS,
   MAX_ARTIFACT_BYTES,
   MAX_HAR_ENTRIES,
+  MAX_INTERCEPT_BODY_BYTES,
+  MAX_INTERCEPT_HEADER_BYTES,
+  MAX_INTERCEPT_HEADERS,
+  MAX_INTERCEPT_HEADER_VALUE_BYTES,
+  MAX_INTERCEPT_URL_PATTERN_LENGTH,
   MAX_SENSITIVE_VALUE_BYTES,
 } from './defaults.js';
 import { BridgeError, ERROR_CODES, getErrorRecovery } from './errors.js';
@@ -300,8 +305,16 @@ export function validateBridgeRequest(request) {
 
   const candidate = /** @type {Record<string, unknown>} */ (request);
 
-  if (typeof candidate.id !== 'string' || !candidate.id.trim()) {
-    throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'Request id must be a non-empty string.');
+  if (
+    typeof candidate.id !== 'string' ||
+    !candidate.id.trim() ||
+    candidate.id.length > 128 ||
+    hasAsciiControlCharacters(candidate.id)
+  ) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      'Request id must be a non-empty string of at most 128 characters without controls.'
+    );
   }
 
   if (
@@ -378,6 +391,15 @@ export function validateBridgeRequest(request) {
   };
 }
 
+/** @param {string} value @returns {boolean} */
+function hasAsciiControlCharacters(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
 /**
  * @param {unknown} source
  * @param {unknown} value
@@ -1503,6 +1525,12 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
   if (typeof params.urlPattern !== 'string' || !params.urlPattern) {
     throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'urlPattern is required.');
   }
+  if (params.urlPattern.length > MAX_INTERCEPT_URL_PATTERN_LENGTH) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `urlPattern must not exceed ${MAX_INTERCEPT_URL_PATTERN_LENGTH} characters.`
+    );
+  }
 
   const action = params.action ?? DEFAULT_NETWORK_INTERCEPT_ACTION;
   if (action !== 'fulfill' && action !== 'continue' && action !== 'block') {
@@ -1523,6 +1551,15 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
   if (params.body !== undefined && typeof params.body !== 'string') {
     throw new BridgeError(ERROR_CODES.INVALID_REQUEST, 'body must be a string.');
   }
+  if (
+    typeof params.body === 'string' &&
+    new TextEncoder().encode(params.body).byteLength > MAX_INTERCEPT_BODY_BYTES
+  ) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `body must not exceed ${MAX_INTERCEPT_BODY_BYTES} UTF-8 bytes.`
+    );
+  }
 
   /** @type {Record<string, string> | undefined} */
   let headers;
@@ -1533,8 +1570,16 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
         'headers must be an object containing string values.'
       );
     }
+    const entries = Object.entries(params.headers);
+    if (entries.length > MAX_INTERCEPT_HEADERS) {
+      throw new BridgeError(
+        ERROR_CODES.INVALID_REQUEST,
+        `headers must contain at most ${MAX_INTERCEPT_HEADERS} entries.`
+      );
+    }
     headers = {};
-    for (const [name, value] of Object.entries(params.headers)) {
+    let headerBytes = 0;
+    for (const [name, value] of entries) {
       if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) {
         throw new BridgeError(
           ERROR_CODES.INVALID_REQUEST,
@@ -1547,6 +1592,20 @@ export function normalizeNetworkInterceptAddParams(params = {}) {
           `Header ${name} must have a string value without newlines.`
         );
       }
+      const valueBytes = new TextEncoder().encode(value).byteLength;
+      if (valueBytes > MAX_INTERCEPT_HEADER_VALUE_BYTES) {
+        throw new BridgeError(
+          ERROR_CODES.INVALID_REQUEST,
+          `Header ${name} must not exceed ${MAX_INTERCEPT_HEADER_VALUE_BYTES} UTF-8 bytes.`
+        );
+      }
+      headerBytes += new TextEncoder().encode(name).byteLength + valueBytes;
+      if (headerBytes > MAX_INTERCEPT_HEADER_BYTES) {
+        throw new BridgeError(
+          ERROR_CODES.INVALID_REQUEST,
+          `headers must not exceed ${MAX_INTERCEPT_HEADER_BYTES} UTF-8 bytes in total.`
+        );
+      }
       headers[name] = value;
     }
   }

package/packages/protocol/src/types.ts

@@ -1053,6 +1053,8 @@ export interface NetworkResult {
   dropped: number;
   abandoned: number;
   source: NetworkSource;
+  provenance: 'page_main_world' | 'chrome_devtools_protocol';
+  integrity: 'untrusted' | 'browser_observed';
   capture: NetworkCaptureAction | null;
   armed: boolean;
   armedDuringCapture: boolean;