@browserbridge/bbx 1.6.1 → 1.6.3

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

@@ -6,9 +6,13 @@ import path from 'node:path';
 
 import { getBridgeDir } from './config.js';
 
+export const BRIDGE_AUTH_TOKEN_ENV = 'BBX_AUTH_TOKEN';
+export const BRIDGE_AUTH_TOKEN_FILE_ENV = 'BBX_AUTH_TOKEN_FILE';
 const TOKEN_FILENAME = 'daemon.auth';
 const TOKEN_BYTES = 32;
 const TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,256}$/u;
+const UUID_TOKEN_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 
 /**
  * @param {NodeJS.ProcessEnv} [env=process.env]
@@ -27,7 +31,32 @@ export function normalizeBridgeAuthToken(value) {
     return null;
   }
   const token = value.trim();
-  return TOKEN_PATTERN.test(token) ? token : null;
+  return TOKEN_PATTERN.test(token) || UUID_TOKEN_PATTERN.test(token) ? token : null;
+}
+
+/**
+ * @param {{ env?: NodeJS.ProcessEnv, readFile?: typeof fs.promises.readFile }} [options={}]
+ * @returns {Promise<string | null>}
+ */
+export async function readBridgeAuthTokenOverride(options = {}) {
+  const env = options.env ?? process.env;
+  const readFile = options.readFile ?? fs.promises.readFile.bind(fs.promises);
+  const explicitToken = normalizeBridgeAuthToken(env[BRIDGE_AUTH_TOKEN_ENV]);
+  if (explicitToken) {
+    return explicitToken;
+  }
+  const tokenFile = env[BRIDGE_AUTH_TOKEN_FILE_ENV];
+  if (!tokenFile) {
+    return null;
+  }
+  try {
+    return normalizeBridgeAuthToken(await readFile(tokenFile, 'utf8'));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    throw error;
+  }
 }
 
 /**
@@ -35,6 +64,10 @@ export function normalizeBridgeAuthToken(value) {
  * @returns {Promise<string | null>}
  */
 export async function readBridgeAuthToken(options = {}) {
+  const override = await readBridgeAuthTokenOverride(options);
+  if (override) {
+    return override;
+  }
   const tokenPath = options.tokenPath ?? getBridgeAuthTokenPath();
   const readFile = options.readFile ?? fs.promises.readFile.bind(fs.promises);
   try {
@@ -47,6 +80,28 @@ export async function readBridgeAuthToken(options = {}) {
   }
 }
 
+/**
+ * @param {string} token
+ * @param {{ tokenPath?: string, writeFile?: typeof fs.promises.writeFile, mkdir?: typeof fs.promises.mkdir, chmod?: typeof fs.promises.chmod }} [options={}]
+ * @returns {Promise<string>}
+ */
+export async function writeBridgeAuthToken(token, options = {}) {
+  const normalized = normalizeBridgeAuthToken(token);
+  if (!normalized) {
+    throw new Error('Bridge auth token must be a UUID or 32-256 URL-safe characters.');
+  }
+  const tokenPath = options.tokenPath ?? getBridgeAuthTokenPath();
+  const writeFile = options.writeFile ?? fs.promises.writeFile.bind(fs.promises);
+  const mkdir = options.mkdir ?? fs.promises.mkdir.bind(fs.promises);
+  const chmod = options.chmod ?? fs.promises.chmod.bind(fs.promises);
+  await mkdir(path.dirname(tokenPath), { recursive: true });
+  await writeFile(tokenPath, `${normalized}\n`, { encoding: 'utf8', mode: 0o600 });
+  if (process.platform !== 'win32') {
+    await chmod(tokenPath, 0o600).catch(() => {});
+  }
+  return normalized;
+}
+
 /**
  * @param {{
  *   tokenPath?: string,

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

@@ -7,9 +7,21 @@ import path from 'node:path';
 export const APP_NAME = 'com.browserbridge.browser_bridge';
 export const BRIDGE_HOME_ENV = 'BROWSER_BRIDGE_HOME';
 export const BRIDGE_TCP_PORT_ENV = 'BBX_TCP_PORT';
+export const BRIDGE_TCP_HOST_ENV = 'BBX_TCP_HOST';
+export const BRIDGE_TCP_BIND_HOST_ENV = 'BBX_TCP_BIND_HOST';
 export const DEFAULT_WINDOWS_TCP_PORT = 9223;
+export const PROXY_CONFIG_FILENAME = 'proxy.json';
 
-/** @typedef {{ type: 'socket', socketPath: string, label: string } | { type: 'tcp', host: string, port: number, label: string }} BridgeTransport */
+/** @typedef {{ type: 'socket', socketPath: string, label: string } | { type: 'tcp', host: string, port: number, bindHost?: string, label: string }} BridgeTransport */
+
+/**
+ * @typedef {{
+ *   enabled: boolean,
+ *   port: number,
+ *   bindHost: string,
+ *   token?: string,
+ * }} BridgeProxyConfig
+ */
 
 /**
  * The official Chrome Web Store extension ID used when callers do not provide
@@ -63,6 +75,72 @@ export function getSocketPath(env = process.env) {
   return path.join(getBridgeDir(env), 'bridge.sock');
 }
 
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {string}
+ */
+export function getProxyConfigPath(env = process.env) {
+  return path.join(getBridgeDir(env), PROXY_CONFIG_FILENAME);
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function normalizeHost(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const host = value.trim();
+  if (!host || /[\s/]/u.test(host)) {
+    return null;
+  }
+  return host;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {number | null}
+ */
+function normalizePort(value) {
+  if (typeof value !== 'number' && typeof value !== 'string') {
+    return null;
+  }
+  const raw = String(value).trim();
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isInteger(port) || String(port) !== raw || port < 1 || port > 65535) {
+    return null;
+  }
+  return port;
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {BridgeProxyConfig | null}
+ */
+export function readProxyConfig(env = process.env) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(getProxyConfigPath(env), 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = /** @type {Record<string, unknown>} */ (parsed);
+    const port = normalizePort(record.port);
+    const bindHost = normalizeHost(record.bindHost) ?? '0.0.0.0';
+    if (record.enabled !== true || port === null) {
+      return null;
+    }
+    return {
+      enabled: true,
+      port,
+      bindHost,
+      ...(typeof record.token === 'string' ? { token: record.token } : {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * @param {string} socketPath
  * @returns {BridgeTransport}
@@ -80,12 +158,13 @@ export function createSocketBridgeTransport(socketPath) {
  * @param {string} [host='127.0.0.1']
  * @returns {BridgeTransport}
  */
-export function createTcpBridgeTransport(port, host = '127.0.0.1') {
+export function createTcpBridgeTransport(port, host = '127.0.0.1', bindHost = host) {
   return {
     type: 'tcp',
     host,
     port,
-    label: `${host}:${port}`,
+    ...(bindHost !== host ? { bindHost } : {}),
+    label: bindHost !== host ? `${host}:${port} (bind ${bindHost})` : `${host}:${port}`,
   };
 }
 
@@ -109,6 +188,38 @@ export function getBridgeTcpPort(env = process.env) {
   return port;
 }
 
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {string}
+ */
+export function getBridgeTcpHost(env = process.env) {
+  const raw = env[BRIDGE_TCP_HOST_ENV];
+  if (raw == null || raw === '') {
+    return '127.0.0.1';
+  }
+  const host = normalizeHost(raw);
+  if (!host) {
+    throw new Error(`${BRIDGE_TCP_HOST_ENV} must be a hostname or IP address.`);
+  }
+  return host;
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {string | null}
+ */
+export function getBridgeTcpBindHost(env = process.env) {
+  const raw = env[BRIDGE_TCP_BIND_HOST_ENV];
+  if (raw == null || raw === '') {
+    return null;
+  }
+  const host = normalizeHost(raw);
+  if (!host) {
+    throw new Error(`${BRIDGE_TCP_BIND_HOST_ENV} must be a hostname or IP address.`);
+  }
+  return host;
+}
+
 /**
  * Align Windows CLI/daemon entrypoints with the installed native-host launcher,
  * which uses TCP by default. Preserve explicit overrides and custom bridge-home
@@ -124,6 +235,9 @@ export function applyWindowsTcpTransportDefaults(env = process.env) {
   if (env[BRIDGE_TCP_PORT_ENV] != null && env[BRIDGE_TCP_PORT_ENV] !== '') {
     return false;
   }
+  if (readProxyConfig(env)) {
+    return false;
+  }
   if (env[BRIDGE_HOME_ENV]) {
     return false;
   }
@@ -139,7 +253,13 @@ export function applyWindowsTcpTransportDefaults(env = process.env) {
 export function getBridgeTransport(env = process.env) {
   const tcpPort = getBridgeTcpPort(env);
   if (tcpPort !== null) {
-    return createTcpBridgeTransport(tcpPort);
+    const host = getBridgeTcpHost(env);
+    return createTcpBridgeTransport(tcpPort, host, getBridgeTcpBindHost(env) ?? host);
+  }
+
+  const proxyConfig = readProxyConfig(env);
+  if (proxyConfig) {
+    return createTcpBridgeTransport(proxyConfig.port, '127.0.0.1', proxyConfig.bindHost);
   }
 
   return createSocketBridgeTransport(getSocketPath(env));
@@ -151,7 +271,7 @@ export function getBridgeTransport(env = process.env) {
  */
 export function getBridgeListenTarget(transport = getBridgeTransport()) {
   if (transport.type === 'tcp') {
-    return { host: transport.host, port: transport.port };
+    return { host: transport.bindHost ?? transport.host, port: transport.port };
   }
   return transport.socketPath;
 }