@browserbridge/bbx 1.0.0 → 1.1.0

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

@@ -11,6 +11,9 @@ import { MAX_NATIVE_MESSAGE_BYTES } from '../../protocol/src/index.js';
  */
 export async function writeNativeMessage(stream, message) {
   const payload = Buffer.from(JSON.stringify(message), 'utf8');
+  if (payload.length > MAX_NATIVE_MESSAGE_BYTES) {
+    throw new Error(`Native message exceeds ${MAX_NATIVE_MESSAGE_BYTES} bytes: ${payload.length}`);
+  }
   const header = Buffer.alloc(4);
   header.writeUInt32LE(payload.length, 0);
   if (!stream.write(header)) {
@@ -24,34 +27,151 @@ export async function writeNativeMessage(stream, message) {
 /**
  * @param {NodeJS.ReadableStream} stream
  * @param {(message: unknown) => void} onMessage
+ * @param {(error: Error) => void} [onProtocolError]
  * @returns {void}
  */
-export function createNativeMessageReader(stream, onMessage) {
-  let buffer = Buffer.alloc(0);
+export function createNativeMessageReader(stream, onMessage, onProtocolError) {
+  /** @type {Buffer[]} */
+  const chunks = [];
+  let bufferedBytes = 0;
+  let closed = false;
+
+  /**
+   * @param {number} length
+   * @returns {Buffer | null}
+   */
+  function peekBytes(length) {
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (bufferedBytes < length || chunks.length === 0) {
+      return null;
+    }
+
+    const firstChunk = chunks[0];
+    if (firstChunk.length >= length) {
+      return firstChunk.subarray(0, length);
+    }
+
+    const combined = Buffer.allocUnsafe(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      const copyLength = Math.min(chunk.length, length - offset);
+      chunk.copy(combined, offset, 0, copyLength);
+      offset += copyLength;
+      if (offset === length) {
+        return combined;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * @param {number} length
+   * @returns {Buffer | null}
+   */
+  function consumeBytes(length) {
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (bufferedBytes < length || chunks.length === 0) {
+      return null;
+    }
+
+    const firstChunk = chunks[0];
+    if (firstChunk.length === length) {
+      chunks.shift();
+      bufferedBytes -= length;
+      return firstChunk;
+    }
+    if (firstChunk.length > length) {
+      const consumed = firstChunk.subarray(0, length);
+      chunks[0] = firstChunk.subarray(length);
+      bufferedBytes -= length;
+      return consumed;
+    }
+
+    const combined = Buffer.allocUnsafe(length);
+    let offset = 0;
+    let remaining = length;
+    while (remaining > 0 && chunks.length > 0) {
+      const chunk = chunks[0];
+      const copyLength = Math.min(chunk.length, remaining);
+      chunk.copy(combined, offset, 0, copyLength);
+      offset += copyLength;
+      remaining -= copyLength;
+      if (copyLength === chunk.length) {
+        chunks.shift();
+      } else {
+        chunks[0] = chunk.subarray(copyLength);
+      }
+    }
+
+    bufferedBytes -= length;
+    return combined;
+  }
+
+  /**
+   * @param {Error} error
+   * @returns {void}
+   */
+  function closeReader(error) {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    stream.removeListener('data', handleData);
+    onProtocolError?.(error);
+    const destroy = /** @type {{ destroy?: (() => void) | undefined }} */ (stream).destroy;
+    if (typeof destroy === 'function') {
+      destroy.call(stream);
+    }
+  }
 
   /** @param {Buffer} chunk */
-  stream.on('data', (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
+  function handleData(chunk) {
+    if (closed || chunk.length === 0) {
+      return;
+    }
+
+    chunks.push(chunk);
+    bufferedBytes += chunk.length;
 
-    while (buffer.length >= 4) {
-      const length = buffer.readUInt32LE(0);
+    while (bufferedBytes >= 4) {
+      const header = peekBytes(4);
+      if (!header) {
+        return;
+      }
+
+      const length = header.readUInt32LE(0);
       if (length > MAX_NATIVE_MESSAGE_BYTES) {
-        buffer = Buffer.alloc(0);
+        closeReader(
+          new Error(`Native message exceeds ${MAX_NATIVE_MESSAGE_BYTES} bytes: ${length}`)
+        );
         return;
       }
-      if (buffer.length < 4 + length) {
+
+      const frameLength = 4 + length;
+      if (bufferedBytes < frameLength) {
         return;
       }
 
-      const payload = buffer.subarray(4, 4 + length);
-      buffer = buffer.subarray(4 + length);
+      const frame = consumeBytes(frameLength);
+      if (!frame) {
+        return;
+      }
+
+      const payload = frame.subarray(4);
       try {
         onMessage(JSON.parse(payload.toString('utf8')));
       } catch {
         // Malformed JSON payload - skip it.
       }
     }
-  });
+  }
+
+  stream.on('data', handleData);
 }
 
 /**

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

@@ -1,15 +1,57 @@
 // @ts-check
 
+import { execFile } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-
-import { APP_NAME, getBridgeDir, getLauncherFilename, getManifestInstallDir, PUBLISHED_EXTENSION_ID } from './config.js';
+import { promisify } from 'node:util';
+
+import {
+  APP_NAME,
+  BRIDGE_TCP_PORT_ENV,
+  DEFAULT_WINDOWS_TCP_PORT,
+  getBridgeDir,
+  getLauncherFilename,
+  getManifestInstallDir,
+  PUBLISHED_EXTENSION_ID,
+} from './config.js';
 
 export const DEFAULT_EXTENSION_ID_ENV = 'BROWSER_BRIDGE_EXTENSION_ID';
 export const BUILT_IN_EXTENSION_ID_SOURCE = 'built_in';
+export const INSTALL_NATIVE_MANIFEST_ERROR = 'INSTALL_NATIVE_MANIFEST_FAILED';
 
 /** @typedef {import('./config.js').SupportedBrowser} SupportedBrowser */
 /** @typedef {'env' | 'built_in' | 'none' | 'invalid_env'} ExtensionIdSource */
+/** @typedef {NodeJS.ErrnoException & { cause?: unknown }} MaybeErrnoError */
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * @returns {string}
+ */
+function getWindowsRegistryExe() {
+  if (process.platform !== 'win32') {
+    return 'reg.exe';
+  }
+
+  const systemRoot = process.env.SystemRoot || process.env.WINDIR;
+  return systemRoot ? path.join(systemRoot, 'System32', 'reg.exe') : 'reg.exe';
+}
+
+export class NativeManifestInstallError extends Error {
+  /**
+   * @param {string} targetPath
+   * @param {unknown} cause
+   */
+  constructor(targetPath, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Failed to install native host files at ${targetPath}: ${detail}`, { cause });
+    this.name = 'NativeManifestInstallError';
+    this.code = INSTALL_NATIVE_MANIFEST_ERROR;
+    this.targetPath = targetPath;
+    this.cause = cause;
+    this.errnoCode = /** @type {MaybeErrnoError | undefined} */ (cause)?.code;
+  }
+}
 
 /**
  * @typedef {{
@@ -21,6 +63,8 @@ export const BUILT_IN_EXTENSION_ID_SOURCE = 'built_in';
  *   bridgeDir?: string | undefined,
  *   stdout?: Pick<NodeJS.WriteStream, 'write'>,
  *   stderr?: Pick<NodeJS.WriteStream, 'write'>,
+ *   preserveCustomExtensionId?: boolean | undefined,
+ *   writeRegistryValue?: ((keyPath: string, value: string) => Promise<void> | void) | undefined,
  *   env?: NodeJS.ProcessEnv
  * }} InstallManifestOptions
  */
@@ -31,10 +75,64 @@ export const BUILT_IN_EXTENSION_ID_SOURCE = 'built_in';
  *   installDir?: string | undefined,
  *   bridgeDir?: string | undefined,
  *   removeBridgeDir?: boolean | undefined,
+ *   deleteRegistryKey?: ((keyPath: string) => Promise<boolean> | boolean) | undefined,
  *   stdout?: Pick<NodeJS.WriteStream, 'write'>
  * }} UninstallManifestOptions
  */
 
+/**
+ * @param {SupportedBrowser} [browser='chrome']
+ * @returns {string}
+ */
+export function getWindowsRegistryKey(browser = 'chrome') {
+  const roots = {
+    chrome: 'HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts',
+    edge: 'HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts',
+    brave: 'HKCU\\Software\\BraveSoftware\\Brave-Browser\\NativeMessagingHosts',
+    chromium: 'HKCU\\Software\\Chromium\\NativeMessagingHosts',
+    // Arc is Chromium-based, and no verified Browser Company-specific native
+    // messaging registry path is documented in this repo yet.
+    arc: 'HKCU\\Software\\Chromium\\NativeMessagingHosts',
+  };
+
+  return `${roots[browser] || roots.chrome}\\${APP_NAME}`;
+}
+
+/**
+ * @param {string} keyPath
+ * @param {string} value
+ * @returns {Promise<void>}
+ */
+async function writeRegistryValue(keyPath, value) {
+  await execFileAsync(getWindowsRegistryExe(), [
+    'add',
+    keyPath,
+    '/ve',
+    '/t',
+    'REG_SZ',
+    '/d',
+    value,
+    '/f',
+  ]);
+}
+
+/**
+ * @param {string} keyPath
+ * @returns {Promise<boolean>}
+ */
+async function deleteRegistryKey(keyPath) {
+  try {
+    await execFileAsync(getWindowsRegistryExe(), ['delete', keyPath, '/f']);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/unable to find|cannot find|was unable to find/i.test(message)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
 /**
  * Parse and validate a Chrome extension ID from a CLI argument.
  * Accepts a raw 32-char ID or a full `chrome-extension://<id>/` origin.
@@ -62,13 +160,13 @@ export function resolveDefaultExtensionId(env = process.env) {
     const parsed = parseExtensionId(candidate);
     return {
       extensionId: parsed,
-      source: parsed ? 'env' : 'invalid_env'
+      source: parsed ? 'env' : 'invalid_env',
     };
   }
 
   return {
     extensionId: PUBLISHED_EXTENSION_ID || null,
-    source: PUBLISHED_EXTENSION_ID ? 'built_in' : 'none'
+    source: PUBLISHED_EXTENSION_ID ? 'built_in' : 'none',
   };
 }
 
@@ -90,9 +188,10 @@ export function getDefaultExtensionId(env = process.env) {
  * @returns {string[]}
  */
 export function getAllowedOrigins(existingManifest, extensionId) {
-  const existing = (existingManifest && Array.isArray(existingManifest.allowed_origins))
-    ? existingManifest.allowed_origins
-    : [];
+  const existing =
+    existingManifest && Array.isArray(existingManifest.allowed_origins)
+      ? existingManifest.allowed_origins
+      : [];
 
   if (extensionId) {
     const origin = `chrome-extension://${extensionId}/`;
@@ -110,6 +209,25 @@ export function getAllowedOrigins(existingManifest, extensionId) {
   return ['chrome-extension://__REPLACE_WITH_EXTENSION_ID__/'];
 }
 
+/**
+ * @param {string[] | undefined} allowedOrigins
+ * @returns {string[]}
+ */
+function getExtensionIdsFromAllowedOrigins(allowedOrigins) {
+  if (!Array.isArray(allowedOrigins)) {
+    return [];
+  }
+
+  const ids = new Set();
+  for (const origin of allowedOrigins) {
+    const match = /^chrome-extension:\/\/([a-z]{32})\/?$/.exec(origin);
+    if (match?.[1]) {
+      ids.add(match[1]);
+    }
+  }
+  return [...ids];
+}
+
 /**
  * @param {string} value
  * @returns {string}
@@ -144,7 +262,10 @@ export async function installNativeManifest(options) {
     installDir = getManifestInstallDir(browser),
     bridgeDir = getBridgeDir(),
     stdout = process.stdout,
-    env = process.env
+    stderr = process.stderr,
+    preserveCustomExtensionId = false,
+    writeRegistryValue: writeRegistryValueFn = writeRegistryValue,
+    env = process.env,
   } = options;
 
   const parsedExtensionId = parseExtensionId(extensionIdArg);
@@ -160,19 +281,35 @@ export async function installNativeManifest(options) {
       `Invalid ${DEFAULT_EXTENSION_ID_ENV}: ${env[DEFAULT_EXTENSION_ID_ENV]}\nExpected 32 lowercase letters or chrome-extension://<id>/`
     );
   }
-  const extensionId = parsedExtensionId || defaultExtensionId.extensionId;
+  const requestedExtensionId = parsedExtensionId || defaultExtensionId.extensionId;
   const hostPath = path.join(repoRoot, 'packages', 'native-host', 'bin', 'native-host.js');
   const launcherPath = path.join(bridgeDir, getLauncherFilename());
   const manifestPath = path.join(installDir, `${APP_NAME}.json`);
 
-  const launcher = process.platform === 'win32'
-    ? `@echo off\r\n"${nodePath}" "${hostPath}" %*\r\n`
-    : `#!/bin/sh
+  const launcher =
+    process.platform === 'win32'
+      ? `@echo off\r\nset ${BRIDGE_TCP_PORT_ENV}=${DEFAULT_WINDOWS_TCP_PORT}\r\n"${nodePath}" "${hostPath}" %*\r\n`
+      : `#!/bin/sh
 exec '${escapeSingleQuotes(nodePath)}' '${escapeSingleQuotes(hostPath)}' "$@"
 `;
 
   const existingManifest = await readExistingManifest(manifestPath);
-  const allowedOrigins = getAllowedOrigins(existingManifest, extensionId);
+  const existingExtensionIds = getExtensionIdsFromAllowedOrigins(existingManifest?.allowed_origins);
+  const hasStoreOrigin = existingExtensionIds.includes(PUBLISHED_EXTENSION_ID);
+  const customExtensionIds = existingExtensionIds.filter((id) => id !== PUBLISHED_EXTENSION_ID);
+  const preservedCustomExtensionId =
+    preserveCustomExtensionId &&
+    !parsedExtensionId &&
+    extensionIdArg == null &&
+    defaultExtensionId.source === BUILT_IN_EXTENSION_ID_SOURCE &&
+    customExtensionIds.length > 0 &&
+    !hasStoreOrigin;
+  const allowedOrigins = preservedCustomExtensionId
+    ? getAllowedOrigins(existingManifest, null)
+    : getAllowedOrigins(existingManifest, requestedExtensionId);
+  const extensionId = preservedCustomExtensionId
+    ? customExtensionIds[0] || requestedExtensionId
+    : requestedExtensionId;
 
   /** @type {{name: string, description: string, path: string, type: 'stdio', allowed_origins: string[]}} */
   const manifest = {
@@ -180,21 +317,36 @@ exec '${escapeSingleQuotes(nodePath)}' '${escapeSingleQuotes(hostPath)}' "$@"
     description: 'Browser Bridge native host',
     path: launcherPath,
     type: 'stdio',
-    allowed_origins: allowedOrigins
+    allowed_origins: allowedOrigins,
   };
 
-  await fs.promises.mkdir(installDir, { recursive: true });
-  await fs.promises.mkdir(bridgeDir, { recursive: true });
-  await fs.promises.writeFile(launcherPath, launcher, 'utf8');
-  if (process.platform !== 'win32') {
-    await fs.promises.chmod(launcherPath, 0o755);
+  let failingPath = installDir;
+  try {
+    await fs.promises.mkdir(installDir, { recursive: true });
+    failingPath = bridgeDir;
+    await fs.promises.mkdir(bridgeDir, { recursive: true });
+    failingPath = launcherPath;
+    await fs.promises.writeFile(launcherPath, launcher, 'utf8');
+    if (process.platform !== 'win32') {
+      await fs.promises.chmod(launcherPath, 0o755);
+    }
+    failingPath = manifestPath;
+    await fs.promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    if (process.platform === 'win32') {
+      failingPath = getWindowsRegistryKey(browser);
+      await writeRegistryValueFn(getWindowsRegistryKey(browser), manifestPath);
+    }
+  } catch (error) {
+    throw new NativeManifestInstallError(failingPath, error);
   }
-  await fs.promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
 
   stdout.write(`Wrote ${manifestPath}\n`);
   stdout.write(`Wrote ${launcherPath}\n`);
+  if (process.platform === 'win32') {
+    stdout.write(`Registered ${getWindowsRegistryKey(browser)}\n`);
+  }
 
-  if (!parsedExtensionId && extensionIdArg == null && extensionId) {
+  if (!preservedCustomExtensionId && !parsedExtensionId && extensionIdArg == null && extensionId) {
     if (defaultExtensionId.source === 'env') {
       stdout.write(`Used extension ID from ${DEFAULT_EXTENSION_ID_ENV}.\n`);
     } else if (defaultExtensionId.source === BUILT_IN_EXTENSION_ID_SOURCE) {
@@ -202,11 +354,19 @@ exec '${escapeSingleQuotes(nodePath)}' '${escapeSingleQuotes(hostPath)}' "$@"
     }
   }
 
-  const hasPlaceholder = allowedOrigins.some((origin) => origin.includes('__REPLACE_WITH_EXTENSION_ID__'));
+  if (preservedCustomExtensionId) {
+    stderr.write(
+      `Warning: existing native host manifest keeps custom extension ID ${customExtensionIds.join(', ')} instead of the Browser Bridge store ID ${PUBLISHED_EXTENSION_ID}. Leaving allowed_origins unchanged.\n`
+    );
+  }
+
+  const hasPlaceholder = allowedOrigins.some((origin) =>
+    origin.includes('__REPLACE_WITH_EXTENSION_ID__')
+  );
   if (hasPlaceholder) {
     stdout.write(
       'Tip: pass the extension ID to set allowed_origins automatically:\n' +
-      '  bbx install <extension-id>\n'
+        '  bbx install <extension-id>\n'
     );
   }
 
@@ -214,7 +374,7 @@ exec '${escapeSingleQuotes(nodePath)}' '${escapeSingleQuotes(hostPath)}' "$@"
     manifestPath,
     launcherPath,
     allowedOrigins,
-    extensionId
+    extensionId,
   };
 }
 
@@ -228,18 +388,23 @@ export async function uninstallNativeManifest(options = {}) {
     installDir = getManifestInstallDir(browser),
     bridgeDir = getBridgeDir(),
     removeBridgeDir = false,
-    stdout = process.stdout
+    deleteRegistryKey: deleteRegistryKeyFn = deleteRegistryKey,
+    stdout = process.stdout,
   } = options;
 
   const manifestPath = path.join(installDir, `${APP_NAME}.json`);
+  const registryKeyPath = process.platform === 'win32' ? getWindowsRegistryKey(browser) : null;
   const removedManifest = await removePathIfExists(manifestPath);
   if (removedManifest) {
     stdout.write(`Removed ${manifestPath}\n`);
   }
 
-  const removedBridgeDir = removeBridgeDir
-    ? await removePathIfExists(bridgeDir)
-    : false;
+  const removedRegistryKey = registryKeyPath ? await deleteRegistryKeyFn(registryKeyPath) : false;
+  if (removedRegistryKey && registryKeyPath) {
+    stdout.write(`Removed ${registryKeyPath}\n`);
+  }
+
+  const removedBridgeDir = removeBridgeDir ? await removePathIfExists(bridgeDir) : false;
   if (removedBridgeDir) {
     stdout.write(`Removed ${bridgeDir}\n`);
   }
@@ -248,7 +413,7 @@ export async function uninstallNativeManifest(options = {}) {
     manifestPath,
     bridgeDir,
     removedManifest,
-    removedBridgeDir
+    removedBridgeDir,
   };
 }