viyv-browser-mcp 0.10.1 → 0.10.3

package/dist/index.js

@@ -2988,7 +2988,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3015,7 +3015,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3590,7 +3590,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3817,7 +3817,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve3,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -11452,10 +11452,10 @@ var require_raw_body = __commonJS({
       if (done) {
         return readStream(stream, encoding, length, limit, wrap(done));
       }
-      return new Promise(function executor(resolve3, reject) {
+      return new Promise(function executor(resolve4, reject) {
         readStream(stream, encoding, length, limit, function onRead(err, buf) {
           if (err) return reject(err);
-          resolve3(buf);
+          resolve4(buf);
         });
       });
     }
@@ -11695,7 +11695,7 @@ var require_content_type = __commonJS({
 
 // src/native-host/bridge.ts
 import { randomUUID } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { createServer as createServer2 } from "net";
 import { join as join2 } from "path";
 
@@ -11762,7 +11762,15 @@ var RECONNECT = {
   /** Max delay (ms) */
   MAX_DELAY: 3e4,
   /** Backoff multiplier */
-  MULTIPLIER: 2
+  MULTIPLIER: 2,
+  /** Symmetric jitter ratio applied to each reconnect delay. ±30% spreads synchronized retries. */
+  JITTER_RATIO: 0.3
+};
+var BRIDGE_READINESS = {
+  /** Max time a pre-handshake tool_call waits for `bridge_status { connected:true }` */
+  TIMEOUT_MS: 8e3,
+  /** Max number of tool_calls queued while the bridge client is below `ready` state */
+  PENDING_QUEUE_MAX: 10
 };
 var BRIDGE = {
   /** TCP port for Native Host bridge (TCP server) */
@@ -11803,59 +11811,185 @@ function matchSubscription(sub, event) {
   return matchEventType(sub.eventTypes, event.eventType) && matchUrlPattern(sub.urlPattern, event.url);
 }
 
+// ../shared/dist/util/jitter.js
+function applyJitter(baseMs, ratio, random = Math.random) {
+  if (!Number.isFinite(baseMs) || baseMs < 0)
+    return 0;
+  if (ratio <= 0)
+    return baseMs;
+  const clampedRatio = Math.min(ratio, 1);
+  const offset = (random() * 2 - 1) * clampedRatio * baseMs;
+  const result = baseMs + offset;
+  return Math.max(0, Math.round(result));
+}
+
+// ../shared/dist/util/exit-reason.js
+function shouldBroadcastClosing(reason) {
+  switch (reason) {
+    case "chrome-sigterm":
+    case "sigint":
+      return false;
+    case "all-empty":
+    case "relay-exhausted":
+    case "shutdown-request":
+      return true;
+    default: {
+      const _exhaustive = reason;
+      return _exhaustive;
+    }
+  }
+}
+
+// ../shared/dist/util/semver.js
+function compareSemver(a, b) {
+  const pa = a.split(".").map((s) => Number.parseInt(s, 10));
+  const pb = b.split(".").map((s) => Number.parseInt(s, 10));
+  for (let i = 0; i < 3; i++) {
+    const ai = Number.isFinite(pa[i]) ? pa[i] : 0;
+    const bi = Number.isFinite(pb[i]) ? pb[i] : 0;
+    const diff = ai - bi;
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+
 // src/native-host-updater.ts
-import {
-  chmodSync,
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  unlinkSync
-} from "fs";
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/native-host/deployment-state.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { resolve } from "path";
-import { fileURLToPath } from "url";
+function getNativeHostDir() {
+  return resolve(homedir(), ".viyv-browser", "native-host");
+}
+function getDeploymentBinaryPath() {
+  return resolve(getNativeHostDir(), "index.js");
+}
+function getDeploymentVersionPath() {
+  return resolve(getNativeHostDir(), "version");
+}
+var SEMVER_CORE = /^\d+\.\d+\.\d+/;
+function readDeploymentState() {
+  const versionPath = getDeploymentVersionPath();
+  if (!existsSync(versionPath)) {
+    return { version: null };
+  }
+  try {
+    const raw = readFileSync(versionPath, "utf-8").trim();
+    if (!raw || !SEMVER_CORE.test(raw)) {
+      return { version: null };
+    }
+    return { version: raw };
+  } catch {
+    return { version: null };
+  }
+}
+function writeDeploymentVersion(version2) {
+  const dir = getNativeHostDir();
+  mkdirSync(dir, { recursive: true });
+  const target = getDeploymentVersionPath();
+  const tmp = resolve(dir, `version.tmp.${process.pid}`);
+  try {
+    writeFileSync(tmp, `${version2}
+`, "utf-8");
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/native-host/sync-policy.ts
+function decideSyncAction(state, selfVersion) {
+  if (state.version === null) {
+    return {
+      shouldSync: true,
+      reason: "no-deploy-version",
+      deployedVersion: null,
+      selfVersion
+    };
+  }
+  const cmp = compareSemver(selfVersion, state.version);
+  if (cmp > 0) {
+    return {
+      shouldSync: true,
+      reason: "upgrade",
+      deployedVersion: state.version,
+      selfVersion
+    };
+  }
+  if (cmp === 0) {
+    return {
+      shouldSync: true,
+      reason: "same-version-idempotent",
+      deployedVersion: state.version,
+      selfVersion
+    };
+  }
+  return {
+    shouldSync: false,
+    reason: "avoid-downgrade",
+    deployedVersion: state.version,
+    selfVersion
+  };
+}
+
+// src/native-host-updater.ts
 var PKG_VERSION = (() => {
-  if (true) return "0.10.1";
+  if (true) return "0.10.3";
   try {
     const here = fileURLToPath(import.meta.url);
-    const pkgPath = resolve(here, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkgPath = resolve2(here, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0-test";
   } catch {
     return "0.0.0-test";
   }
 })();
-var NATIVE_HOST_DIR = resolve(homedir(), ".viyv-browser", "native-host");
 function getSourceBinaryPath() {
   return fileURLToPath(import.meta.url);
 }
 function getNativeHostBinaryPath() {
-  return resolve(NATIVE_HOST_DIR, "index.js");
+  return getDeploymentBinaryPath();
 }
 function isNativeHostDeployed() {
-  return existsSync(getNativeHostBinaryPath());
+  return existsSync2(getNativeHostBinaryPath());
 }
 function syncNativeHostBinary() {
   const source = getSourceBinaryPath();
-  if (!existsSync(source)) {
+  if (!existsSync2(source)) {
     throw new Error(`Source binary not found: ${source}`);
   }
-  mkdirSync(NATIVE_HOST_DIR, { recursive: true });
+  const dir = getNativeHostDir();
+  mkdirSync2(dir, { recursive: true });
   const target = getNativeHostBinaryPath();
-  const tmp = resolve(NATIVE_HOST_DIR, `index.js.tmp.${process.pid}`);
+  const tmp = resolve2(dir, `index.js.tmp.${process.pid}`);
   try {
     copyFileSync(source, tmp);
     chmodSync(tmp, 493);
-    renameSync(tmp, target);
+    renameSync2(tmp, target);
   } catch (err) {
     try {
-      unlinkSync(tmp);
+      unlinkSync2(tmp);
     } catch {
     }
     throw err;
   }
+  writeDeploymentVersion(PKG_VERSION);
+}
+function syncNativeHostBinaryIfNeeded() {
+  const decision = decideSyncAction(readDeploymentState(), PKG_VERSION);
+  if (decision.shouldSync) {
+    syncNativeHostBinary();
+  }
+  return decision;
 }
 function shouldUpdateBridge(bridgeVersion) {
   return compareSemver(PKG_VERSION, bridgeVersion) > 0;
@@ -11863,20 +11997,11 @@ function shouldUpdateBridge(bridgeVersion) {
 function getPackageVersion() {
   return PKG_VERSION;
 }
-function compareSemver(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
-}
 
 // src/native-host/bridge-control.ts
 import { randomBytes } from "crypto";
 import { createServer } from "net";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
 var LOG_PREFIX = "[viyv-browser:native-host:control]";
 function startBridgeControl(opts) {
@@ -11886,9 +12011,9 @@ function startBridgeControl(opts) {
   const { deps, onError } = opts;
   let cookie;
   try {
-    mkdirSync2(dirname(cookiePath), { recursive: true });
+    mkdirSync3(dirname(cookiePath), { recursive: true });
     cookie = randomBytes(BRIDGE.CONTROL_COOKIE_BYTES);
-    writeFileSync(cookiePath, cookie.toString("hex"), { mode: 384 });
+    writeFileSync2(cookiePath, cookie.toString("hex"), { mode: 384 });
     try {
       chmodSync2(cookiePath, 384);
     } catch {
@@ -12026,7 +12151,7 @@ function startBridgeControl(opts) {
 }
 
 // src/native-host/bridge-relay.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { createConnection } from "net";
 import { join } from "path";
 
@@ -12128,7 +12253,7 @@ function readProfileIdFromEnv() {
   const dir = process.env.VIYV_USER_DATA_DIR;
   if (!dir) return null;
   try {
-    const raw = readFileSync2(join(dir, "viyv-profile.id"), "utf8").trim();
+    const raw = readFileSync3(join(dir, "viyv-profile.id"), "utf8").trim();
     return raw || null;
   } catch {
     return null;
@@ -12460,7 +12585,7 @@ function startBridge(options) {
       const DRAIN_TIMEOUT = 5e3;
       const drainAndExit = () => {
         if (requestOrigin.size === 0) {
-          gracefulExit("Bridge shutdown requested for version update");
+          gracefulExit("shutdown-request", "version update");
           return;
         }
         process.stderr.write(
@@ -12471,7 +12596,7 @@ function startBridge(options) {
         const check2 = setInterval(() => {
           if (requestOrigin.size === 0 || Date.now() - start > DRAIN_TIMEOUT) {
             clearInterval(check2);
-            gracefulExit("Bridge shutdown requested for version update");
+            gracefulExit("shutdown-request", "version update");
           }
         }, 200);
       };
@@ -12536,6 +12661,7 @@ function startBridge(options) {
     } else if (type === "browser_event") {
       const agentId = message2.agentId;
       if (agentId) broadcastToAgent(agentId, message2);
+    } else if (type === "sw_keepalive") {
     } else {
       process.stderr.write(`${LOG_PREFIX3} Unknown message type from Chrome: ${type}, dropping
 `);
@@ -12565,19 +12691,22 @@ function startBridge(options) {
   let primaryStdinClosed = false;
   const ORPHAN_TIMEOUT = 6e4;
   let orphanTimer = null;
-  function gracefulExit(reason) {
-    process.stderr.write(`${LOG_PREFIX3} ${reason}, exiting
+  function gracefulExit(reason, detail) {
+    const suffix = detail ? ` (${detail})` : "";
+    process.stderr.write(`${LOG_PREFIX3} exiting reason=${reason}${suffix}
 `);
     if (orphanTimer) {
       clearTimeout(orphanTimer);
       orphanTimer = null;
     }
-    const closingMsg = JSON.stringify({ type: "bridge_closing", timestamp: Date.now() });
-    for (const [, conn] of mcpConnections) {
-      try {
-        conn.socket.write(`${closingMsg}
+    if (shouldBroadcastClosing(reason)) {
+      const closingMsg = JSON.stringify({ type: "bridge_closing", timestamp: Date.now() });
+      for (const [, conn] of mcpConnections) {
+        try {
+          conn.socket.write(`${closingMsg}
 `);
-      } catch {
+        } catch {
+        }
       }
     }
     for (const [, conn] of mcpConnections) {
@@ -12603,7 +12732,7 @@ function startBridge(options) {
       return;
     }
     if (chromeConnections.size === 0 && mcpConnections.size === 0) {
-      gracefulExit("No connections remaining");
+      gracefulExit("all-empty", "no connections remaining");
     }
     if (chromeConnections.size === 0 && mcpConnections.size > 0 && !orphanTimer) {
       process.stderr.write(
@@ -12800,7 +12929,7 @@ function startBridge(options) {
     const primaryUserDataDir = process.env.VIYV_USER_DATA_DIR;
     if (primaryUserDataDir) {
       try {
-        const raw = readFileSync3(join2(primaryUserDataDir, "viyv-profile.id"), "utf8").trim();
+        const raw = readFileSync4(join2(primaryUserDataDir, "viyv-profile.id"), "utf8").trim();
         if (raw) {
           setProfileId(primaryChromeId, raw);
           process.stderr.write(
@@ -12819,8 +12948,8 @@ function startBridge(options) {
       onError: (e) => onError?.(e)
     });
     notifyChromeConnected(false);
-    process.on("SIGINT", () => gracefulExit("SIGINT received"));
-    process.on("SIGTERM", () => gracefulExit("SIGTERM received"));
+    process.on("SIGINT", () => gracefulExit("sigint"));
+    process.on("SIGTERM", () => gracefulExit("chrome-sigterm"));
     process.stdin.on("end", () => {
       process.stderr.write(`${LOG_PREFIX3} Primary Chrome stdin closed
 `);
@@ -12833,9 +12962,8 @@ function startBridge(options) {
 
 // src/server.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 import http from "http";
-import { createConnection as createConnection2 } from "net";
 import { dirname as dirname2 } from "path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -24912,7 +25040,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -24929,7 +25057,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -25007,7 +25135,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve3(parseResult.data);
+            resolve4(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -25268,12 +25396,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve3, interval);
+      const timeoutId = setTimeout(resolve4, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -26232,7 +26360,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+      await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -27020,12 +27148,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message2) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const json = serializeMessage(message2);
       if (this._stdout.write(json)) {
-        resolve3();
+        resolve4();
       } else {
-        this._stdout.once("drain", resolve3);
+        this._stdout.once("drain", resolve4);
       }
     });
   }
@@ -27439,7 +27567,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve3) => setTimeout(resolve3));
+            await new Promise((resolve4) => setTimeout(resolve4));
             maxReadCount = 3;
             continue;
           }
@@ -27921,9 +28049,9 @@ data:
       const initRequest = messages.find((m) => isInitializeRequest(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) {
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           this._streamMapping.set(streamId, {
-            resolveJson: resolve3,
+            resolveJson: resolve4,
             cleanup: () => {
               this._streamMapping.delete(streamId);
             }
@@ -28249,6 +28377,408 @@ var StreamableHTTPServerTransport = class {
   }
 };
 
+// src/native-host/bridge-client/index.ts
+import { createConnection as createConnection2 } from "net";
+
+// src/native-host/bridge-client/connection-state.ts
+function transition(state, event) {
+  if (event.kind === "stop") return "disconnected";
+  switch (state) {
+    case "disconnected":
+      if (event.kind === "start") return "connecting";
+      return state;
+    case "connecting":
+      if (event.kind === "socket-connected") return "handshaking";
+      if (event.kind === "socket-closed") return "disconnected";
+      return state;
+    case "handshaking":
+      if (event.kind === "bridge-status-true") return "ready";
+      if (event.kind === "bridge-status-false") return "handshaking";
+      if (event.kind === "bridge-closing") return "draining";
+      if (event.kind === "socket-closed") return "disconnected";
+      return state;
+    case "ready":
+      if (event.kind === "bridge-status-false") return "handshaking";
+      if (event.kind === "bridge-closing") return "draining";
+      if (event.kind === "socket-closed") return "disconnected";
+      return state;
+    case "draining":
+      if (event.kind === "socket-closed") return "disconnected";
+      return state;
+    default: {
+      const _exhaustive = state;
+      return _exhaustive;
+    }
+  }
+}
+function isReady(state) {
+  return state === "ready";
+}
+
+// src/native-host/bridge-client/pending-queue.ts
+var PendingQueue = class {
+  constructor(max, ttlMs, timers) {
+    this.max = max;
+    this.ttlMs = ttlMs;
+    this.timers = timers;
+    if (max < 1) throw new Error("PendingQueue max must be >= 1");
+    if (ttlMs < 0) throw new Error("PendingQueue ttlMs must be >= 0");
+  }
+  entries = [];
+  /** Try to enqueue. Returns `true` on success, `false` when rejected (onReject already fired). */
+  enqueue(entry) {
+    if (this.entries.length >= this.max) {
+      entry.onReject("queue-full");
+      return false;
+    }
+    const stored = { ...entry, timer: null };
+    stored.timer = this.timers.setTimer(() => this.expire(stored), this.ttlMs);
+    this.entries.push(stored);
+    return true;
+  }
+  /** Flush every queued entry in FIFO order. */
+  flushAll() {
+    const snapshot = this.entries.splice(0, this.entries.length);
+    for (const entry of snapshot) {
+      this.timers.clearTimer(entry.timer);
+      entry.onFlush(entry.payload);
+    }
+  }
+  /** Reject every queued entry with the given reason. Used on `stop()`. */
+  rejectAll(reason) {
+    const snapshot = this.entries.splice(0, this.entries.length);
+    for (const entry of snapshot) {
+      this.timers.clearTimer(entry.timer);
+      entry.onReject(reason);
+    }
+  }
+  size() {
+    return this.entries.length;
+  }
+  expire(entry) {
+    const idx = this.entries.indexOf(entry);
+    if (idx === -1) return;
+    this.entries.splice(idx, 1);
+    entry.onReject("timeout");
+  }
+};
+
+// src/native-host/bridge-client/index.ts
+var LOG_PREFIX4 = "[viyv-browser:mcp:bridge]";
+var METRIC_PREFIX = "[viyv-browser:mcp:metric]";
+var LINE_TERMINATOR = "\n";
+var BRIDGE_RECONNECT_CAP_MS = 3e3;
+var defaultTimers = {
+  setTimer: (fn, ms) => setTimeout(fn, ms),
+  clearTimer: (h) => clearTimeout(h)
+};
+var defaultSchedule = (fn, ms) => {
+  const h = setTimeout(fn, ms);
+  return () => clearTimeout(h);
+};
+var BridgeClient = class {
+  constructor(options) {
+    this.options = options;
+    this.log = options.log ?? ((line) => process.stderr.write(`${line}
+`));
+    this.metric = options.metric ?? ((line) => process.stderr.write(`${line}
+`));
+    this.now = options.now ?? (() => Date.now());
+    this.schedule = options.schedule ?? defaultSchedule;
+    this.random = options.random ?? Math.random;
+    this.queue = new PendingQueue(
+      BRIDGE_READINESS.PENDING_QUEUE_MAX,
+      BRIDGE_READINESS.TIMEOUT_MS,
+      options.timers ?? defaultTimers
+    );
+  }
+  state = "disconnected";
+  socket = null;
+  reconnectAttempt = 0;
+  cancelReconnect = null;
+  messageHandlers = /* @__PURE__ */ new Set();
+  stateHandlers = /* @__PURE__ */ new Set();
+  queue;
+  /** ms since epoch when the current handshake started; `null` when not measuring. */
+  handshakeStartMs = null;
+  started = false;
+  log;
+  metric;
+  now;
+  schedule;
+  random;
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.apply({ kind: "start" });
+    this.connect();
+  }
+  stop() {
+    this.started = false;
+    this.cancelReconnect?.();
+    this.cancelReconnect = null;
+    this.queue.rejectAll("stopped");
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.destroy();
+    }
+    this.socket = null;
+    this.apply({ kind: "stop" });
+  }
+  /**
+   * Drop the current socket and reconnect immediately. Used by switch_browser
+   * to pivot to a fresh Chrome. Pending tool_calls are drained with the
+   * SWITCH_IN_PROGRESS error by the caller before this is invoked.
+   */
+  forceReconnect() {
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.destroy();
+    }
+    this.socket = null;
+    this.apply({ kind: "socket-closed" });
+    if (this.started) {
+      this.reconnectAttempt = 0;
+      this.scheduleReconnect();
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  isReady() {
+    return isReady(this.state);
+  }
+  /**
+   * Return the socket when it is TCP-live (handshaking, ready, or draining).
+   * Ancillary writes like session_init / session_close tolerate writes during
+   * handshake — the bridge buffers them until Chrome is reachable.
+   * Returns null when the socket is not safe to write to.
+   */
+  getSocket() {
+    if (!this.socket || this.socket.destroyed) return null;
+    if (this.state === "handshaking" || this.state === "ready" || this.state === "draining") {
+      return this.socket;
+    }
+    return null;
+  }
+  onMessage(fn) {
+    this.messageHandlers.add(fn);
+    return () => this.messageHandlers.delete(fn);
+  }
+  onStateChange(fn) {
+    this.stateHandlers.add(fn);
+    return () => this.stateHandlers.delete(fn);
+  }
+  /**
+   * Send a tool_call line. If the bridge is `ready`, writes immediately.
+   * Otherwise enqueues until readiness, failing with `queue-full` if capacity
+   * is exhausted or `timeout` if the handshake takes too long.
+   */
+  enqueueToolCall(line) {
+    return new Promise((resolve4, reject) => {
+      if (this.state === "ready" && this.socket && !this.socket.destroyed) {
+        try {
+          this.socket.write(line.endsWith(LINE_TERMINATOR) ? line : line + LINE_TERMINATOR);
+          resolve4();
+        } catch (err) {
+          reject({ reason: "write-failed", detail: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+      }
+      const enqueued = this.queue.enqueue({
+        payload: {
+          line: line.endsWith(LINE_TERMINATOR) ? line : line + LINE_TERMINATOR,
+          resolve: resolve4,
+          reject
+        },
+        onFlush: (entry) => {
+          if (this.socket && !this.socket.destroyed) {
+            try {
+              this.socket.write(entry.line);
+              entry.resolve();
+            } catch (err) {
+              entry.reject({
+                reason: "write-failed",
+                detail: err instanceof Error ? err.message : String(err)
+              });
+            }
+          } else {
+            entry.reject({ reason: "write-failed", detail: "socket unavailable at flush" });
+          }
+        },
+        onReject: (reason) => {
+          reject({ reason });
+        }
+      });
+      if (enqueued) {
+        this.emitMetric("queue.enqueue", { depth: this.queue.size() });
+      }
+    });
+  }
+  connect() {
+    if (!this.started) return;
+    this.cancelReconnect = null;
+    this.apply({ kind: "start" });
+    if (this.state !== "connecting") {
+      this.forceState("connecting");
+    }
+    const sock = createConnection2({ host: this.options.host, port: this.options.port });
+    this.socket = sock;
+    sock.on("connect", () => {
+      this.handshakeStartMs = this.now();
+      sock.setKeepAlive(true, 3e4);
+      this.reconnectAttempt = 0;
+      this.apply({ kind: "socket-connected" });
+    });
+    sock.on("error", (err) => {
+      this.log(`${LOG_PREFIX4} socket error: ${err.message}`);
+    });
+    sock.on("close", () => {
+      const wasReady = this.state === "ready";
+      if (this.socket === sock) this.socket = null;
+      this.apply({ kind: "socket-closed" });
+      if (wasReady) this.log(`${LOG_PREFIX4} bridge disconnected`);
+      if (this.started) this.scheduleReconnect();
+    });
+    let lineBuffer = "";
+    sock.on("data", (data) => {
+      lineBuffer += data.toString("utf-8");
+      const lines = lineBuffer.split(LINE_TERMINATOR);
+      lineBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          this.handleIncoming(parsed);
+        } catch (err) {
+          this.log(
+            `${LOG_PREFIX4} parse error: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    });
+  }
+  handleIncoming(msg) {
+    if (msg && typeof msg === "object") {
+      const type = msg.type;
+      if (type === "bridge_closing") {
+        this.log(`${LOG_PREFIX4} received bridge_closing, will reconnect`);
+        this.apply({ kind: "bridge-closing" });
+        if (this.socket && !this.socket.destroyed) this.socket.destroy();
+        return;
+      }
+      if (type === "bridge_status") {
+        const connected = msg.connected === true;
+        this.apply({ kind: connected ? "bridge-status-true" : "bridge-status-false" });
+      }
+    }
+    for (const h of this.messageHandlers) {
+      try {
+        h(msg);
+      } catch (err) {
+        this.log(
+          `${LOG_PREFIX4} handler threw: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (!this.started) return;
+    if (this.cancelReconnect) return;
+    this.reconnectAttempt++;
+    const base = Math.min(
+      RECONNECT.INITIAL_DELAY * RECONNECT.MULTIPLIER ** (this.reconnectAttempt - 1),
+      BRIDGE_RECONNECT_CAP_MS
+    );
+    const delay = applyJitter(base, RECONNECT.JITTER_RATIO, this.random);
+    this.emitMetric("reconnect.scheduled", { attempt: this.reconnectAttempt, delayMs: delay });
+    this.log(`${LOG_PREFIX4} reconnect in ${delay}ms (attempt ${this.reconnectAttempt})`);
+    this.cancelReconnect = this.schedule(() => {
+      this.cancelReconnect = null;
+      this.connect();
+    }, delay);
+  }
+  apply(event) {
+    const next = transition(this.state, event);
+    if (next === this.state) return;
+    const prev = this.state;
+    this.state = next;
+    this.emitMetric("state.transition", { from: prev, to: next, event: event.kind });
+    if (next === "ready") {
+      if (this.handshakeStartMs !== null) {
+        this.emitMetric("handshake.complete", {
+          elapsedMs: this.now() - this.handshakeStartMs
+        });
+        this.handshakeStartMs = null;
+      }
+      this.queue.flushAll();
+    }
+    for (const h of this.stateHandlers) {
+      try {
+        h(next, prev);
+      } catch (err) {
+        this.log(
+          `${LOG_PREFIX4} state handler threw: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  /** Force a specific state (used only for recovering from impossible transitions). */
+  forceState(to) {
+    if (this.state === to) return;
+    const prev = this.state;
+    this.state = to;
+    this.emitMetric("state.force", { from: prev, to });
+    for (const h of this.stateHandlers) {
+      try {
+        h(to, prev);
+      } catch {
+      }
+    }
+  }
+  emitMetric(name, fields) {
+    this.metric(
+      `${METRIC_PREFIX} ${name} ${Object.entries(fields).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ")}`
+    );
+  }
+};
+function toolCallRejectionToErrorCode(rej) {
+  switch (rej.reason) {
+    case "queue-full":
+      return {
+        code: "EXTENSION_NOT_CONNECTED",
+        message: "Bridge readiness queue is full; try again shortly"
+      };
+    case "timeout":
+      return {
+        code: "EXTENSION_NOT_CONNECTED",
+        message: "Timed out waiting for bridge readiness"
+      };
+    case "stopped":
+      return {
+        code: "EXTENSION_NOT_CONNECTED",
+        message: "Bridge client was stopped"
+      };
+    case "write-failed":
+      return {
+        code: "EXTENSION_NOT_CONNECTED",
+        message: `Socket write failed: ${rej.detail}`
+      };
+  }
+}
+
+// src/bridge-protocol/shutdown-request-gate.ts
+var SHUTDOWN_REQUEST_COOLDOWN_MS = 3e4;
+function createShutdownGateState() {
+  return { lastSentAt: null, lastVersion: null };
+}
+function shouldSendShutdownRequest(state, observedVersion, now, cooldownMs = SHUTDOWN_REQUEST_COOLDOWN_MS) {
+  if (state.lastSentAt === null) return true;
+  if (state.lastVersion !== observedVersion) return true;
+  return now - state.lastSentAt >= cooldownMs;
+}
+function markSent(state, version2, now) {
+  return { lastSentAt: now, lastVersion: version2 };
+}
+
 // ../shared/dist/bearer-equals.js
 import { timingSafeEqual } from "crypto";
 function bearerEquals(header, expectedToken) {
@@ -33775,8 +34305,12 @@ function computeToolTimeout(tool, input) {
 
 // src/server.ts
 var pendingRequests = /* @__PURE__ */ new Map();
-var extensionSocket = null;
+var bridgeClient = null;
 var bridgeUpdateInfo = null;
+var shutdownGate = createShutdownGateState();
+function getBridgeSocket() {
+  return bridgeClient?.getSocket() ?? null;
+}
 function readJwtConfigFromEnv() {
   const alg = process.env.VIYV_JWT_ALG ?? "none";
   return {
@@ -33844,8 +34378,9 @@ function bridgeRegisterAgent(agentId, sessionId) {
     bridgeAgentRefs.set(agentId, set);
   }
   set.add(sessionId);
-  if (isFirst && extensionSocket && !extensionSocket.destroyed) {
-    sendSessionInit(extensionSocket, agentId);
+  if (isFirst) {
+    const sock = getBridgeSocket();
+    if (sock) sendSessionInit(sock, agentId);
   }
 }
 function bridgeUnregisterAgent(agentId, sessionId) {
@@ -33854,8 +34389,9 @@ function bridgeUnregisterAgent(agentId, sessionId) {
   set.delete(sessionId);
   if (set.size === 0) {
     bridgeAgentRefs.delete(agentId);
-    if (extensionSocket && !extensionSocket.destroyed) {
-      extensionSocket.write(
+    const sock = getBridgeSocket();
+    if (sock) {
+      sock.write(
         `${JSON.stringify({
           id: randomUUID5(),
           type: "session_close",
@@ -33892,7 +34428,7 @@ function coerceShape(shape) {
   return result;
 }
 function handleFileExport(filePath, result) {
-  mkdirSync3(dirname2(filePath), { recursive: true });
+  mkdirSync4(dirname2(filePath), { recursive: true });
   let content;
   let metadata;
   if (typeof result.data === "string") {
@@ -33912,7 +34448,7 @@ function handleFileExport(filePath, result) {
     const pages = Array.isArray(result.pages) ? result.pages : [];
     metadata = { ok: true, file_path: filePath, page_count: pages.length };
   }
-  writeFileSync2(filePath, content, "utf-8");
+  writeFileSync3(filePath, content, "utf-8");
   metadata.file_size = Buffer.byteLength(content, "utf-8");
   return metadata;
 }
@@ -34006,7 +34542,8 @@ async function startMcpServer(agentName, options) {
     setDefaultAgentId(agentName);
   }
   configuredChromeProfile = options?.chromeProfile;
-  connectToBridge();
+  bridgeClient = initBridgeClient();
+  bridgeClient.start();
   if (options?.transport === "sse") {
     const sessions2 = /* @__PURE__ */ new Map();
     const httpServer = http.createServer();
@@ -34044,7 +34581,7 @@ async function startMcpServer(agentName, options) {
       }
       httpServer.close(() => {
       });
-      extensionSocket?.destroy();
+      bridgeClient?.stop();
       process.exit(0);
     };
     process.on("SIGINT", () => {
@@ -34119,7 +34656,7 @@ async function startMcpServer(agentName, options) {
       }
       httpServer.close(() => {
       });
-      extensionSocket?.destroy();
+      bridgeClient?.stop();
       process.exit(0);
     };
     process.on("SIGINT", () => {
@@ -34138,13 +34675,13 @@ async function startMcpServer(agentName, options) {
     );
     process.stdin.on("end", () => {
       process.stderr.write("[viyv-browser:mcp] stdin closed, shutting down\n");
-      extensionSocket?.destroy();
+      bridgeClient?.stop();
       process.exit(0);
     });
     process.on("SIGINT", () => process.exit(0));
     process.on("SIGTERM", () => process.exit(0));
     process.on("exit", () => {
-      extensionSocket?.destroy();
+      bridgeClient?.stop();
     });
   }
 }
@@ -34299,7 +34836,7 @@ async function handleStreamableHttpRequest(req, res, sessions2) {
 }
 var MAX_BODY_SIZE = 4 * 1024 * 1024;
 function parseJsonBody(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const chunks = [];
     let size = 0;
     let destroyed = false;
@@ -34317,7 +34854,7 @@ function parseJsonBody(req) {
     req.on("end", () => {
       if (destroyed) return;
       try {
-        resolve3(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+        resolve4(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
       } catch (error2) {
         reject(new Error(`Invalid JSON: ${error2.message}`));
       }
@@ -34327,65 +34864,6 @@ function parseJsonBody(req) {
     });
   });
 }
-function connectToBridge() {
-  let retryCount = 0;
-  let bridgeClosingReceived = false;
-  let cleanup = null;
-  function connect() {
-    bridgeClosingReceived = false;
-    const socket = createConnection2({ port: BRIDGE.TCP_PORT, host: BRIDGE.TCP_HOST });
-    socket.on("connect", () => {
-      retryCount = 0;
-      cleanup = setupBridgeConnection(socket, () => {
-        bridgeClosingReceived = true;
-      });
-    });
-    socket.on("error", () => {
-    });
-    socket.on("close", () => {
-      const wasConnected = cleanup !== null;
-      cleanup?.();
-      cleanup = null;
-      if (wasConnected) {
-        process.stderr.write("[viyv-browser:mcp] Bridge disconnected\n");
-      }
-      if (extensionSocket === socket) {
-        extensionSocket = null;
-        setExtensionConnected(false);
-      }
-      for (const [id, pending] of pendingRequests) {
-        clearTimeout(pending.timer);
-        pendingRequests.delete(id);
-        pending.resolve({
-          error: {
-            code: "EXTENSION_NOT_CONNECTED",
-            message: "Bridge disconnected while request was pending"
-          }
-        });
-      }
-      scheduleReconnect();
-    });
-  }
-  function scheduleReconnect() {
-    if (bridgeClosingReceived) {
-      retryCount = 0;
-      setTimeout(connect, RECONNECT.INITIAL_DELAY);
-      return;
-    }
-    retryCount++;
-    const BRIDGE_RECONNECT_CAP = 3e3;
-    const delay = Math.min(
-      RECONNECT.INITIAL_DELAY * RECONNECT.MULTIPLIER ** (retryCount - 1),
-      BRIDGE_RECONNECT_CAP
-    );
-    process.stderr.write(
-      `[viyv-browser:mcp] Reconnecting to bridge in ${delay}ms (attempt ${retryCount})
-`
-    );
-    setTimeout(connect, delay);
-  }
-  connect();
-}
 function sendSessionInit(socket, agentId) {
   const initMsg = {
     id: randomUUID5(),
@@ -34400,65 +34878,79 @@ function sendSessionInit(socket, agentId) {
   socket.write(`${JSON.stringify(initMsg)}
 `);
 }
-function setupBridgeConnection(socket, onBridgeClosing) {
-  process.stderr.write(
-    `[viyv-browser:mcp] Connected to bridge at ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
+function initBridgeClient() {
+  const client = new BridgeClient({ host: BRIDGE.TCP_HOST, port: BRIDGE.TCP_PORT });
+  let heartbeatInterval = null;
+  client.onMessage((rawMsg) => {
+    if (!rawMsg || typeof rawMsg !== "object") return;
+    let parsed = rawMsg;
+    if (parsed.type === "compressed" && typeof parsed.data === "string") {
+      try {
+        const decompressed = decompressPayload(parsed.data, true);
+        parsed = JSON.parse(decompressed);
+      } catch (err) {
+        process.stderr.write(
+          `[viyv-browser:mcp] Decompress error: ${err instanceof Error ? err.message : String(err)}
 `
-  );
-  extensionSocket = socket;
-  socket.setKeepAlive(true, 3e4);
-  setExtensionConnected(true);
-  const agentId = getDefaultAgentId();
-  sendSessionInit(socket, agentId);
-  bridgeResyncAgents(socket);
-  const heartbeatInterval = setInterval(() => {
-    if (socket.destroyed) {
-      clearInterval(heartbeatInterval);
-      return;
+        );
+        return;
+      }
     }
-    socket.write(
-      `${JSON.stringify({
-        id: randomUUID5(),
-        type: "session_heartbeat",
-        agentId,
-        timestamp: Date.now()
-      })}
+    handleExtensionMessage(parsed);
+  });
+  client.onStateChange((next, prev) => {
+    if (next === "ready" && prev !== "ready") {
+      process.stderr.write(
+        `[viyv-browser:mcp] Connected to bridge at ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
 `
-    );
-  }, TIMEOUTS.HEARTBEAT);
-  let lineBuffer = "";
-  socket.on("data", (data) => {
-    lineBuffer += data.toString("utf-8");
-    const lines = lineBuffer.split("\n");
-    lineBuffer = lines.pop() ?? "";
-    for (const line of lines) {
-      if (!line) continue;
-      try {
-        let parsed = JSON.parse(line);
-        if (parsed.type === "bridge_closing") {
-          process.stderr.write("[viyv-browser:mcp] Received bridge_closing, will reconnect\n");
-          onBridgeClosing();
-          socket.destroy();
-          return;
-        }
-        if (parsed.type === "compressed" && typeof parsed.data === "string") {
-          const decompressed = decompressPayload(parsed.data, true);
-          parsed = JSON.parse(decompressed);
-        }
-        handleExtensionMessage(parsed);
-      } catch (error2) {
-        process.stderr.write(`[viyv-browser:mcp] Parse error: ${error2.message}
-`);
+      );
+      setExtensionConnected(true);
+      const sock = client.getSocket();
+      if (sock) {
+        const agentId = getDefaultAgentId();
+        sendSessionInit(sock, agentId);
+        bridgeResyncAgents(sock);
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        heartbeatInterval = setInterval(() => {
+          const s = client.getSocket();
+          if (!s || s.destroyed) {
+            if (heartbeatInterval) {
+              clearInterval(heartbeatInterval);
+              heartbeatInterval = null;
+            }
+            return;
+          }
+          s.write(
+            `${JSON.stringify({
+              id: randomUUID5(),
+              type: "session_heartbeat",
+              agentId,
+              timestamp: Date.now()
+            })}
+`
+          );
+        }, TIMEOUTS.HEARTBEAT);
+      }
+    }
+    if (prev === "ready" && next !== "ready") {
+      setExtensionConnected(false);
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+      }
+      for (const [id, pending] of pendingRequests) {
+        clearTimeout(pending.timer);
+        pendingRequests.delete(id);
+        pending.resolve({
+          error: {
+            code: "EXTENSION_NOT_CONNECTED",
+            message: "Bridge disconnected while request was pending"
+          }
+        });
       }
     }
   });
-  socket.on("error", (error2) => {
-    process.stderr.write(`[viyv-browser:mcp] Bridge socket error: ${error2.message}
-`);
-  });
-  return () => {
-    clearInterval(heartbeatInterval);
-  };
+  return client;
 }
 function handleExtensionMessage(message2) {
   if (!message2 || typeof message2 !== "object") return;
@@ -34516,9 +35008,10 @@ function handleExtensionMessage(message2) {
       } else {
         setExtensionConnected(true);
         recordHeartbeat();
-        if (extensionSocket && !extensionSocket.destroyed && listSessions().length === 0) {
+        const sockForReinit = getBridgeSocket();
+        if (sockForReinit && listSessions().length === 0) {
           const agentId = getDefaultAgentId();
-          sendSessionInit(extensionSocket, agentId);
+          sendSessionInit(sockForReinit, agentId);
           process.stderr.write(
             `[viyv-browser:mcp] Session re-initialized after Chrome reconnect: ${agentId}
 `
@@ -34529,14 +35022,24 @@ function handleExtensionMessage(message2) {
     const bridgeVersion = typeof msg.bridgeVersion === "string" ? msg.bridgeVersion : null;
     if (bridgeVersion && shouldUpdateBridge(bridgeVersion)) {
       const serverVersion = getPackageVersion();
-      process.stderr.write(
-        `[viyv-browser:mcp] Bridge version mismatch (bridge=${bridgeVersion}, server=${serverVersion}), requesting restart
+      const nowMs = Date.now();
+      if (shouldSendShutdownRequest(shutdownGate, bridgeVersion, nowMs)) {
+        process.stderr.write(
+          `[viyv-browser:mcp] Bridge version mismatch (bridge=${bridgeVersion}, server=${serverVersion}), requesting restart
 `
-      );
-      bridgeUpdateInfo = { from: bridgeVersion, to: serverVersion };
-      if (extensionSocket && !extensionSocket.destroyed) {
-        extensionSocket.write(
-          `${JSON.stringify({ type: "bridge_shutdown_request", timestamp: Date.now() })}
+        );
+        bridgeUpdateInfo = { from: bridgeVersion, to: serverVersion };
+        const shutdownSock = getBridgeSocket();
+        if (shutdownSock) {
+          shutdownSock.write(
+            `${JSON.stringify({ type: "bridge_shutdown_request", timestamp: nowMs })}
+`
+          );
+          shutdownGate = markSent(shutdownGate, bridgeVersion, nowMs);
+        }
+      } else {
+        process.stderr.write(
+          `[viyv-browser:mcp] Skipping bridge_shutdown_request \u2014 same version ${bridgeVersion} within cooldown (orphan MCP or external tampering is re-seeding the deploy binary; check for stale viyv-browser-mcp processes)
 `
         );
       }
@@ -34665,7 +35168,7 @@ async function callExtensionTool(tool, input) {
   }
   if (tool === "browser_health") {
     const health = getHealthStatus();
-    if (!health.extensionConnected || !extensionSocket || extensionSocket.destroyed) {
+    if (!health.extensionConnected || !getBridgeSocket()) {
       return {
         content: [{ type: "text", text: JSON.stringify(health) }]
       };
@@ -34679,7 +35182,7 @@ async function callExtensionTool(tool, input) {
     if (paths) {
       for (const p of paths) {
         try {
-          if (!existsSync2(p) || !statSync(p).isFile()) {
+          if (!existsSync3(p) || !statSync(p).isFile()) {
             return {
               content: [
                 {
@@ -34711,7 +35214,7 @@ async function callExtensionTool(tool, input) {
     let csvData;
     if (typeof input.file_path === "string") {
       const fp = input.file_path;
-      if (!existsSync2(fp) || !statSync(fp).isFile()) {
+      if (!existsSync3(fp) || !statSync(fp).isFile()) {
         return {
           content: [
             {
@@ -34723,7 +35226,7 @@ async function callExtensionTool(tool, input) {
           ]
         };
       }
-      csvData = readFileSync4(fp, "utf-8");
+      csvData = readFileSync5(fp, "utf-8");
     } else if (typeof input.data === "string") {
       csvData = input.data;
     }
@@ -34749,7 +35252,7 @@ async function callExtensionTool(tool, input) {
       }
     }
   }
-  if (!extensionSocket || extensionSocket.destroyed) {
+  if (!bridgeClient) {
     return {
       content: [
         {
@@ -34757,7 +35260,7 @@ async function callExtensionTool(tool, input) {
           text: JSON.stringify({
             error: {
               code: "EXTENSION_NOT_CONNECTED",
-              message: "Chrome Extension is not connected. Please open Chrome and click the Viyv Browser extension icon."
+              message: "Bridge client not initialized"
             }
           })
         }
@@ -34767,36 +35270,15 @@ async function callExtensionTool(tool, input) {
   const requestId = randomUUID5();
   const agentId = getCurrentAgentId(getDefaultAgentId);
   touchSession(agentId);
-  const sock = extensionSocket;
+  const client = bridgeClient;
   const toolTimeout = computeToolTimeout(tool, input);
-  return new Promise((resolve3) => {
-    const onError = () => {
-      const pending = pendingRequests.get(requestId);
-      if (pending) {
-        clearTimeout(pending.timer);
-        pendingRequests.delete(requestId);
-        resolve3({
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: {
-                  code: "EXTENSION_NOT_CONNECTED",
-                  message: "Socket write failed"
-                }
-              })
-            }
-          ]
-        });
-      }
-    };
+  return new Promise((resolve4) => {
     const removeErrorListener = () => {
-      sock.removeListener("error", onError);
     };
     const timer = setTimeout(() => {
       pendingRequests.delete(requestId);
       removeErrorListener();
-      resolve3({
+      resolve4({
         content: [
           {
             type: "text",
@@ -34823,12 +35305,12 @@ async function callExtensionTool(tool, input) {
         if (FILE_EXPORT_TOOLS.has(tool) && typeof filePath === "string" && ("data" in result || "pages" in result)) {
           try {
             const metadata = handleFileExport(filePath, result);
-            resolve3({
+            resolve4({
               content: [{ type: "text", text: JSON.stringify(metadata) }]
             });
           } catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            resolve3({
+            resolve4({
               content: [
                 {
                   type: "text",
@@ -34847,9 +35329,9 @@ async function callExtensionTool(tool, input) {
         if (RESULT_EXPORT_TOOLS.has(tool) && typeof filePath === "string") {
           try {
             const content = JSON.stringify(result, null, 2);
-            mkdirSync3(dirname2(filePath), { recursive: true });
-            writeFileSync2(filePath, content, "utf-8");
-            resolve3({
+            mkdirSync4(dirname2(filePath), { recursive: true });
+            writeFileSync3(filePath, content, "utf-8");
+            resolve4({
               content: [
                 {
                   type: "text",
@@ -34862,7 +35344,7 @@ async function callExtensionTool(tool, input) {
             });
           } catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            resolve3({
+            resolve4({
               content: [
                 {
                   type: "text",
@@ -34889,21 +35371,21 @@ async function callExtensionTool(tool, input) {
         }
         if (tempImportFile) {
           try {
-            unlinkSync2(tempImportFile);
+            unlinkSync3(tempImportFile);
           } catch {
           }
         }
-        resolve3({ content: buildResponseContent(tool, finalResult) });
+        resolve4({ content: buildResponseContent(tool, finalResult) });
       },
       reject: (error2) => {
         removeErrorListener();
         if (tempImportFile) {
           try {
-            unlinkSync2(tempImportFile);
+            unlinkSync3(tempImportFile);
           } catch {
           }
         }
-        resolve3({
+        resolve4({
           content: [
             {
               type: "text",
@@ -34937,13 +35419,17 @@ async function callExtensionTool(tool, input) {
       `[viyv-browser:mcp] tool_call id=${requestId} agent=${agentId} pid=${ctxLog?.claims?.pid ?? chromeProfile ?? "-"} tool=${tool}
 `
     );
-    const written = sock.write(`${JSON.stringify(request)}
-`);
-    if (!written) {
-      sock.once("drain", () => {
+    client.enqueueToolCall(`${JSON.stringify(request)}
+`).catch((rej) => {
+      const pending = pendingRequests.get(requestId);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      pendingRequests.delete(requestId);
+      const { code, message: message2 } = toolCallRejectionToErrorCode(rej);
+      resolve4({
+        content: [{ type: "text", text: JSON.stringify({ error: { code, message: message2 } }) }]
       });
-    }
-    sock.once("error", onError);
+    });
   });
 }
 async function handleSwitchBrowser() {
@@ -34958,19 +35444,18 @@ async function handleSwitchBrowser() {
       }
     });
   }
-  if (extensionSocket && !extensionSocket.destroyed) {
+  if (bridgeClient) {
     process.stderr.write("[viyv-browser:mcp] switch_browser: closing current connection\n");
-    extensionSocket.destroy();
-    extensionSocket = null;
+    bridgeClient.forceReconnect();
     setExtensionConnected(false);
   }
   process.stderr.write("[viyv-browser:mcp] switch_browser: waiting for bridge reconnection...\n");
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const checkInterval = setInterval(() => {
-      if (extensionSocket && !extensionSocket.destroyed && isExtensionConnected()) {
+      if (bridgeClient?.isReady() && isExtensionConnected()) {
         clearInterval(checkInterval);
         clearTimeout(timer);
-        resolve3({
+        resolve4({
           content: [
             {
               type: "text",
@@ -34985,7 +35470,7 @@ async function handleSwitchBrowser() {
     }, 500);
     const timer = setTimeout(() => {
       clearInterval(checkInterval);
-      resolve3({
+      resolve4({
         content: [
           {
             type: "text",
@@ -35004,9 +35489,9 @@ async function handleSwitchBrowser() {
 
 // src/setup.ts
 import { execSync } from "child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, platform } from "os";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 function runSetup(options = {}) {
   const os = platform();
   console.log("Viyv Browser MCP - Native Messaging Host Setup");
@@ -35038,8 +35523,8 @@ function runSetup(options = {}) {
   console.log(`Wrapper: ${wrapperPath}`);
   for (const manifestPath of manifestPaths) {
     console.log(`Manifest path: ${manifestPath}`);
-    mkdirSync4(dirname3(manifestPath), { recursive: true });
-    writeFileSync3(manifestPath, JSON.stringify(manifest, null, 2));
+    mkdirSync5(dirname3(manifestPath), { recursive: true });
+    writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2));
     chmodSync3(manifestPath, 420);
   }
   console.log("\nNative Messaging Host registered successfully!");
@@ -35053,17 +35538,17 @@ function runSetup(options = {}) {
 }
 function createNativeHostWrapper(os, binaryPath, dockerMode) {
   const manifestDir = dockerMode ? "/etc/chromium/native-messaging-hosts" : dirname3(getManifestPath(os));
-  mkdirSync4(manifestDir, { recursive: true });
+  mkdirSync5(manifestDir, { recursive: true });
   const nodePath = getNodePath();
   if (os === "win32") {
-    const wrapperPath2 = resolve2(manifestDir, `${NATIVE_HOST_NAME}.bat`);
-    writeFileSync3(wrapperPath2, `@echo off\r
+    const wrapperPath2 = resolve3(manifestDir, `${NATIVE_HOST_NAME}.bat`);
+    writeFileSync4(wrapperPath2, `@echo off\r
 "${nodePath}" "${binaryPath}" --native-host\r
 `);
     return wrapperPath2;
   }
-  const wrapperPath = resolve2(manifestDir, `${NATIVE_HOST_NAME}.sh`);
-  writeFileSync3(wrapperPath, `#!/bin/bash
+  const wrapperPath = resolve3(manifestDir, `${NATIVE_HOST_NAME}.sh`);
+  writeFileSync4(wrapperPath, `#!/bin/bash
 exec "${nodePath}" "${binaryPath}" --native-host
 `);
   chmodSync3(wrapperPath, 493);
@@ -35078,23 +35563,23 @@ function getNodePath() {
 }
 function getDockerManifestPaths() {
   return [
-    resolve2("/etc/chromium/native-messaging-hosts", `${NATIVE_HOST_NAME}.json`),
-    resolve2(homedir2(), ".config/chromium/NativeMessagingHosts", `${NATIVE_HOST_NAME}.json`)
+    resolve3("/etc/chromium/native-messaging-hosts", `${NATIVE_HOST_NAME}.json`),
+    resolve3(homedir2(), ".config/chromium/NativeMessagingHosts", `${NATIVE_HOST_NAME}.json`)
   ];
 }
 function getManifestPath(os) {
   const home = homedir2();
   switch (os) {
     case "darwin":
-      return resolve2(
+      return resolve3(
         home,
         "Library/Application Support/Google/Chrome/NativeMessagingHosts",
         `${NATIVE_HOST_NAME}.json`
       );
     case "linux":
-      return resolve2(home, ".config/google-chrome/NativeMessagingHosts", `${NATIVE_HOST_NAME}.json`);
+      return resolve3(home, ".config/google-chrome/NativeMessagingHosts", `${NATIVE_HOST_NAME}.json`);
     case "win32":
-      return resolve2(
+      return resolve3(
         home,
         "AppData/Local/Google/Chrome/User Data/NativeMessagingHosts",
         `${NATIVE_HOST_NAME}.json`
@@ -35114,9 +35599,9 @@ function setupClaudeDesktopConfig() {
   const configPath = getClaudeDesktopConfigPath();
   console.log(`Config path: ${configPath}`);
   let config2 = {};
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync5(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync6(configPath, "utf-8"));
     } catch {
       console.error(
         `ERROR: Failed to parse ${configPath}. Fix the JSON manually or delete the file.`
@@ -35136,8 +35621,8 @@ function setupClaudeDesktopConfig() {
     env: { PATH: envPath }
   };
   const configDir = dirname3(configPath);
-  mkdirSync4(configDir, { recursive: true });
-  writeFileSync3(configPath, JSON.stringify(config2, null, 2));
+  mkdirSync5(configDir, { recursive: true });
+  writeFileSync4(configPath, JSON.stringify(config2, null, 2));
   console.log(`npx path: ${npxPath}`);
   console.log("\nClaude Desktop config updated successfully!");
   console.log("Please restart Claude Desktop for changes to take effect.");
@@ -35154,13 +35639,13 @@ function getClaudeDesktopConfigPath() {
   const home = homedir2();
   switch (process.platform) {
     case "darwin":
-      return resolve2(home, "Library/Application Support/Claude/claude_desktop_config.json");
+      return resolve3(home, "Library/Application Support/Claude/claude_desktop_config.json");
     case "linux":
-      return resolve2(home, ".config/Claude/claude_desktop_config.json");
+      return resolve3(home, ".config/Claude/claude_desktop_config.json");
     case "win32":
-      return resolve2(home, "AppData/Roaming/Claude/claude_desktop_config.json");
+      return resolve3(home, "AppData/Roaming/Claude/claude_desktop_config.json");
     default:
-      return resolve2(home, ".config/Claude/claude_desktop_config.json");
+      return resolve3(home, ".config/Claude/claude_desktop_config.json");
   }
 }
 
@@ -35202,7 +35687,18 @@ if (args.includes("setup")) {
   const authBearer = authIdx >= 0 ? args[authIdx + 1] : process.env.VIYV_MCP_AUTH_BEARER;
   if (isNativeHostDeployed()) {
     try {
-      syncNativeHostBinary();
+      const decision = syncNativeHostBinaryIfNeeded();
+      if (decision.shouldSync) {
+        process.stderr.write(
+          `[viyv-browser:mcp] Native host binary synced (self=${decision.selfVersion}, was=${decision.deployedVersion ?? "unknown"}, reason=${decision.reason})
+`
+        );
+      } else {
+        process.stderr.write(
+          `[viyv-browser:mcp] Native host sync skipped \u2014 deployed v${decision.deployedVersion} is newer than self v${decision.selfVersion} (preventing downgrade by orphan MCP)
+`
+        );
+      }
     } catch (err) {
       process.stderr.write(
         `[viyv-browser:mcp] WARNING: Failed to update native host binary: ${err.message}