@browserbridge/bbx 1.1.0 → 1.3.0

package/README.md

@@ -99,17 +99,18 @@ Managed installs support OpenAI Codex, Claude Code, Cursor, GitHub Copilot, Open
 
 ## Why Browser Bridge
 
-Most adjacent tools optimize for different goals. [Playwright](https://playwright.dev/) and headless automation stacks are excellent for deterministic tests and CI - but they start from a clean browser context by design. [Claude in Chrome](https://support.claude.com/en/articles/12012173-get-started-with-claude-in-chrome) is great for integrated Claude workflows, but is vendor-specific. Generic MCP browser servers offer broad control without the developer-focused depth.
+Most adjacent tools optimize for different goals. [Playwright](https://playwright.dev/) and headless automation stacks are excellent for deterministic tests and CI - but they start from a clean browser context by design. [Claude in Chrome](https://support.claude.com/en/articles/12012173-get-started-with-claude-in-chrome) is great for integrated Claude workflows, and the [Codex extension](https://chromewebstore.google.com/detail/codex/hehggadaopoacecdllhhajmbjkdcmajg) is a great option if you use Codex, but both are vendor-specific. Generic MCP browser servers offer broad control without the developer-focused depth.
 
 Browser Bridge is optimized for the opposite starting point: **inspect the state that already exists** in a real tab - logged-in sessions, feature flags, seeded storage, SPA state - use structured reads to understand it, test a patch in place, then fix the source. It's open-source, agent-agnostic, and scoped to explicit tab sessions rather than ambient browser control.
 
 ## Setup
 
-1. Install [Browser Bridge from the Chrome Web Store](https://chromewebstore.google.com/detail/browser-bridge/jjjkmmcdkpcgamlopogicbnnhdgebhie)
+1. Install [Browser Bridge from the Chrome Web Store](https://chromewebstore.google.com/detail/browser-bridge/jjjkmmcdkpcgamlopogicbnnhdgebhie) in Chrome or another Chromium-based browser
 2. `npm install -g @browserbridge/bbx` - installs the CLI and native host
-3. In the extension side panel, install MCP or CLI (skill) for your agent of choice
-4. Enable Browser Bridge for the Chrome window you want to inspect/control with the AI agent
-5. Ask your agent to use Browser Bridge via MCP (`BB MCP` or `Browser Bridge MCP`), or invoke the `browser-bridge` / `$bbx` skill in CLI mode
+3. Run `bbx install`, or target a specific browser with `bbx install --browser edge`, `bbx install --browser brave`, `bbx install --browser chromium`, or `bbx install --browser arc`
+4. In the extension side panel, install MCP or CLI (skill) for your agent of choice
+5. Enable Browser Bridge for the browser window you want to inspect/control with the AI agent
+6. Ask your agent to use Browser Bridge via MCP (`BB MCP` or `Browser Bridge MCP`), or invoke the `browser-bridge` / `$bbx` skill in CLI mode
 
 ## How it works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "private": false,
   "keywords": [
     "agent-tools",

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

@@ -50,8 +50,8 @@ import { getDoctorReport, requestBridge, resolveRef } from './runtime.js';
 import { collectSetupStatus } from './setup-status.js';
 import { annotateBridgeSummary, summarizeBridgeResponse } from './subagent.js';
 
-/** @typedef {import('../../protocol/src/types.js').BridgeMethod} BridgeMethod */
-/** @typedef {{ image: string, rect: Record<string, unknown> }} ScreenshotResult */
+/** @typedef {import('./types.js').BridgeMethod} BridgeMethod */
+/** @typedef {import('./types.js').ScreenshotResult} ScreenshotResult */
 
 const REQUEST_SOURCE = 'cli';
 const TEST_TIMEOUT_ENV = 'BBX_CLIENT_REQUEST_TIMEOUT_MS';
@@ -139,8 +139,8 @@ if (command === 'install-skill') {
       projectPath: isGlobal ? os.homedir() : process.cwd(),
       ...getSetupStatusTestOverrides(),
     });
-    /** @type {import('./install.js').SupportedTarget[]} */
-    const detected = /** @type {import('./install.js').SupportedTarget[]} */ (
+    /** @type {import('./types.js').SupportedTarget[]} */
+    const detected = /** @type {import('./types.js').SupportedTarget[]} */ (
       setupStatus.skillTargets.filter((entry) => entry.detected).map((entry) => entry.key)
     );
     const installedManagedTargets = new Set(
@@ -149,7 +149,7 @@ if (command === 'install-skill') {
         .map((entry) => entry.key)
     );
     const installedManagedTargetList =
-      /** @type {import('./install.js').SupportedTarget[]} */ ([...installedManagedTargets]);
+      /** @type {import('./types.js').SupportedTarget[]} */ ([...installedManagedTargets]);
 
     // Aliases like 'openai' and 'google' map to canonical targets and stay omitted.
     const items = SUPPORTED_TARGETS.map((t) => ({
@@ -167,19 +167,19 @@ if (command === 'install-skill') {
       items
     );
 
-    /** @type {import('./install.js').SupportedTarget[]} */
+    /** @type {import('./types.js').SupportedTarget[]} */
     let targets;
     if (selected === null) {
       // Non-TTY: prefer managed installs, then detected targets (always includes 'agents').
       targets = installedManagedTargets.size > 0 ? installedManagedTargetList : detected;
     } else {
-      targets = /** @type {import('./install.js').SupportedTarget[]} */ (selected);
+      targets = /** @type {import('./types.js').SupportedTarget[]} */ (selected);
     }
 
     const projectPath = isGlobal ? os.homedir() : process.cwd();
     if (selected !== null) {
       const deselectedTargets =
-        /** @type {import('./install.js').SupportedTarget[]} */ (
+        /** @type {import('./types.js').SupportedTarget[]} */ (
           installedManagedTargetList.filter((target) => !targets.includes(target))
         );
       const removableTargets = await findInstalledManagedTargets({
@@ -241,7 +241,7 @@ if (command === 'install-mcp') {
 
   const clientArg = argsLeft[0];
 
-  /** @type {import('./mcp-config.js').McpClientName[]} */
+  /** @type {import('./types.js').McpClientName[]} */
   let clients;
 
   if (!clientArg) {
@@ -252,14 +252,14 @@ if (command === 'install-mcp') {
       projectPath: process.cwd(),
       ...getSetupStatusTestOverrides(),
     });
-    const detected = /** @type {import('./mcp-config.js').McpClientName[]} */ (
+    const detected = /** @type {import('./types.js').McpClientName[]} */ (
       setupStatus.mcpClients.filter((entry) => entry.detected).map((entry) => entry.key)
     );
     const configuredClients = new Set(
       setupStatus.mcpClients.filter((entry) => entry.configured).map((entry) => entry.key)
     );
     const configuredClientList =
-      /** @type {import('./mcp-config.js').McpClientName[]} */ ([...configuredClients]);
+      /** @type {import('./types.js').McpClientName[]} */ ([...configuredClients]);
     const items = MCP_CLIENT_NAMES.map((c) => ({
       value: c,
       label: `${c.padEnd(10)}  ${MCP_CLIENT_LABELS[c]}`,
@@ -284,12 +284,12 @@ if (command === 'install-mcp') {
             ? detected
             : [...MCP_CLIENT_NAMES];
     } else {
-      clients = /** @type {import('./mcp-config.js').McpClientName[]} */ (selected);
+      clients = /** @type {import('./types.js').McpClientName[]} */ (selected);
     }
 
     if (selected !== null) {
       const deselectedClients =
-        /** @type {import('./mcp-config.js').McpClientName[]} */ (
+        /** @type {import('./types.js').McpClientName[]} */ (
           configuredClientList.filter((clientName) => !clients.includes(clientName))
         );
       const removableClients = await findConfiguredMcpClients({
@@ -470,15 +470,20 @@ async function main() {
     }
 
     if (command === 'batch') {
-      await ensureClientConnection();
       const input = rest[0];
       if (!input) {
         throw new Error('Usage: batch \'[{"method":"...","params":{...}}, ...]\'');
       }
-      const calls = JSON.parse(input);
+      let calls;
+      try {
+        calls = JSON.parse(input);
+      } catch {
+        throw new Error('Invalid JSON syntax. Expected a JSON array of bridge calls.');
+      }
       if (!Array.isArray(calls)) {
         throw new Error('Batch input must be a JSON array.');
       }
+      await ensureClientConnection();
       const results = await Promise.all(
         calls.map(async (call) => {
           if (!call || typeof call !== 'object' || typeof call.method !== 'string') {
@@ -613,16 +618,18 @@ async function main() {
     }
 
     if (command === 'screenshot') {
-      const [refOrSelector, outputPath] = rest;
-      if (!refOrSelector) throw new Error('Usage: screenshot <ref|selector> [path]');
-      const elementRef = await resolveRef(client, refOrSelector, null, REQUEST_SOURCE);
+      const parsed = extractTabFlag(rest);
+      const [refOrSelector, outputPath] = parsed.rest;
+      if (!refOrSelector)
+        throw new Error('Usage: screenshot [--tab <tabId>] <ref|selector> [path]');
+      const elementRef = await resolveRef(client, refOrSelector, parsed.tabId, REQUEST_SOURCE);
       const response = await requestBridge(
         client,
         'screenshot.capture_element',
         {
           elementRef,
         },
-        { source: REQUEST_SOURCE }
+        { tabId: parsed.tabId, source: REQUEST_SOURCE }
       );
       if (!response.ok) {
         await printSummary(response);
@@ -845,10 +852,13 @@ async function uninstallBrowserBridge() {
  */
 async function parseCallCommand(args) {
   const parsed = extractTabFlag(args);
-  const [first, second] = parsed.rest;
+  const [first, second, ...extra] = parsed.rest;
   if (!first) {
     throw new Error('Usage: call [--tab <tabId>] <method> [paramsJson]');
   }
+  if (extra.length > 0) {
+    throw new Error('Usage: call [--tab <tabId>] <method> [paramsJson]');
+  }
 
   if (first.includes('.')) {
     const method = /** @type {BridgeMethod} */ (first);

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

@@ -15,48 +15,33 @@ import {
   getBridgeTransport,
   getSocketPath,
 } from '../../native-host/src/config.js';
+import { restartBridgeDaemon } from '../../native-host/src/daemon-process.js';
 
-/** @typedef {import('../../native-host/src/config.js').BridgeTransport} BridgeTransport */
+/** @typedef {import('./types.js').BridgeMeta} BridgeMeta */
+/** @typedef {import('./types.js').BridgeMethod} BridgeMethod */
+/** @typedef {import('./types.js').BridgeResponse} BridgeResponse */
+/** @typedef {import('./types.js').BridgeClientOptions} BridgeClientOptions */
+/** @typedef {import('./types.js').ClientMessage} ClientMessage */
+/** @typedef {import('./types.js').PendingRequest} PendingRequest */
+/** @typedef {import('./types.js').ProtocolHealthResult} ProtocolHealthResult */
 
-/** @typedef {import('../../protocol/src/types.js').BridgeResponse} BridgeResponse */
-/** @typedef {import('../../protocol/src/types.js').BridgeMeta} BridgeMeta */
-/** @typedef {import('../../protocol/src/types.js').BridgeMethod} BridgeMethod */
 /**
- * @typedef {{
- *   supported_versions?: string[],
- *   deprecated_since?: string,
- *   migration_hint?: string
- * }} ProtocolHealthResult
- */
-
-/**
- * @typedef {{
- *   type: 'registered',
- *   role: 'agent' | 'extension',
- *   clientId?: string
- * } | {
- *   type: 'agent.response',
- *   response: BridgeResponse
- * }} ClientMessage
- */
-
-/**
- * @typedef {{
- *   resolve: (value: any) => void,
- *   reject: (error: Error) => void,
- *   timeoutId: NodeJS.Timeout
- * }} PendingRequest
- */
-
-/**
- * @typedef {{
- *   transport?: BridgeTransport,
- *   socketPath?: string,
- *   clientId?: string,
- *   defaultTimeoutMs?: number,
- *   autoReconnect?: boolean,
- * }} BridgeClientOptions
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
  */
+function compareProtocolVersions(left, right) {
+  const leftParts = left.split('.').map((part) => Number(part) || 0);
+  const rightParts = right.split('.').map((part) => Number(part) || 0);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
+    if (delta !== 0) {
+      return delta > 0 ? 1 : -1;
+    }
+  }
+  return 0;
+}
 
 /**
  * @param {string} method
@@ -81,6 +66,8 @@ export class BridgeClient extends EventEmitter {
     clientId = `agent_${randomUUID()}`,
     defaultTimeoutMs = DEFAULT_CLIENT_REQUEST_TIMEOUT_MS,
     autoReconnect = false,
+    restartDaemonOnVersionMismatch = true,
+    restartDaemonFn = restartBridgeDaemon,
   } = {}) {
     super();
     this.transport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
@@ -89,6 +76,8 @@ export class BridgeClient extends EventEmitter {
     this.clientId = clientId;
     this.defaultTimeoutMs = defaultTimeoutMs;
     this.autoReconnect = autoReconnect;
+    this.restartDaemonOnVersionMismatch = restartDaemonOnVersionMismatch;
+    this.restartDaemonFn = restartDaemonFn;
     this.socket = null;
     this.connected = false;
     this.protocolCompatibility = null;
@@ -96,6 +85,7 @@ export class BridgeClient extends EventEmitter {
     /** @type {Map<string, PendingRequest>} */
     this.waiting = new Map();
     this._reconnecting = false;
+    this._attemptedVersionMismatchRestart = false;
   }
 
   /**
@@ -173,19 +163,38 @@ export class BridgeClient extends EventEmitter {
       });
     });
 
+    this.protocolCompatibility = null;
+    this.protocolWarning = null;
+
+    /** @type {ProtocolHealthResult | null} */
+    let healthResult = null;
     try {
       const healthResponse = await this.request({
         method: 'health.ping',
       });
       if (healthResponse.ok) {
-        this.protocolCompatibility = BridgeClient.checkProtocolVersion(
-          /** @type {ProtocolHealthResult} */ (healthResponse.result)
-        );
-        this.protocolWarning = this.protocolCompatibility.warning ?? null;
+        healthResult = /** @type {ProtocolHealthResult} */ (healthResponse.result);
       }
     } catch {
       this.protocolCompatibility = null;
       this.protocolWarning = null;
+      return;
+    }
+
+    if (!healthResult) {
+      return;
+    }
+
+    this.protocolCompatibility = BridgeClient.checkProtocolVersion(healthResult);
+    this.protocolWarning = this.protocolCompatibility.warning ?? null;
+    if (this.protocolCompatibility.compatible) {
+      this._attemptedVersionMismatchRestart = false;
+    }
+    if (this.shouldRestartDaemonForProtocolMismatch(healthResult)) {
+      this._attemptedVersionMismatchRestart = true;
+      await this.disconnectForDaemonRestart();
+      await this.restartDaemonFn({ transport: this.transport });
+      await this.connect();
     }
   }
 
@@ -305,6 +314,60 @@ export class BridgeClient extends EventEmitter {
     this._reconnecting = false;
   }
 
+  /**
+   * @param {ProtocolHealthResult} healthResult
+   * @returns {boolean}
+   */
+  shouldRestartDaemonForProtocolMismatch(healthResult) {
+    if (
+      !this.restartDaemonOnVersionMismatch ||
+      this._attemptedVersionMismatchRestart ||
+      !this.protocolCompatibility ||
+      this.protocolCompatibility.compatible
+    ) {
+      return false;
+    }
+
+    const remoteVersions = Array.isArray(healthResult?.daemon_supported_versions)
+      ? healthResult.daemon_supported_versions
+      : healthResult?.extensionConnected === true
+        ? []
+        : Array.isArray(healthResult?.supported_versions)
+          ? healthResult.supported_versions
+          : [];
+    const latestRemote = remoteVersions[0];
+    return (
+      typeof latestRemote === 'string' &&
+      compareProtocolVersions(latestRemote, PROTOCOL_VERSION) < 0
+    );
+  }
+
+  /**
+   * Drop the current socket before forcing a daemon restart so the next
+   * connect() call observes a fresh local process rather than the existing one.
+   *
+   * @returns {Promise<void>}
+   */
+  async disconnectForDaemonRestart() {
+    const socket = this.socket;
+    if (!socket) {
+      return;
+    }
+
+    const previousAutoReconnect = this.autoReconnect;
+    this.autoReconnect = false;
+    this.connected = false;
+    this.socket = null;
+
+    if (!socket.destroyed) {
+      const closed = once(socket, 'close').catch(() => {});
+      socket.destroy();
+      await closed;
+    }
+
+    this.autoReconnect = previousAutoReconnect;
+  }
+
   /**
    * Check whether the remote side supports our protocol version.
    * Call after a successful health.ping to get early warnings about version drift.

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

@@ -3,18 +3,8 @@
 import { BRIDGE_METHOD_REGISTRY, BRIDGE_METHODS } from '../../protocol/src/index.js';
 import { parseCommaList, parseIntArg, parsePropertyAssignments } from './cli-helpers.js';
 
-/** @typedef {import('../../protocol/src/types.js').BridgeMethod} BridgeMethod */
-
-/**
- * @typedef {{
- *   method: BridgeMethod,
- *   resolve?: boolean,
- *   printMethod?: string,
- *   usage: string,
- *   description: string,
- *   build: (r: string[], ref?: string) => Record<string, unknown>
- * }} ShortcutCommand
- */
+/** @typedef {import('./types.js').BridgeMethod} BridgeMethod */
+/** @typedef {import('./types.js').ShortcutCommand} ShortcutCommand */
 
 /**
  * @param {BridgeMethod} method
@@ -247,7 +237,7 @@ export const CLI_HELP_SECTIONS = Object.freeze([
   {
     title: 'Setup',
     lines: [
-      'bbx install [--browser chrome|edge|brave|chromium] [extension-id]  Install native messaging manifest',
+      'bbx install [--browser chrome|edge|brave|chromium|arc] [extension-id]  Install native messaging manifest',
       'bbx uninstall                                                      Remove native host manifests, Browser Bridge runtime files, and managed MCP/skill installs',
       'bbx install [--all] [--browser <name>] [extension-id]              Install native host manifest (--all for all supported browsers)',
       'bbx install-skill [targets|all] [--global] [--project <path>]      Install/update the managed Browser Bridge CLI skill',
@@ -347,7 +337,7 @@ export const CLI_HELP_SECTIONS = Object.freeze([
   {
     title: 'Capture',
     lines: [
-      'bbx screenshot <ref|selector> [path]                               Capture partial element screenshot',
+      'bbx screenshot [--tab <tabId>] <ref|selector> [path]               Capture partial element screenshot',
     ],
   },
 ]);

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

@@ -4,9 +4,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-/** @typedef {import('./mcp-config.js').McpClientName} McpClientName */
-/** @typedef {import('./install.js').SupportedTarget} SupportedTarget */
-/** @typedef {() => boolean | Promise<boolean>} Detector */
+/** @typedef {import('./types.js').McpClientName} McpClientName */
+/** @typedef {import('./types.js').SupportedTarget} SupportedTarget */
+/** @typedef {import('./types.js').Detector} Detector */
 
 const home = os.homedir();
 const platform = process.platform;

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

@@ -41,9 +41,7 @@ const copilotBrowserBridgeNote = [
   '',
 ].join('\n');
 
-/**
- * @typedef {'codex' | 'claude' | 'cursor' | 'copilot' | 'opencode' | 'antigravity' | 'windsurf' | 'agents'} SupportedTarget
- */
+/** @typedef {import('./types.js').SupportedTarget} SupportedTarget */
 
 /** @type {SupportedTarget[]} */
 export const SUPPORTED_TARGETS = [...supportedTargets];
@@ -68,9 +66,7 @@ export function isSupportedTarget(value) {
   return supportedTargets.includes(/** @type {SupportedTarget} */ (value));
 }
 
-/**
- * @typedef {{targets: SupportedTarget[], projectPath: string, global: boolean}} InstallAgentOptions
- */
+/** @typedef {import('./types.js').InstallAgentOptions} InstallAgentOptions */
 
 /**
  * @param {string[]} args
@@ -202,7 +198,7 @@ async function rollbackInstalledSkillDirs(attempted) {
 /**
  * Write MCP config for the given clients.
  *
- * @param {import('./mcp-config.js').McpClientName[]} clients
+ * @param {import('./types.js').McpClientName[]} clients
  * @param {{
  *   global: boolean,
  *   projectPath: string,

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

@@ -5,9 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-/**
- * @typedef {'codex' | 'claude' | 'cursor' | 'copilot' | 'opencode' | 'antigravity' | 'windsurf' | 'agents'} McpClientName
- */
+/** @typedef {import('./types.js').McpClientName} McpClientName */
 
 /** @type {McpClientName[]} */
 export const MCP_CLIENT_NAMES = [

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

@@ -12,39 +12,14 @@ import { resolveDefaultExtensionId } from '../../native-host/src/install-manifes
 import { methodNeedsTab } from './cli-helpers.js';
 import { BridgeClient } from './client.js';
 
-/** @typedef {import('../../protocol/src/types.js').BridgeMethod} BridgeMethod */
-/** @typedef {import('../../protocol/src/types.js').BridgeMeta} BridgeMeta */
-/** @typedef {import('../../protocol/src/types.js').BridgeRequestSource} BridgeRequestSource */
-/** @typedef {import('../../protocol/src/types.js').BridgeResponse} BridgeResponse */
+/** @typedef {import('./types.js').BridgeMethod} BridgeMethod */
+/** @typedef {import('./types.js').BridgeMeta} BridgeMeta */
+/** @typedef {import('./types.js').BridgeRequestSource} BridgeRequestSource */
+/** @typedef {import('./types.js').BridgeResponse} BridgeResponse */
 /** @typedef {import('../../native-host/src/config.js').SupportedBrowser} SupportedBrowser */
-
-/**
- * @typedef {{
- *   browser: string,
- *   manifestPath: string,
- *   installed: boolean
- * }} BrowserManifestStatus
- */
-
-/**
- * @typedef {{
- *   manifestInstalled: boolean,
- *   manifestPath: string,
- *   allowedOrigins: string[],
- *   defaultExtensionId: string | null,
- *   defaultExtensionIdSource: string,
- *   daemonReachable: boolean,
- *   extensionConnected: boolean,
- *   accessEnabled: boolean,
- *   enabledWindowId: number | null,
- *   routeTabId: number | null,
- *   routeReady: boolean,
- *   routeReason: string,
- *   issues: string[],
- *   nextSteps: string[],
- *   browserManifests: BrowserManifestStatus[]
- * }} DoctorReport
- */
+/** @typedef {import('./types.js').BrowserManifestStatus} BrowserManifestStatus */
+/** @typedef {import('./types.js').DoctorReport} DoctorReport */
+/** @typedef {import('./types.js').DoctorReportOptions} DoctorReportOptions */
 
 /**
  * @param {BridgeClient} client
@@ -178,15 +153,6 @@ export async function checkBrowserManifests() {
   );
 }
 
-/**
- * @typedef {{
- *   loadManifest?: () => Promise<{allowed_origins?: string[]} | null>,
- *   manifestPath?: string,
- *   defaultExtensionIdInfo?: { extensionId: string | null, source: string },
- *   bridgeClientRunner?: <T>(callback: (client: BridgeClient) => Promise<T>) => Promise<T>
- * }} DoctorReportOptions
- */
-
 /**
  * @param {DoctorReportOptions} [options={}]
  * @returns {Promise<DoctorReport>}

package/packages/agent-client/src/setup-status.js

@@ -21,8 +21,8 @@ import {
   SUPPORTED_TARGETS,
 } from './install.js';
 
-/** @typedef {import('./mcp-config.js').McpClientName} McpClientName */
-/** @typedef {import('./install.js').SupportedTarget} SupportedTarget */
+/** @typedef {import('./types.js').McpClientName} McpClientName */
+/** @typedef {import('./types.js').SupportedTarget} SupportedTarget */
 /** @typedef {import('../../protocol/src/types.js').SetupStatus} SetupStatus */
 /** @typedef {import('../../protocol/src/types.js').McpClientStatus} McpClientStatus */
 /** @typedef {import('../../protocol/src/types.js').SkillTargetStatus} SkillTargetStatus */
@@ -52,17 +52,7 @@ const SKILL_TARGET_LABELS = {
   agents: 'Generic agents',
 };
 
-/**
- * @typedef {{
- *   global?: boolean,
- *   cwd?: string,
- *   projectPath?: string,
- *   mcpDetectors?: Record<string, () => boolean | Promise<boolean>>,
- *   skillDetectors?: Record<string, () => boolean | Promise<boolean>>,
- *   access?: (targetPath: string) => Promise<void>,
- *   readFile?: (targetPath: string, encoding: BufferEncoding) => Promise<string>
- * }} SetupStatusOptions
- */
+/** @typedef {import('./types.js').SetupStatusOptions} SetupStatusOptions */
 
 /**
  * Return Browser Bridge MCP and skill installation status for supported clients.