@browserbridge/bbx 1.8.0 → 1.10.0

package/packages/agent-client/src/command-registry.js

@@ -2,6 +2,7 @@
 
 import { BRIDGE_METHOD_REGISTRY, BRIDGE_METHODS } from '../../protocol/src/index.js';
 import {
+  isElementRef,
   parseCommaList,
   parseIntArg,
   parseNumberArg,
@@ -39,7 +40,7 @@ function createShortcutCommand(method, usage, build, options = {}) {
  */
 function createAtomicTarget(value) {
   if (!value) throw new Error('A ref or selector is required.');
-  return value.startsWith('el_') ? { elementRef: value } : { selector: value };
+  return isElementRef(value) ? { elementRef: value } : { selector: value };
 }
 
 /** @type {Record<string, ShortcutCommand>} */
@@ -204,7 +205,10 @@ export const SHORTCUT_COMMANDS = {
       maxDepth: r[1] ? parseIntArg(r[1], 'maxDepth') : undefined,
     })
   ),
-  perf: createShortcutCommand('performance.get_metrics', 'bbx perf', () => ({})),
+  perf: createShortcutCommand('performance.get_metrics', 'bbx perf', () => ({}), {
+    description:
+      'Read a raw Chrome/CDP counter point sample (names and units vary; no BBX navigation window or LCP/CLS/INP measurement)',
+  }),
   scroll: createShortcutCommand('viewport.scroll', 'bbx scroll <top> [left]', (r) => {
     if (!r[0] && !r[1]) throw new Error('Usage: scroll <top> [left]');
     return {
@@ -250,6 +254,7 @@ export const CLI_METHOD_BINDINGS = Object.freeze({
   'press-key': 'input.press_key',
   'cdp-press-key': 'cdp.dispatch_key_event',
   screenshot: 'screenshot.capture_element',
+  har: 'network.export_har',
   eval: 'page.evaluate',
 });
 
@@ -262,9 +267,11 @@ export const CLI_HELP_SECTIONS = Object.freeze([
       'bbx uninstall                                                      Remove native host manifests, Browser Bridge runtime files, and managed MCP/skill installs',
       'bbx install-skill [targets|all] [--global] [--project <path>]      Install/update the managed Browser Bridge CLI skill',
       'bbx install-mcp [client|all] [--local]                             Write MCP config for codex|claude|cursor|copilot|opencode|antigravity|windsurf|agents',
+      '  MCP starts with common tools; browser_toolset loads one specialized typed tool by name when needed.',
       'bbx status                                                         Check bridge connection',
       'bbx doctor                                                         Consolidated local runtime, setup, protocol, and readiness diagnostics',
       'bbx restart                                                        Restart the local daemon and running MCP servers',
+      'bbx config set auto-update <off|compatible>                         Configure protocol-compatible npm updates',
       'bbx proxy enable [--port 9223] [--bind-host 127.0.0.1] [--rotate-token]  Enable loopback TCP proxy mode for SSH tunneling',
       '  Non-loopback binds require --unsafe-plaintext because raw TCP is unencrypted.',
       'bbx proxy disable                                                  Disable proxy mode and restart the daemon',
@@ -280,15 +287,17 @@ export const CLI_HELP_SECTIONS = Object.freeze([
       'bbx tab-close <tabId>                                              Close a tab',
       'bbx tab-activate <tabId>                                           Bring a tab to the foreground',
       'bbx skill                                                          Runtime budget presets and method groups',
+      'bbx protocol describe [method|group]                                Describe method params or list registry groups locally',
       'bbx mcp serve                                                      Start Browser Bridge as an MCP stdio server',
     ],
   },
   {
     title: 'Generic RPC',
     lines: [
-      'bbx call [--tab <tabId>] <method> [paramsJson|-]                   Call any bridge method (- reads JSON from stdin)',
+      'bbx call [--tab <tabId>] [--preset quick|normal|deep] <method> [paramsJson|-]  Call any bridge method (- reads JSON from stdin)',
       'bbx <method> [--tab <tabId>] [paramsJson|-]                        Direct alias for exact bridge methods such as page.get_state',
-      "bbx batch '[{method,params,tabId?},...]'                           Parallel method calls",
+      "bbx batch [--preset quick|normal|deep] '[{method,params,tabId?},...]'  Up to 20 parallel read-only calls",
+      '--preset fills budget gaps (maxNodes, maxDepth, textBudget, limit) from the shared quick|normal|deep presets; explicit params always win.',
       'Every bridge command accepts --remote <name> (or BBX_REMOTE env) to target a remote destination from `bbx remote list`.',
       'Advanced bridge params stay available through `bbx call`, even when shortcuts expose only the common case.',
       'For open-ended investigation, start with `bbx batch` on `page.get_state`, `dom.query`, and `page.get_text` before any screenshot or CDP call.',
@@ -376,6 +385,7 @@ export const CLI_HELP_SECTIONS = Object.freeze([
     title: 'Capture',
     lines: [
       'bbx screenshot [--tab <tabId>] [--format png|jpeg|webp] [--quality 0-100] <ref|selector> [path]',
+      'bbx har [--tab <tabId>] [--limit 1-200] [--url-pattern <pattern>] [--delivery inline|artifact|auto] [outPath]',
     ],
   },
 ]);

package/packages/agent-client/src/config.js

@@ -0,0 +1,195 @@
+// @ts-check
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getBridgeDir, getBridgeTransport } from '../../native-host/src/config.js';
+import { atomicWriteFile } from './atomic-write.js';
+
+/** @typedef {import('./types.js').AutoUpdatePolicy} AutoUpdatePolicy */
+/** @typedef {import('./types.js').BridgeClientOptions} BridgeClientOptions */
+/** @typedef {import('./types.js').BrowserBridgeConfig} BrowserBridgeConfig */
+
+export const AUTO_UPDATE_ENV = 'BBX_AUTO_UPDATE';
+export const CONFIG_FILENAME = 'config.json';
+const AUTO_UPDATE_POLICIES = new Set(['off', 'compatible']);
+
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {string}
+ */
+export function getBridgeConfigPath(env = process.env) {
+  return path.join(getBridgeDir(env), CONFIG_FILENAME);
+}
+
+/**
+ * @param {unknown} value
+ * @returns {AutoUpdatePolicy}
+ */
+export function parseAutoUpdatePolicy(value) {
+  if (typeof value !== 'string' || !AUTO_UPDATE_POLICIES.has(value)) {
+    throw new Error('Auto-update policy must be "off" or "compatible".');
+  }
+  return /** @type {AutoUpdatePolicy} */ (value);
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {Promise<BrowserBridgeConfig>}
+ */
+export async function readBridgeConfig(env = process.env) {
+  const configPath = getBridgeConfigPath(env);
+  let raw;
+  try {
+    raw = await fs.promises.readFile(configPath, 'utf8');
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return { autoUpdate: 'off' };
+    }
+    throw error;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Cannot read ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Cannot read ${configPath}: expected a JSON object.`);
+  }
+
+  const config = /** @type {Record<string, unknown>} */ (parsed);
+  return {
+    ...config,
+    autoUpdate: config.autoUpdate === undefined ? 'off' : parseAutoUpdatePolicy(config.autoUpdate),
+  };
+}
+
+/**
+ * @param {AutoUpdatePolicy} policy
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {Promise<string>}
+ */
+export async function setAutoUpdatePolicy(policy, env = process.env) {
+  const normalized = parseAutoUpdatePolicy(policy);
+  const configPath = getBridgeConfigPath(env);
+  const config = await readBridgeConfig(env);
+  await atomicWriteFile(
+    configPath,
+    `${JSON.stringify({ ...config, autoUpdate: normalized }, null, 2)}\n`,
+    { encoding: 'utf8', mode: 0o600 }
+  );
+  return configPath;
+}
+
+/**
+ * Environment configuration overrides the persisted preference for unattended
+ * and containerized clients.
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @returns {Promise<AutoUpdatePolicy>}
+ */
+export async function getAutoUpdatePolicy(env = process.env) {
+  if (env[AUTO_UPDATE_ENV] !== undefined) {
+    return parseAutoUpdatePolicy(env[AUTO_UPDATE_ENV]);
+  }
+  return (await readBridgeConfig(env)).autoUpdate;
+}
+
+/**
+ * @param {BridgeClientOptions} [options={}]
+ * @param {NodeJS.ProcessEnv} [env=process.env]
+ * @param {string[]} [argv=process.argv]
+ * @returns {Promise<BridgeClientOptions>}
+ */
+export async function applyConfiguredAutoUpdate(
+  options = {},
+  env = process.env,
+  argv = process.argv
+) {
+  if (options.updateNpmOnCompatibleVersion !== undefined) {
+    return options;
+  }
+  if (env[AUTO_UPDATE_ENV] === undefined && !isBrowserBridgeProcess(argv)) {
+    return options;
+  }
+  if (env.npm_command === 'exec' || (await getAutoUpdatePolicy(env)) !== 'compatible') {
+    return options;
+  }
+  const transport = options.socketPath ? null : (options.transport ?? getBridgeTransport(env));
+  if (transport?.type === 'tcp' && !isLoopbackHost(transport.host)) {
+    return options;
+  }
+  return {
+    ...options,
+    checkProtocolOnConnect: true,
+    updateNpmOnCompatibleVersion: true,
+    exitProcessOnNpmUpdate: isMcpProcess(argv),
+  };
+}
+
+/**
+ * @param {string} host
+ * @returns {boolean}
+ */
+function isLoopbackHost(host) {
+  const normalized = host
+    .trim()
+    .toLowerCase()
+    .replace(/^\[|\]$/gu, '');
+  if (normalized === 'localhost' || normalized === '::1' || normalized === '0:0:0:0:0:0:0:1') {
+    return true;
+  }
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/u.exec(normalized);
+  return Boolean(
+    match && match.slice(1).every((part) => Number(part) <= 255) && match[1] === '127'
+  );
+}
+
+/**
+ * @param {string[]} [argv=process.argv]
+ * @returns {boolean}
+ */
+export function isMcpProcess(argv = process.argv) {
+  const entry = (argv[1] || '').replaceAll('\\', '/');
+  const entryName = entry.slice(entry.lastIndexOf('/') + 1).toLowerCase();
+  return (
+    (argv[2] === 'mcp' && argv[3] === 'serve') ||
+    (entry.includes('/mcp-server/') && entry.endsWith('/bin.js')) ||
+    entryName === 'bbx-mcp' ||
+    entryName === 'bbx-mcp.cmd'
+  );
+}
+
+/**
+ * Persisted CLI preferences apply to the shipped executables, not arbitrary
+ * programmatic BridgeClient consumers that happen to share the same user home.
+ *
+ * @param {string[]} [argv=process.argv]
+ * @returns {boolean}
+ */
+export function isBrowserBridgeProcess(argv = process.argv) {
+  if (isMcpProcess(argv)) return true;
+  const entry = (argv[1] || '').replaceAll('\\', '/');
+  const entryName = entry.slice(entry.lastIndexOf('/') + 1).toLowerCase();
+  return (
+    (entry.includes('/agent-client/') && entry.endsWith('/cli.js')) ||
+    entryName === 'bbx' ||
+    entryName === 'bbx.cmd'
+  );
+}
+
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+function isMissingFileError(error) {
+  return Boolean(
+    error &&
+    typeof error === 'object' &&
+    /** @type {{ code?: unknown }} */ (error).code === 'ENOENT'
+  );
+}

package/packages/agent-client/src/mcp-config.js

@@ -91,23 +91,23 @@ export function getMcpConfigShape(clientName) {
  *   env: Record<string, string>
  * } | {
  *   type: 'local',
- *   command: string[]
+ *   command: string[],
+ *   environment?: Record<string, string>
  * }}
  */
 function createBaseServerConfig(clientName) {
-  const serverConfig = {
-    command: MCP_COMMAND,
-    args: [...MCP_ARGS],
-    env: {},
-  };
-
   if (clientName === 'opencode') {
     return {
       type: 'local',
       command: [MCP_COMMAND, ...MCP_ARGS],
     };
   }
-  return serverConfig;
+
+  return {
+    command: MCP_COMMAND,
+    args: [...MCP_ARGS],
+    env: {},
+  };
 }
 
 /** @type {Record<McpClientName, { key: string, includeType: boolean, keepEmptyBlock?: boolean }>} */

package/packages/agent-client/src/npm-self-update.js

@@ -0,0 +1,305 @@
+// @ts-check
+
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PACKAGE_NAME = '@browserbridge/bbx';
+const PACKAGE_ROOT = path.dirname(fileURLToPath(new URL('../../../package.json', import.meta.url)));
+const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+const DEFAULT_LOCK_TIMEOUT_MS = 120_000;
+const UPDATE_LOCK_PORT_START = 49_152;
+const UPDATE_LOCK_PORT_COUNT = 16_384;
+const UPDATE_LOCK_PORT_ATTEMPTS = 32;
+
+/** @typedef {import('./types.js').NpmUpdateResult} NpmUpdateResult */
+
+export class NpmPackageUpdatedError extends Error {
+  /**
+   * @param {string} version
+   */
+  constructor(version) {
+    super(`Browser Bridge updated to ${version}; restarting to load the new version.`);
+    this.name = 'NpmPackageUpdatedError';
+    this.code = 'BBX_NPM_UPDATED';
+    this.version = version;
+  }
+}
+
+/**
+ * @param {string} value
+ * @returns {[number, number, number] | null}
+ */
+export function parseStableVersion(value) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u.exec(value);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+
+/**
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
+ */
+export function comparePackageVersions(left, right) {
+  const leftParts = parseStableVersion(left);
+  const rightParts = parseStableVersion(right);
+  if (!leftParts || !rightParts) {
+    throw new Error(`Cannot compare invalid stable versions "${left}" and "${right}".`);
+  }
+  for (let index = 0; index < leftParts.length; index += 1) {
+    const delta = leftParts[index] - rightParts[index];
+    if (delta !== 0) return delta > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+/**
+ * @param {string} version
+ * @returns {string | null}
+ */
+export function derivePackageProtocolVersion(version) {
+  const parsed = parseStableVersion(version);
+  return parsed ? `${parsed[0]}.${parsed[1]}` : null;
+}
+
+/**
+ * @param {unknown[]} versions
+ * @param {readonly string[]} supportedProtocols
+ * @param {string} currentVersion
+ * @returns {string | null}
+ */
+export function selectCompatibleNpmVersion(versions, supportedProtocols, currentVersion) {
+  if (!parseStableVersion(currentVersion)) return null;
+  const supported = new Set(supportedProtocols.filter((version) => /^\d+\.\d+$/u.test(version)));
+  let selected = null;
+  for (const value of versions) {
+    if (typeof value !== 'string' || !parseStableVersion(value)) continue;
+    const protocolVersion = derivePackageProtocolVersion(value);
+    if (!protocolVersion || !supported.has(protocolVersion)) continue;
+    if (comparePackageVersions(value, currentVersion) <= 0) continue;
+    if (selected === null || comparePackageVersions(value, selected) > 0) selected = value;
+  }
+  return selected;
+}
+
+/**
+ * @param {string} packageRoot
+ * @returns {Promise<string | null>}
+ */
+async function readPackageVersion(packageRoot) {
+  try {
+    const parsed = JSON.parse(
+      await fs.promises.readFile(path.join(packageRoot, 'package.json'), 'utf8')
+    );
+    return parsed && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ env?: NodeJS.ProcessEnv, timeoutMs?: number }} [options={}]
+ * @returns {Promise<string>}
+ */
+export async function runNpmCommand(args, options = {}) {
+  const env = options.env ?? process.env;
+  const npmExecPath = env.npm_execpath;
+  const useNode = Boolean(npmExecPath && /\.(?:c?js|mjs)$/u.test(npmExecPath));
+  const command = useNode
+    ? process.execPath
+    : npmExecPath || (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+  const commandArgs = useNode && npmExecPath ? [npmExecPath, ...args] : args;
+
+  return new Promise((resolve, reject) => {
+    execFile(
+      command,
+      commandArgs,
+      {
+        env,
+        encoding: 'utf8',
+        timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+        maxBuffer: 4 * 1024 * 1024,
+        windowsHide: true,
+      },
+      (error, stdout, stderr) => {
+        if (!error) {
+          resolve(stdout);
+          return;
+        }
+        const detail = stderr.trim();
+        reject(
+          new Error(
+            `npm ${args.join(' ')} failed${detail ? `: ${detail.slice(0, 1000)}` : `: ${error.message}`}`
+          )
+        );
+      }
+    );
+  });
+}
+
+/**
+ * Bind an exclusive loopback port derived from the global npm package path.
+ * The OS releases the lock if the updater crashes, avoiding persistent stale
+ * lock files while preserving cross-process serialization.
+ *
+ * @param {string} lockKey
+ * @param {number} [offset=0]
+ * @returns {number}
+ */
+export function getNpmUpdateLockPort(lockKey, offset = 0) {
+  const digest = createHash('sha256').update(lockKey).digest();
+  return (
+    UPDATE_LOCK_PORT_START +
+    ((digest.readUInt32BE(0) + Math.max(0, Math.trunc(offset))) % UPDATE_LOCK_PORT_COUNT)
+  );
+}
+
+/**
+ * @param {number} port
+ * @returns {Promise<string | null>}
+ */
+async function readNpmUpdateLockIdentity(port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: '127.0.0.1', port });
+    let settled = false;
+    let value = '';
+    /** @param {string | null} result */
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setEncoding('utf8');
+    socket.setTimeout(250, () => finish(null));
+    socket.on('data', (chunk) => {
+      value += chunk;
+      if (value.length > 256 || value.includes('\n')) finish(value.trim());
+    });
+    socket.on('end', () => finish(value.trim() || null));
+    socket.on('error', () => finish(null));
+  });
+}
+
+/**
+ * @param {string} lockKey
+ * @param {number} [timeoutMs=DEFAULT_LOCK_TIMEOUT_MS]
+ * @returns {Promise<() => Promise<void>>}
+ */
+export async function acquireNpmUpdateLock(lockKey, timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
+  const startedAt = Date.now();
+  const identity = `bbx-npm-update:${createHash('sha256').update(lockKey).digest('hex')}`;
+  while (true) {
+    let activeUpdaterFound = false;
+    for (let offset = 0; offset < UPDATE_LOCK_PORT_ATTEMPTS; offset += 1) {
+      const port = getNpmUpdateLockPort(lockKey, offset);
+      const server = net.createServer((socket) => socket.end(`${identity}\n`));
+      const acquired = await new Promise((resolve, reject) => {
+        server.once('error', (error) => {
+          if (/** @type {NodeJS.ErrnoException} */ (error).code === 'EADDRINUSE') {
+            resolve(false);
+            return;
+          }
+          reject(error);
+        });
+        server.listen({ host: '127.0.0.1', port, exclusive: true }, () => resolve(true));
+      });
+      if (acquired) {
+        return async () => {
+          await new Promise((resolve) => server.close(resolve));
+        };
+      }
+      if ((await readNpmUpdateLockIdentity(port)) === identity) {
+        activeUpdaterFound = true;
+        break;
+      }
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(
+        activeUpdaterFound
+          ? 'Timed out waiting for another Browser Bridge npm update to finish.'
+          : 'Could not reserve a local Browser Bridge npm update lock.'
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+}
+
+/**
+ * @param {{
+ *   extensionVersion: string,
+ *   supportedVersions: readonly string[],
+ *   env?: NodeJS.ProcessEnv,
+ *   packageRoot?: string,
+ *   lockPath?: string,
+ *   runNpmFn?: typeof runNpmCommand,
+ * }} options
+ * @returns {Promise<NpmUpdateResult>}
+ */
+export async function updateCompatibleNpmPackage(options) {
+  const env = options.env ?? process.env;
+  const packageRoot = options.packageRoot ?? PACKAGE_ROOT;
+  const runNpmFn = options.runNpmFn ?? runNpmCommand;
+  const extensionProtocol = derivePackageProtocolVersion(options.extensionVersion);
+  if (!extensionProtocol || !options.supportedVersions.includes(extensionProtocol)) {
+    return { updated: false, reason: 'invalid_extension_version' };
+  }
+
+  const globalRoot = (await runNpmFn(['root', '--global'], { env })).trim();
+  const expectedRoot = path.join(globalRoot, '@browserbridge', 'bbx');
+  const [realPackageRoot, realExpectedRoot, expectedStat] = await Promise.all([
+    fs.promises.realpath(packageRoot).catch(() => ''),
+    fs.promises.realpath(expectedRoot).catch(() => ''),
+    fs.promises.lstat(expectedRoot).catch(() => null),
+  ]);
+  if (!realPackageRoot || realPackageRoot !== realExpectedRoot || expectedStat?.isSymbolicLink()) {
+    return { updated: false, reason: 'not_global_install' };
+  }
+
+  const lockKey = options.lockPath ?? realExpectedRoot;
+  const releaseLock = await acquireNpmUpdateLock(lockKey);
+  try {
+    const currentVersion = await readPackageVersion(packageRoot);
+    if (!currentVersion || !parseStableVersion(currentVersion)) {
+      return { updated: false, reason: 'invalid_installed_version' };
+    }
+    if (comparePackageVersions(options.extensionVersion, currentVersion) <= 0) {
+      return { updated: false, reason: 'extension_not_newer', previousVersion: currentVersion };
+    }
+
+    const versionsRaw = await runNpmFn(['view', PACKAGE_NAME, 'versions', '--json'], { env });
+    const parsedVersions = JSON.parse(versionsRaw);
+    const versions = Array.isArray(parsedVersions) ? parsedVersions : [parsedVersions];
+    const targetVersion = selectCompatibleNpmVersion(
+      versions,
+      options.supportedVersions,
+      currentVersion
+    );
+    if (!targetVersion) {
+      return { updated: false, reason: 'no_compatible_update', previousVersion: currentVersion };
+    }
+
+    await runNpmFn(
+      ['install', '--global', '--no-audit', '--no-fund', '--', `${PACKAGE_NAME}@${targetVersion}`],
+      { env }
+    );
+    const installedVersion = await readPackageVersion(packageRoot);
+    if (installedVersion !== targetVersion) {
+      throw new Error(
+        `npm reported success, but Browser Bridge ${targetVersion} was not installed at ${packageRoot}.`
+      );
+    }
+    return {
+      updated: true,
+      reason: 'updated',
+      previousVersion: currentVersion,
+      version: targetVersion,
+    };
+  } finally {
+    await releaseLock();
+  }
+}

package/packages/agent-client/src/remotes.js

@@ -7,6 +7,7 @@ import { createTcpBridgeTransport, getBridgeDir } from '../../native-host/src/co
 import { normalizeBridgeAuthToken } from '../../native-host/src/auth-token.js';
 import { atomicWriteFile } from './atomic-write.js';
 import { BridgeClient } from './client.js';
+import { applyConfiguredAutoUpdate } from './config.js';
 
 const REMOTES_FILENAME = 'remotes.json';
 const LOCAL_DESTINATION_ID = 'local';
@@ -287,12 +288,12 @@ function validateAuthToken(token) {
 
 /**
  * @param {string | null | undefined} destinationId
- * @param {{ defaultTimeoutMs?: number, checkProtocolOnConnect?: boolean }} [options={}]
+ * @param {import('./types.js').BridgeClientOptions} [options={}]
  * @returns {Promise<BridgeClient>}
  */
 export async function createBridgeClientForDestination(destinationId, options = {}) {
   if (!destinationId || destinationId === LOCAL_DESTINATION_ID) {
-    return new BridgeClient(options);
+    return new BridgeClient(await applyConfiguredAutoUpdate(options));
   }
   const config = await readRemoteConfig();
   const remote = config.remotes.find((entry) => entry.id === destinationId);
@@ -304,5 +305,6 @@ export async function createBridgeClientForDestination(destinationId, options =
     transport: createTcpBridgeTransport(remote.port, remote.host),
     authToken: remote.token,
     restartDaemonOnVersionMismatch: false,
+    updateNpmOnCompatibleVersion: false,
   });
 }