viyv-browser-mcp 0.3.4 → 0.3.6

package/dist/index.js

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { existsSync as existsSync4, readdirSync } from "fs";
-
 // src/native-host/bridge.ts
-import { existsSync } from "fs";
 import { createConnection } from "net";
 
 // ../shared/dist/constants.js
@@ -64,6 +60,12 @@ var RECONNECT = {
   /** Backoff multiplier */
   MULTIPLIER: 2
 };
+var BRIDGE = {
+  /** TCP port for MCP Server ↔ Native Host bridge communication */
+  TCP_PORT: 9224,
+  /** Loopback address for bridge */
+  TCP_HOST: "127.0.0.1"
+};
 var MCP_SERVER = {
   /** Server name for MCP protocol */
   NAME: "viyv-browser",
@@ -149,7 +151,7 @@ function writeMessage(stream, message) {
 // src/native-host/bridge.ts
 var MAX_BUFFER_SIZE = 1e3;
 function startBridge(options) {
-  const { socketPath, onError } = options;
+  const { port = BRIDGE.TCP_PORT, host = BRIDGE.TCP_HOST, onError } = options;
   let socket = null;
   let reconnecting = false;
   let retryCount = 0;
@@ -177,35 +179,31 @@ function startBridge(options) {
     reconnecting = true;
     const POLL_INTERVAL = 2e3;
     function attemptReconnect() {
-      if (existsSync(socketPath)) {
-        process.stderr.write(
-          `[viyv-browser:native-host] Socket found, reconnecting (attempt ${retryCount + 1})
+      retryCount++;
+      process.stderr.write(
+        `[viyv-browser:native-host] Reconnecting to ${host}:${port} (attempt ${retryCount})
 `
-        );
-        reconnecting = false;
-        connectSocket();
-      } else {
-        retryCount++;
-        if (retryCount > 60) {
-          process.stderr.write(
-            "[viyv-browser:native-host] Socket not found after 120s, slowing down polling\n"
-          );
-          setTimeout(attemptReconnect, RECONNECT.MAX_DELAY);
-        } else {
-          setTimeout(attemptReconnect, POLL_INTERVAL);
-        }
-      }
+      );
+      reconnecting = false;
+      connectSocket();
     }
     const delay = retryCount === 0 ? RECONNECT.INITIAL_DELAY : POLL_INTERVAL;
     setTimeout(attemptReconnect, delay);
   }
   function connectSocket() {
-    socket = createConnection(socketPath);
+    socket = createConnection({ port, host });
     socket.on("connect", () => {
-      process.stderr.write(`[viyv-browser:native-host] Connected to MCP server at ${socketPath}
-`);
+      process.stderr.write(
+        `[viyv-browser:native-host] Connected to MCP server at ${host}:${port}
+`
+      );
       retryCount = 0;
       flushBuffer();
+      writeMessage(process.stdout, {
+        type: "bridge_status",
+        connected: true,
+        timestamp: Date.now()
+      });
     });
     let lineBuffer = "";
     socket.on("data", (data) => {
@@ -234,6 +232,11 @@ function startBridge(options) {
     socket.on("close", () => {
       process.stderr.write("[viyv-browser:native-host] Socket closed\n");
       socket = null;
+      writeMessage(process.stdout, {
+        type: "bridge_status",
+        connected: false,
+        timestamp: Date.now()
+      });
       scheduleReconnect();
     });
   }
@@ -283,7 +286,7 @@ function startBridge(options) {
 
 // src/server.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { chmodSync, existsSync as existsSync2, statSync, unlinkSync } from "fs";
+import { existsSync, statSync } from "fs";
 import http from "http";
 import { createConnection as createConnection2, createServer } from "net";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -2250,12 +2253,12 @@ function createConfiguredMcpServer() {
   };
   return server;
 }
-async function startMcpServer(socketPath, agentName, options) {
+async function startMcpServer(agentName, options) {
   if (agentName) {
     setDefaultAgentId(agentName);
   }
-  await evictExistingBridge(socketPath);
-  const socketServer = createSocketServer(socketPath);
+  await evictExistingBridge();
+  const bridgeServer = createBridgeServer();
   if (options?.transport === "sse") {
     const sessions2 = /* @__PURE__ */ new Map();
     const httpServer = http.createServer();
@@ -2277,8 +2280,10 @@ async function startMcpServer(socketPath, agentName, options) {
       process.stderr.write(`[viyv-browser:mcp] SSE server listening on 127.0.0.1:${port}
 `);
     });
-    process.stderr.write(`[viyv-browser:mcp] MCP Server started (SSE), socket: ${socketPath}
-`);
+    process.stderr.write(
+      `[viyv-browser:mcp] MCP Server started (SSE), bridge: ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
+`
+    );
     let shuttingDown = false;
     const shutdown = async () => {
       if (shuttingDown) return;
@@ -2289,9 +2294,8 @@ async function startMcpServer(socketPath, agentName, options) {
       }
       httpServer.close(() => {
       });
-      socketServer.close(() => {
+      bridgeServer.close(() => {
       });
-      cleanupSocket(socketPath);
       process.exit(0);
     };
     process.on("SIGINT", () => {
@@ -2300,9 +2304,6 @@ async function startMcpServer(socketPath, agentName, options) {
     process.on("SIGTERM", () => {
       shutdown();
     });
-    process.on("exit", () => {
-      cleanupSocket(socketPath);
-    });
   } else if (options?.transport === "streamable-http") {
     const sessions2 = /* @__PURE__ */ new Map();
     const SESSION_TTL = 30 * 60 * 1e3;
@@ -2344,7 +2345,7 @@ async function startMcpServer(socketPath, agentName, options) {
       );
     });
     process.stderr.write(
-      `[viyv-browser:mcp] MCP Server started (streamable-http), socket: ${socketPath}
+      `[viyv-browser:mcp] MCP Server started (streamable-http), bridge: ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
 `
     );
     let shuttingDown = false;
@@ -2358,9 +2359,8 @@ async function startMcpServer(socketPath, agentName, options) {
       }
       httpServer.close(() => {
       });
-      socketServer.close(() => {
+      bridgeServer.close(() => {
       });
-      cleanupSocket(socketPath);
       process.exit(0);
     };
     process.on("SIGINT", () => {
@@ -2369,20 +2369,18 @@ async function startMcpServer(socketPath, agentName, options) {
     process.on("SIGTERM", () => {
       shutdown();
     });
-    process.on("exit", () => {
-      cleanupSocket(socketPath);
-    });
   } else {
     const server = createConfiguredMcpServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    process.stderr.write(`[viyv-browser:mcp] MCP Server started (stdio), socket: ${socketPath}
-`);
+    process.stderr.write(
+      `[viyv-browser:mcp] MCP Server started (stdio), bridge: ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
+`
+    );
     process.on("SIGINT", () => process.exit(0));
     process.on("SIGTERM", () => process.exit(0));
     process.on("exit", () => {
-      socketServer.close();
-      cleanupSocket(socketPath);
+      bridgeServer.close();
     });
   }
 }
@@ -2554,14 +2552,13 @@ function parseJsonBody(req) {
     });
   });
 }
-function evictExistingBridge(socketPath) {
-  if (!existsSync2(socketPath)) return Promise.resolve();
+function evictExistingBridge() {
   return new Promise((resolve2) => {
     const timeout = setTimeout(() => {
       tempSocket.destroy();
       resolve2();
     }, 2e3);
-    const tempSocket = createConnection2(socketPath);
+    const tempSocket = createConnection2({ port: BRIDGE.TCP_PORT, host: BRIDGE.TCP_HOST });
     tempSocket.on("connect", () => {
       process.stderr.write("[viyv-browser:mcp] Evicted bridge from previous MCP server\n");
       setTimeout(() => {
@@ -2576,90 +2573,112 @@ function evictExistingBridge(socketPath) {
     });
   });
 }
-function createSocketServer(socketPath) {
-  cleanupSocket(socketPath);
-  const server = createServer((socket) => {
-    if (extensionSocket && !extensionSocket.destroyed) {
-      process.stderr.write("[viyv-browser:mcp] Replacing existing extension connection\n");
-      extensionSocket.destroy();
-    }
-    process.stderr.write("[viyv-browser:mcp] Extension connected via Unix socket\n");
-    extensionSocket = socket;
-    setExtensionConnected(true);
-    const agentId = getDefaultAgentId();
-    createSession(agentId);
-    const initMsg = {
-      id: randomUUID2(),
-      type: "session_init",
-      agentId,
-      protocolVersion: PROTOCOL_VERSION,
-      timestamp: Date.now()
-    };
-    socket.write(`${JSON.stringify(initMsg)}
+function handleBridgeConnection(socket, label) {
+  if (extensionSocket && !extensionSocket.destroyed) {
+    process.stderr.write("[viyv-browser:mcp] Replacing existing extension connection\n");
+    extensionSocket.destroy();
+  }
+  process.stderr.write(`[viyv-browser:mcp] Extension connected via ${label}
 `);
-    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 === "compressed" && typeof parsed.data === "string") {
-            const decompressed = decompressPayload(parsed.data, true);
-            parsed = JSON.parse(decompressed);
-          }
-          handleExtensionMessage(parsed);
-        } catch (error) {
-          process.stderr.write(`[viyv-browser:mcp] Parse error: ${error.message}
+  extensionSocket = socket;
+  setExtensionConnected(true);
+  const agentId = getDefaultAgentId();
+  createSession(agentId);
+  const initMsg = {
+    id: randomUUID2(),
+    type: "session_init",
+    agentId,
+    protocolVersion: PROTOCOL_VERSION,
+    timestamp: Date.now()
+  };
+  socket.write(`${JSON.stringify(initMsg)}
 `);
+  const heartbeatInterval = setInterval(() => {
+    if (socket.destroyed) {
+      clearInterval(heartbeatInterval);
+      return;
+    }
+    socket.write(
+      `${JSON.stringify({
+        id: randomUUID2(),
+        type: "session_heartbeat",
+        agentId,
+        timestamp: Date.now()
+      })}
+`
+    );
+  }, 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 === "compressed" && typeof parsed.data === "string") {
+          const decompressed = decompressPayload(parsed.data, true);
+          parsed = JSON.parse(decompressed);
         }
+        handleExtensionMessage(parsed);
+      } catch (error) {
+        process.stderr.write(`[viyv-browser:mcp] Parse error: ${error.message}
+`);
       }
-    });
-    socket.on("close", () => {
-      process.stderr.write("[viyv-browser:mcp] Extension 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: "Extension disconnected while request was pending"
-          }
-        });
-      }
-    });
-    socket.on("error", (error) => {
-      process.stderr.write(`[viyv-browser:mcp] Socket error: ${error.message}
+    }
+  });
+  socket.on("close", () => {
+    clearInterval(heartbeatInterval);
+    process.stderr.write("[viyv-browser:mcp] Extension 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: "Extension disconnected while request was pending"
+        }
+      });
+    }
+  });
+  socket.on("error", (error) => {
+    process.stderr.write(`[viyv-browser:mcp] Socket error: ${error.message}
 `);
-    });
   });
+}
+function createBridgeServer() {
+  const server = createServer((socket) => handleBridgeConnection(socket, "TCP"));
   server.on("error", (error) => {
     if (error.code === "EADDRINUSE") {
       process.stderr.write(
-        `[viyv-browser:mcp] Socket ${socketPath} already in use, forcing cleanup...
+        `[viyv-browser:mcp] TCP port ${BRIDGE.TCP_PORT} already in use, retrying...
 `
       );
-      cleanupSocket(socketPath);
-      server.listen(socketPath, () => {
-        chmodSync(socketPath, 438);
-        process.stderr.write(`[viyv-browser:mcp] Unix socket listening on ${socketPath} (retry)
-`);
-      });
+      setTimeout(() => {
+        server.listen(BRIDGE.TCP_PORT, BRIDGE.TCP_HOST, () => {
+          process.stderr.write(
+            `[viyv-browser:mcp] TCP bridge listening on ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT} (retry)
+`
+          );
+        });
+      }, 1e3);
     } else {
-      process.stderr.write(`[viyv-browser:mcp] Server error: ${error.message} (${error.code})
-`);
+      process.stderr.write(
+        `[viyv-browser:mcp] TCP bridge error: ${error.message} (${error.code})
+`
+      );
     }
   });
-  server.listen(socketPath, () => {
-    chmodSync(socketPath, 438);
-    process.stderr.write(`[viyv-browser:mcp] Unix socket listening on ${socketPath}
-`);
+  server.listen(BRIDGE.TCP_PORT, BRIDGE.TCP_HOST, () => {
+    process.stderr.write(
+      `[viyv-browser:mcp] TCP bridge listening on ${BRIDGE.TCP_HOST}:${BRIDGE.TCP_PORT}
+`
+    );
   });
   return server;
 }
@@ -2742,7 +2761,7 @@ async function callExtensionTool(tool, input) {
     if (paths) {
       for (const p of paths) {
         try {
-          if (!existsSync2(p) || !statSync(p).isFile()) {
+          if (!existsSync(p) || !statSync(p).isFile()) {
             return {
               content: [
                 {
@@ -2928,36 +2947,10 @@ async function handleSwitchBrowser() {
     }, SWITCH_TIMEOUT);
   });
 }
-function cleanupSocket(socketPath) {
-  if (!existsSync2(socketPath)) return;
-  try {
-    unlinkSync(socketPath);
-  } catch (error) {
-    const err = error;
-    if (err.code === "EPERM" || err.code === "EACCES") {
-      process.stderr.write(
-        `[viyv-browser:mcp] Cannot remove stale socket (${err.code}), retrying with chmod...
-`
-      );
-      try {
-        chmodSync(socketPath, 438);
-        unlinkSync(socketPath);
-      } catch (retryError) {
-        process.stderr.write(
-          `[viyv-browser:mcp] Failed to remove socket after chmod: ${retryError.message}
-`
-        );
-      }
-    } else if (err.code !== "ENOENT") {
-      process.stderr.write(`[viyv-browser:mcp] Socket cleanup error: ${err.message}
-`);
-    }
-  }
-}
 
 // src/setup.ts
 import { execSync } from "child_process";
-import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { chmodSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
 import { homedir, platform } from "os";
 import { dirname, resolve } from "path";
 function runSetup(options = {}) {
@@ -2967,7 +2960,7 @@ function runSetup(options = {}) {
   console.log("================================================");
   console.log(`Platform: ${os}`);
   console.log(`Binary: ${binaryPath}`);
-  if (!existsSync3(binaryPath)) {
+  if (!existsSync2(binaryPath)) {
     console.error(`WARNING: Binary not found at ${binaryPath}`);
     console.error("The Native Messaging Host may not work until the binary is available.");
   }
@@ -2991,7 +2984,7 @@ function runSetup(options = {}) {
   console.log(`Manifest path: ${manifestPath}`);
   mkdirSync(manifestDir, { recursive: true });
   writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  chmodSync2(manifestPath, 420);
+  chmodSync(manifestPath, 420);
   console.log("\nNative Messaging Host registered successfully!");
   console.log("\nNext steps:");
   console.log("1. Start the MCP Server: node <path>/dist/index.js");
@@ -3023,7 +3016,7 @@ function createNativeHostWrapper(os, binaryPath) {
   writeFileSync(wrapperPath, `#!/bin/bash
 exec "${nodePath}" "${binaryPath}" --native-host
 `);
-  chmodSync2(wrapperPath, 493);
+  chmodSync(wrapperPath, 493);
   return wrapperPath;
 }
 function getNodePath() {
@@ -3062,44 +3055,14 @@ if (args.includes("setup")) {
   const extensionId = extensionIdIdx >= 0 ? args[extensionIdIdx + 1] : void 0;
   runSetup({ extensionId });
 } else if (args.includes("--native-host")) {
-  let waitForSocket = function() {
-    const start = Date.now();
-    function poll() {
-      const socketPath = findSocketPath();
-      if (socketPath) {
-        process.stderr.write(`[viyv-browser:native-host] Found socket at ${socketPath}
-`);
-        startBridge({
-          socketPath,
-          onError: (error) => {
-            process.stderr.write(`[viyv-browser:native-host] Error: ${error.message}
+  process.stderr.write("[viyv-browser:native-host] Starting bridge (TCP mode)\n");
+  startBridge({
+    onError: (error) => {
+      process.stderr.write(`[viyv-browser:native-host] Error: ${error.message}
 `);
-          }
-        });
-        return;
-      }
-      if (Date.now() - start > MAX_WAIT) {
-        process.stderr.write(
-          `[viyv-browser:native-host] MCP server socket not found after ${MAX_WAIT / 1e3}s. Exiting.
-`
-        );
-        process.exit(1);
-      }
-      process.stderr.write(
-        `[viyv-browser:native-host] Waiting for MCP server socket (${SOCKET_PATH})...
-`
-      );
-      setTimeout(poll, POLL_INTERVAL);
     }
-    poll();
-  };
-  waitForSocket2 = waitForSocket;
-  const SOCKET_PATH = "/tmp/viyv-browser.sock";
-  const POLL_INTERVAL = 2e3;
-  const MAX_WAIT = 12e4;
-  waitForSocket();
+  });
 } else {
-  const socketPath = "/tmp/viyv-browser.sock";
   const agentNameIdx = args.indexOf("--agent-name");
   const agentName = agentNameIdx >= 0 ? args[agentNameIdx + 1] : void 0;
   const transportIdx = args.indexOf("--transport");
@@ -3113,20 +3076,6 @@ if (args.includes("setup")) {
   }
   const portIdx = args.indexOf("--port");
   const port = portIdx >= 0 ? Number(args[portIdx + 1]) : void 0;
-  startMcpServer(socketPath, agentName, { transport: transportMode, port });
-}
-var waitForSocket2;
-function findSocketPath() {
-  const envSocket = process.env.VIYV_BROWSER_SOCKET;
-  if (envSocket) return envSocket;
-  const fixedPath = "/tmp/viyv-browser.sock";
-  if (existsSync4(fixedPath)) return fixedPath;
-  try {
-    const tmpFiles = readdirSync("/tmp");
-    const socketFile = tmpFiles.find((f) => f.startsWith("viyv-browser-") && f.endsWith(".sock"));
-    if (socketFile) return `/tmp/${socketFile}`;
-  } catch {
-  }
-  return null;
+  startMcpServer(agentName, { transport: transportMode, port });
 }
 //# sourceMappingURL=index.js.map