viyv-browser-mcp 0.5.0 → 0.5.4

package/dist/index.js

@@ -80,6 +80,9 @@ var MCP_SERVER = {
   SOCKET_PATH_TEMPLATE: "/tmp/viyv-browser-{pid}.sock"
 };
 
+// src/native-host/bridge-relay.ts
+import { createConnection } from "net";
+
 // src/native-host/compression.ts
 import { gunzipSync, gzipSync } from "zlib";
 var CHUNK_SIZE = 768 * 1024;
@@ -144,16 +147,127 @@ function writeMessage(stream, message) {
   const encoded = encodeMessage(message);
   stream.write(encoded);
 }
+function decompressIfNeeded(message) {
+  if (message.type === "compressed" && typeof message.data === "string") {
+    return JSON.parse(decompressPayload(message.data, true));
+  }
+  return message;
+}
+function createTcpLineReader(onMessage, onError) {
+  let lineBuffer = "";
+  return (data) => {
+    lineBuffer += data.toString("utf-8");
+    const lines = lineBuffer.split("\n");
+    lineBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        const message = decompressIfNeeded(JSON.parse(line));
+        onMessage(message);
+      } catch (error) {
+        onError?.(error);
+      }
+    }
+  };
+}
 
-// src/native-host/bridge.ts
+// src/native-host/bridge-relay.ts
 var LOG_PREFIX = "[viyv-browser:native-host]";
+var RELAY_MAX_RETRIES = 10;
+function startRelayMode(port, host, onError) {
+  let retryCount = 0;
+  let relaySocket = null;
+  createMessageReader(
+    process.stdin,
+    (raw) => {
+      if (!raw || typeof raw !== "object") return;
+      const message = decompressIfNeeded(raw);
+      if (relaySocket && !relaySocket.destroyed) {
+        relaySocket.write(`${JSON.stringify(message)}
+`);
+      }
+    },
+    onError
+  );
+  function connect() {
+    const socket = createConnection({ port, host });
+    socket.on("connect", () => {
+      retryCount = 0;
+      relaySocket = socket;
+      process.stderr.write(`${LOG_PREFIX} Relay connected to bridge at ${host}:${port}
+`);
+      socket.write(`${JSON.stringify({ type: "chrome_relay_init", timestamp: Date.now() })}
+`);
+      const processData = createTcpLineReader((message) => {
+        if (message.type === "chrome_relay_ack") {
+          process.stderr.write(`${LOG_PREFIX} Relay assigned chromeId: ${message.chromeId}
+`);
+          return;
+        }
+        writeMessage(process.stdout, message);
+      }, onError);
+      socket.on("data", processData);
+    });
+    socket.on("error", (error) => {
+      process.stderr.write(`${LOG_PREFIX} Relay connection error: ${error.message}
+`);
+    });
+    socket.on("close", () => {
+      relaySocket = null;
+      retryCount++;
+      if (retryCount > RELAY_MAX_RETRIES) {
+        process.stderr.write(
+          `${LOG_PREFIX} Relay max retries (${RELAY_MAX_RETRIES}) reached. Exiting.
+`
+        );
+        process.exit(0);
+      }
+      const delay = Math.min(
+        RECONNECT.INITIAL_DELAY * RECONNECT.MULTIPLIER ** (retryCount - 1),
+        RECONNECT.MAX_DELAY
+      );
+      process.stderr.write(
+        `${LOG_PREFIX} Relay reconnecting in ${delay}ms (attempt ${retryCount}/${RELAY_MAX_RETRIES})
+`
+      );
+      setTimeout(connect, delay);
+    });
+  }
+  connect();
+  process.stdin.on("end", () => {
+    process.stderr.write(`${LOG_PREFIX} Relay: stdin closed, shutting down
+`);
+    relaySocket?.destroy();
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    relaySocket?.destroy();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    relaySocket?.destroy();
+    process.exit(0);
+  });
+}
+
+// src/native-host/bridge.ts
+var LOG_PREFIX2 = "[viyv-browser:native-host]";
 var ROUTING_CLEANUP_INTERVAL = 3e4;
 function startBridge(options) {
   const { port = BRIDGE.TCP_PORT, host = BRIDGE.TCP_HOST, onError } = options;
   const mcpConnections = /* @__PURE__ */ new Map();
   const requestOrigin = /* @__PURE__ */ new Map();
   const agentToConn = /* @__PURE__ */ new Map();
+  const chromeConnections = /* @__PURE__ */ new Map();
+  const agentToChrome = /* @__PURE__ */ new Map();
+  let nextChromeIndex = 0;
   let server = null;
+  const primaryChromeId = `chrome-${nextChromeIndex++}`;
+  chromeConnections.set(primaryChromeId, {
+    chromeId: primaryChromeId,
+    send: (msg) => writeMessage(process.stdout, msg),
+    agentIds: /* @__PURE__ */ new Set()
+  });
   const cleanupTimer2 = setInterval(() => {
     const now = Date.now();
     for (const [id, entry] of requestOrigin) {
@@ -163,12 +277,11 @@ function startBridge(options) {
     }
   }, ROUTING_CLEANUP_INTERVAL);
   cleanupTimer2.unref();
-  function notifyChromeConnected(connected) {
-    writeMessage(process.stdout, {
-      type: "bridge_status",
-      connected,
-      timestamp: Date.now()
-    });
+  function getChromeProfilesList() {
+    return Array.from(chromeConnections.values()).map((c) => ({
+      chromeId: c.chromeId,
+      connected: true
+    }));
   }
   function sendToMcp(connId, message) {
     const conn = mcpConnections.get(connId);
@@ -180,53 +293,110 @@ function startBridge(options) {
       onError?.(error);
     }
   }
-  function sendToChrome(message) {
-    writeMessage(process.stdout, message);
+  function sendToChrome(chromeId, message) {
+    const chrome = chromeConnections.get(chromeId);
+    if (chrome) {
+      chrome.send(message);
+    } else {
+      process.stderr.write(
+        `${LOG_PREFIX2} WARNING: chromeId '${chromeId}' not found, falling back to primary
+`
+      );
+      chromeConnections.get(primaryChromeId)?.send(message);
+    }
+  }
+  function getChromeForAgent(agentId) {
+    return agentToChrome.get(agentId) ?? primaryChromeId;
   }
   function connIdForAgent(agentId) {
     return agentToConn.get(agentId);
   }
+  function cleanupAgent(agentId, connId) {
+    agentToConn.delete(agentId);
+    mcpConnections.get(connId)?.agentIds.delete(agentId);
+    const chromeId = agentToChrome.get(agentId);
+    if (chromeId) {
+      chromeConnections.get(chromeId)?.agentIds.delete(agentId);
+    }
+    agentToChrome.delete(agentId);
+  }
+  function notifyChromeConnected(connected) {
+    const msg = { type: "bridge_status", connected, timestamp: Date.now() };
+    for (const chrome of chromeConnections.values()) {
+      chrome.send(msg);
+    }
+  }
+  function broadcastChromeProfiles() {
+    const msg = {
+      type: "bridge_status",
+      connected: true,
+      chromeProfiles: getChromeProfilesList(),
+      timestamp: Date.now()
+    };
+    for (const [connId] of mcpConnections) {
+      sendToMcp(connId, msg);
+    }
+  }
   function handleMcpMessage(connId, message) {
     const type = message.type;
     if (!type) return;
+    const agentId = message.agentId;
     if (type === "tool_call") {
       const id = message.id;
       if (id) {
         requestOrigin.set(id, { connId, timestamp: Date.now() });
       }
-      sendToChrome(message);
+      const perCallProfile = message.chromeProfile;
+      let targetChrome;
+      if (perCallProfile && chromeConnections.has(perCallProfile)) {
+        targetChrome = perCallProfile;
+      } else {
+        if (perCallProfile && !chromeConnections.has(perCallProfile)) {
+          process.stderr.write(
+            `${LOG_PREFIX2} WARNING: chromeProfile '${perCallProfile}' not found, using agent default
+`
+          );
+        }
+        targetChrome = agentId ? getChromeForAgent(agentId) : primaryChromeId;
+      }
+      sendToChrome(targetChrome, message);
     } else if (type === "session_init") {
-      const agentId = message.agentId;
       if (agentId) {
         const existingConnId = agentToConn.get(agentId);
         if (existingConnId && existingConnId !== connId) {
           process.stderr.write(
-            `${LOG_PREFIX} WARNING: agentId '${agentId}' re-registered from conn ${existingConnId} \u2192 ${connId}
+            `${LOG_PREFIX2} WARNING: agentId '${agentId}' re-registered from conn ${existingConnId} \u2192 ${connId}
 `
           );
-          const oldConn = mcpConnections.get(existingConnId);
-          if (oldConn) oldConn.agentIds.delete(agentId);
+          mcpConnections.get(existingConnId)?.agentIds.delete(agentId);
         }
         agentToConn.set(agentId, connId);
-        const conn = mcpConnections.get(connId);
-        if (conn) conn.agentIds.add(agentId);
+        mcpConnections.get(connId)?.agentIds.add(agentId);
+        const chromeProfile = message.chromeProfile;
+        const resolvedChrome = chromeProfile && chromeConnections.has(chromeProfile) ? chromeProfile : primaryChromeId;
+        if (chromeProfile && !chromeConnections.has(chromeProfile)) {
+          process.stderr.write(
+            `${LOG_PREFIX2} WARNING: chromeProfile '${chromeProfile}' not found, using primary
+`
+          );
+        }
+        agentToChrome.set(agentId, resolvedChrome);
+        chromeConnections.get(resolvedChrome)?.agentIds.add(agentId);
       }
-      sendToChrome(message);
+      sendToChrome(agentId ? getChromeForAgent(agentId) : primaryChromeId, message);
     } else if (type === "session_close") {
-      const agentId = message.agentId;
       if (agentId && agentToConn.get(agentId) === connId) {
-        agentToConn.delete(agentId);
-        const conn = mcpConnections.get(connId);
-        if (conn) conn.agentIds.delete(agentId);
+        const targetChrome = getChromeForAgent(agentId);
+        cleanupAgent(agentId, connId);
+        sendToChrome(targetChrome, message);
       }
-      sendToChrome(message);
     } else if (type === "session_heartbeat" || type === "session_recovery") {
-      sendToChrome(message);
+      sendToChrome(agentId ? getChromeForAgent(agentId) : primaryChromeId, message);
     } else if (type === "bridge_status" || type === "bridge_closing") {
-      process.stderr.write(`${LOG_PREFIX} Ignoring ${type} from MCP Server ${connId}
+      process.stderr.write(`${LOG_PREFIX2} Ignoring ${type} from MCP Server ${connId}
 `);
     } else {
-      sendToChrome(message);
+      sendToChrome(agentId ? getChromeForAgent(agentId) : primaryChromeId, message);
     }
   }
   function handleChromeMessage(message) {
@@ -241,7 +411,7 @@ function startBridge(options) {
           sendToMcp(entry.connId, message);
         } else {
           process.stderr.write(
-            `${LOG_PREFIX} No routing entry for tool_result id=${id}, dropping
+            `${LOG_PREFIX2} No routing entry for tool_result id=${id}, dropping
 `
           );
         }
@@ -254,7 +424,7 @@ function startBridge(options) {
           sendToMcp(entry.connId, message);
         } else {
           process.stderr.write(
-            `${LOG_PREFIX} No routing entry for chunk requestId=${requestId}, dropping
+            `${LOG_PREFIX2} No routing entry for chunk requestId=${requestId}, dropping
 `
           );
         }
@@ -264,9 +434,7 @@ function startBridge(options) {
       if (agentId) {
         const connId = connIdForAgent(agentId);
         if (connId) {
-          agentToConn.delete(agentId);
-          const conn = mcpConnections.get(connId);
-          if (conn) conn.agentIds.delete(agentId);
+          cleanupAgent(agentId, connId);
           sendToMcp(connId, message);
         }
       }
@@ -274,38 +442,133 @@ function startBridge(options) {
       const agentId = message.agentId;
       if (agentId) {
         const connId = connIdForAgent(agentId);
-        if (connId) {
-          sendToMcp(connId, message);
-        }
+        if (connId) sendToMcp(connId, message);
       }
     } else if (type === "browser_event") {
       const agentId = message.agentId;
       if (agentId) {
         const connId = connIdForAgent(agentId);
-        if (connId) {
-          sendToMcp(connId, message);
-        }
+        if (connId) sendToMcp(connId, message);
       }
     } else {
-      process.stderr.write(`${LOG_PREFIX} Unknown message type from Chrome: ${type}, dropping
+      process.stderr.write(`${LOG_PREFIX2} Unknown message type from Chrome: ${type}, dropping
 `);
     }
   }
-  function handleMcpConnection(socket) {
+  function setupRelayConnection(socket) {
+    const chromeId = `chrome-${nextChromeIndex++}`;
+    const chrome = {
+      chromeId,
+      send: (msg) => {
+        if (!socket.destroyed) {
+          try {
+            socket.write(`${JSON.stringify(msg)}
+`);
+          } catch {
+          }
+        }
+      },
+      agentIds: /* @__PURE__ */ new Set()
+    };
+    chromeConnections.set(chromeId, chrome);
+    process.stderr.write(
+      `${LOG_PREFIX2} Chrome relay connected: ${chromeId} (total chromes: ${chromeConnections.size})
+`
+    );
+    socket.write(
+      `${JSON.stringify({ type: "chrome_relay_ack", chromeId, timestamp: Date.now() })}
+`
+    );
+    if (mcpConnections.size > 0) {
+      chrome.send({ type: "bridge_status", connected: true, timestamp: Date.now() });
+    }
+    broadcastChromeProfiles();
+    const processData = createTcpLineReader((message) => handleChromeMessage(message), onError);
+    socket.on("data", processData);
+    socket.on("error", (error) => {
+      process.stderr.write(`${LOG_PREFIX2} Relay socket error (${chromeId}): ${error.message}
+`);
+    });
+    socket.on("close", () => {
+      process.stderr.write(
+        `${LOG_PREFIX2} Chrome relay disconnected: ${chromeId} (remaining chromes: ${chromeConnections.size - 1})
+`
+      );
+      for (const agentId of [...chrome.agentIds]) {
+        const connId = connIdForAgent(agentId);
+        if (connId) {
+          sendToMcp(connId, {
+            id: randomUUID(),
+            type: "session_close",
+            agentId,
+            timestamp: Date.now()
+          });
+          cleanupAgent(agentId, connId);
+        } else {
+          agentToChrome.delete(agentId);
+        }
+      }
+      chromeConnections.delete(chromeId);
+      broadcastChromeProfiles();
+    });
+  }
+  function handleTcpConnection(socket) {
+    let lineBuffer = "";
+    let identified = false;
+    const identifyTimeout = setTimeout(() => {
+      if (!identified) {
+        identified = true;
+        socket.removeListener("data", onData);
+        handleMcpConnection(socket, lineBuffer);
+      }
+    }, 5e3);
+    const onData = (data) => {
+      if (identified) return;
+      lineBuffer += data.toString("utf-8");
+      const newlineIdx = lineBuffer.indexOf("\n");
+      if (newlineIdx === -1) return;
+      identified = true;
+      clearTimeout(identifyTimeout);
+      socket.removeListener("data", onData);
+      const firstLine = lineBuffer.substring(0, newlineIdx);
+      const remaining = lineBuffer.substring(newlineIdx + 1);
+      try {
+        const firstMsg = JSON.parse(firstLine);
+        if (firstMsg.type === "chrome_relay_init") {
+          setupRelayConnection(socket);
+          if (remaining) {
+            socket.emit("data", Buffer.from(remaining, "utf-8"));
+          }
+        } else {
+          handleMcpConnection(socket, lineBuffer);
+        }
+      } catch {
+        handleMcpConnection(socket, lineBuffer);
+      }
+    };
+    socket.on("data", onData);
+    socket.on("error", () => {
+      clearTimeout(identifyTimeout);
+    });
+    socket.on("close", () => {
+      clearTimeout(identifyTimeout);
+    });
+  }
+  function handleMcpConnection(socket, initialData) {
     if (mcpConnections.size >= BRIDGE.MAX_CONNECTIONS) {
       process.stderr.write(
-        `${LOG_PREFIX} Max connections (${BRIDGE.MAX_CONNECTIONS}) reached, rejecting
+        `${LOG_PREFIX2} Max connections (${BRIDGE.MAX_CONNECTIONS}) reached, rejecting
 `
       );
       socket.destroy();
       return;
     }
     const connId = randomUUID();
-    const conn = { socket, lineBuffer: "", agentIds: /* @__PURE__ */ new Set() };
+    const conn = { socket, agentIds: /* @__PURE__ */ new Set() };
     const wasEmpty = mcpConnections.size === 0;
     mcpConnections.set(connId, conn);
     process.stderr.write(
-      `${LOG_PREFIX} MCP Server connected: ${connId} (total: ${mcpConnections.size})
+      `${LOG_PREFIX2} MCP Server connected: ${connId} (total: ${mcpConnections.size})
 `
     );
     socket.setKeepAlive(true, 3e4);
@@ -315,44 +578,33 @@ function startBridge(options) {
     sendToMcp(connId, {
       type: "bridge_status",
       connected: true,
+      chromeProfiles: getChromeProfilesList(),
       timestamp: Date.now()
     });
-    socket.on("data", (data) => {
-      conn.lineBuffer += data.toString("utf-8");
-      const lines = conn.lineBuffer.split("\n");
-      conn.lineBuffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line) continue;
-        try {
-          let message = JSON.parse(line);
-          if (message.type === "compressed" && typeof message.data === "string") {
-            const decompressed = decompressPayload(message.data, true);
-            message = JSON.parse(decompressed);
-          }
-          handleMcpMessage(connId, message);
-        } catch (error) {
-          onError?.(error);
-        }
-      }
-    });
+    const processData = createTcpLineReader((message) => handleMcpMessage(connId, message), onError);
+    socket.on("data", processData);
+    if (initialData) {
+      processData(Buffer.from(initialData, "utf-8"));
+    }
     socket.on("error", (error) => {
-      process.stderr.write(`${LOG_PREFIX} MCP Server socket error (${connId}): ${error.message}
+      process.stderr.write(`${LOG_PREFIX2} MCP Server socket error (${connId}): ${error.message}
 `);
     });
     socket.on("close", () => {
       process.stderr.write(
-        `${LOG_PREFIX} MCP Server disconnected: ${connId} (remaining: ${mcpConnections.size - 1})
+        `${LOG_PREFIX2} MCP Server disconnected: ${connId} (remaining: ${mcpConnections.size - 1})
 `
       );
-      for (const agentId of conn.agentIds) {
+      for (const agentId of [...conn.agentIds]) {
         if (agentToConn.get(agentId) === connId) {
-          agentToConn.delete(agentId);
-          sendToChrome({
+          const targetChrome = getChromeForAgent(agentId);
+          sendToChrome(targetChrome, {
             id: randomUUID(),
             type: "session_close",
             agentId,
             timestamp: Date.now()
           });
+          cleanupAgent(agentId, connId);
         }
       }
       for (const [id, entry] of requestOrigin) {
@@ -366,74 +618,66 @@ function startBridge(options) {
       }
     });
   }
-  createMessageReader(
-    process.stdin,
-    (raw) => {
-      if (!raw || typeof raw !== "object") return;
-      let message = raw;
-      if (message.type === "compressed" && typeof message.data === "string") {
-        try {
-          const decompressed = decompressPayload(message.data, true);
-          message = JSON.parse(decompressed);
-        } catch (error) {
-          onError?.(error);
-          return;
-        }
-      }
-      handleChromeMessage(message);
-    },
-    onError
-  );
-  server = createServer((socket) => handleMcpConnection(socket));
+  server = createServer((socket) => handleTcpConnection(socket));
   server.on("error", (error) => {
     if (error.code === "EADDRINUSE") {
-      process.stderr.write(
-        `${LOG_PREFIX} TCP port ${port} already in use. Another Native Host may be running.
-`
-      );
-      process.exit(1);
+      process.stderr.write(`${LOG_PREFIX2} Port ${port} in use. Starting relay mode.
+`);
+      clearInterval(cleanupTimer2);
+      startRelayMode(port, host, onError);
     } else {
-      process.stderr.write(`${LOG_PREFIX} TCP server error: ${error.message} (${error.code})
+      process.stderr.write(`${LOG_PREFIX2} TCP server error: ${error.message} (${error.code})
 `);
     }
   });
   server.listen(port, host, () => {
-    process.stderr.write(`${LOG_PREFIX} TCP server listening on ${host}:${port}
+    process.stderr.write(`${LOG_PREFIX2} TCP server listening on ${host}:${port}
 `);
+    createMessageReader(
+      process.stdin,
+      (raw) => {
+        if (!raw || typeof raw !== "object") return;
+        const message = decompressIfNeeded(raw);
+        handleChromeMessage(message);
+      },
+      onError
+    );
     notifyChromeConnected(false);
-  });
-  function shutdown() {
-    const closingMsg = JSON.stringify({ type: "bridge_closing", timestamp: Date.now() });
-    for (const [, conn] of mcpConnections) {
-      try {
-        conn.socket.write(`${closingMsg}
+    function shutdown() {
+      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) {
+        conn.socket.destroy();
+      }
+      mcpConnections.clear();
+      agentToConn.clear();
+      agentToChrome.clear();
+      chromeConnections.clear();
+      requestOrigin.clear();
+      clearInterval(cleanupTimer2);
+      server?.close();
+      server = null;
     }
-    for (const [, conn] of mcpConnections) {
-      conn.socket.destroy();
-    }
-    mcpConnections.clear();
-    agentToConn.clear();
-    requestOrigin.clear();
-    clearInterval(cleanupTimer2);
-    server?.close();
-    server = null;
-  }
-  process.on("SIGINT", () => {
-    shutdown();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    shutdown();
-    process.exit(0);
-  });
-  process.stdin.on("end", () => {
-    process.stderr.write(`${LOG_PREFIX} stdin closed, shutting down
+    process.on("SIGINT", () => {
+      shutdown();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      shutdown();
+      process.exit(0);
+    });
+    process.stdin.on("end", () => {
+      process.stderr.write(`${LOG_PREFIX2} stdin closed, shutting down
 `);
-    shutdown();
-    process.exit(0);
+      shutdown();
+      process.exit(0);
+    });
   });
 }
 
@@ -441,7 +685,7 @@ function startBridge(options) {
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync, statSync } from "fs";
 import http from "http";
-import { createConnection } from "net";
+import { createConnection as createConnection2 } from "net";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -554,6 +798,7 @@ function processEvent(event) {
 // src/health.ts
 var extensionConnected = false;
 var lastHeartbeat = null;
+var chromeProfiles = [];
 function setExtensionConnected(connected) {
   extensionConnected = connected;
   if (connected) lastHeartbeat = Date.now();
@@ -561,6 +806,9 @@ function setExtensionConnected(connected) {
 function recordHeartbeat() {
   lastHeartbeat = Date.now();
 }
+function setChromeProfiles(profiles) {
+  chromeProfiles = profiles;
+}
 var HEARTBEAT_STALENESS_MS = 6e4;
 function isExtensionConnected() {
   if (!extensionConnected) return false;
@@ -574,7 +822,8 @@ function getHealthStatus() {
     extensionConnected,
     lastHeartbeat,
     uptime: process.uptime(),
-    memoryUsage: process.memoryUsage().heapUsed
+    memoryUsage: process.memoryUsage().heapUsed,
+    chromeProfiles
   };
 }
 
@@ -790,6 +1039,38 @@ Returns details of HTTP requests and responses including URL, method,
 status code, headers, and timing information. Supports filtering
 by URL pattern or resource type.`;
 
+// src/tools/sheets/descriptions.ts
+var SHEETS_READ_DESCRIPTION = `Read data from the active Google Sheets spreadsheet.
+
+Uses the gviz/tq endpoint with session cookies \u2014 works with private sheets without OAuth.
+Supports range selection, tq query language for filtering/aggregation, and row limits.
+
+tq query examples:
+- "SELECT A, B WHERE C > 100" \u2014 filter rows
+- "SELECT A, SUM(B) GROUP BY A" \u2014 aggregate
+- "SELECT * ORDER BY C DESC LIMIT 5" \u2014 sort and limit
+
+Set formulas=true to read raw formulas (e.g., =IMAGE(), =HYPERLINK()) instead of computed values.
+Formula mode reads cell-by-cell via the formula bar, limited to 200 cells.
+The tab must be on a Google Sheets page (docs.google.com/spreadsheets/).`;
+var SHEETS_WRITE_DESCRIPTION = `Write data to the active Google Sheets spreadsheet.
+
+For single cell: navigates to the cell via Name Box and types the value.
+For multiple cells: converts 2D array to TSV, copies to clipboard via Offscreen Document, then pastes with Ctrl+V. Sheets auto-expands TSV into multiple cells.
+
+Provide either "value" (single cell string) or "values" (2D array), not both.
+The tab must be on a Google Sheets page.`;
+var SHEETS_INFO_DESCRIPTION = `Get metadata about the active Google Sheets spreadsheet.
+
+Returns spreadsheet ID, document title, sheet list (name, index, row/col counts, active status), active cell reference, and URL.
+Uses DOM inspection and gviz/tq queries for sheet dimensions.
+The tab must be on a Google Sheets page.`;
+var SHEETS_NAVIGATE_DESCRIPTION = `Navigate within the active Google Sheets spreadsheet.
+
+Jump to a specific cell (e.g., "A1", "Z100") via the Name Box, or switch to a different sheet tab by name.
+Both cell and sheet can be specified together.
+The tab must be on a Google Sheets page.`;
+
 // src/tools/semantic/sm-add-action.ts
 var SM_ADD_ACTION_DESCRIPTION = `Define a semantic action (step sequence) for a registered page.
 
@@ -1284,6 +1565,7 @@ across multiple pages. Loop steps support cartesian product iteration over varia
 
 Parameters:
 - label: scenario name (e.g., "Price Table Collection")
+- start_url: the URL to open when running this scenario (required)
 - description: optional LLM-facing description
 - params: global parameter definitions (available as {{param_name}} templates)
 - steps: ordered step sequence
@@ -1360,6 +1642,7 @@ Supports partial updates - only provide fields you want to change.
 Parameters:
 - scenario_id: the scenario to update
 - label: new name
+- start_url: new starting URL
 - description: new description
 - params: new parameter definitions
 - steps: new step sequence
@@ -1926,7 +2209,7 @@ var smAddActionTool = {
     ).optional().describe("Parameter definitions"),
     steps: z.array(
       z.object({
-        type: z.enum(["click", "type", "select", "wait", "scroll", "key", "navigate", "file_upload"]).describe("Step type"),
+        type: z.enum(["click", "type", "select", "wait", "scroll", "key", "navigate", "file_upload", "script"]).describe("Step type"),
         target_id: z.string().optional().describe("Target to act on"),
         params: z.object({
           text: z.string().optional(),
@@ -1939,7 +2222,7 @@ var smAddActionTool = {
           file_paths: z.array(z.string()).optional().describe("File paths for file_upload step")
         }).optional().describe("Step parameters"),
         pre_wait: z.object({
-          strategy: z.enum(["selector", "navigation", "time"]),
+          strategy: z.enum(["selector", "navigation", "time", "network_idle"]),
           selector: z.string().optional(),
           timeout_ms: z.coerce.number().default(5e3)
         }).optional().describe("Pre-step wait rule"),
@@ -2079,7 +2362,7 @@ var scenarioStepSchema = z.lazy(
     z.object({
       type: z.literal("wait"),
       label: z.string().optional(),
-      strategy: z.enum(["time", "selector", "navigation"]),
+      strategy: z.enum(["time", "selector", "navigation", "network_idle"]),
       selector: z.string().optional(),
       timeout_ms: z.coerce.number()
     })
@@ -2090,6 +2373,7 @@ var smScenarioCreateTool = {
   description: SM_SCENARIO_CREATE_DESCRIPTION,
   inputSchema: z.object({
     label: z.string().describe("Scenario name"),
+    start_url: z.string().url().describe("Starting URL to open when running this scenario"),
     description: z.string().optional().describe("LLM-facing description"),
     params: z.array(
       z.object({
@@ -2112,6 +2396,7 @@ var smScenarioUpdateTool = {
   inputSchema: z.object({
     scenario_id: z.string().describe("Scenario ID to update"),
     label: z.string().optional(),
+    start_url: z.string().url().optional().describe("Starting URL to open when running this scenario"),
     description: z.string().optional(),
     params: z.array(
       z.object({
@@ -2325,6 +2610,47 @@ var smCustomViewGetTool = {
     include_data: z.boolean().optional().describe("Include resolved data in response (default: false)")
   })
 };
+var sheetsReadTool = {
+  name: "sheets_read",
+  description: SHEETS_READ_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID of the Google Sheets page"),
+    range: z.string().optional().describe('Cell range (e.g., "A1:D10", "Sheet2!B:B"). Omit for all data.'),
+    query: z.string().optional().describe('gviz tq query (e.g., "SELECT A,B WHERE C > 100 ORDER BY A")'),
+    headers: z.coerce.number().min(0).max(10).optional().describe("Number of header rows (default: 1)"),
+    sheet: z.string().optional().describe("Sheet name (omit for active sheet)"),
+    max_rows: z.coerce.number().min(1).max(1e4).optional().describe("Max rows to return (default: 500)"),
+    formulas: z.boolean().optional().describe(
+      'Read cell formulas instead of computed values (default: false). Requires "range". Reads cell-by-cell via formula bar, limited to 200 cells. Use for =IMAGE(), =HYPERLINK(), etc.'
+    )
+  })
+};
+var sheetsWriteTool = {
+  name: "sheets_write",
+  description: SHEETS_WRITE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID of the Google Sheets page"),
+    cell: z.string().describe('Target cell reference (e.g., "A1", "Sheet2!B5")'),
+    value: z.string().optional().describe("Single cell value (exclusive with values)"),
+    values: z.array(z.array(z.string())).optional().describe("2D array of values (exclusive with value)")
+  })
+};
+var sheetsInfoTool = {
+  name: "sheets_info",
+  description: SHEETS_INFO_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID of the Google Sheets page")
+  })
+};
+var sheetsNavigateTool = {
+  name: "sheets_navigate",
+  description: SHEETS_NAVIGATE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID of the Google Sheets page"),
+    cell: z.string().optional().describe('Cell to jump to (e.g., "A1", "Z100")'),
+    sheet: z.string().optional().describe("Sheet name to switch to")
+  })
+};
 var allTools = [
   // Core (16)
   navigateTool,
@@ -2409,12 +2735,18 @@ var allTools = [
   smCustomViewUpdateTool,
   smCustomViewDeleteTool,
   smCustomViewListTool,
-  smCustomViewGetTool
+  smCustomViewGetTool,
+  // Google Sheets (4)
+  sheetsReadTool,
+  sheetsWriteTool,
+  sheetsInfoTool,
+  sheetsNavigateTool
 ];
 
 // src/server.ts
 var pendingRequests = /* @__PURE__ */ new Map();
 var extensionSocket = null;
+var configuredChromeProfile;
 function coerceValue(v) {
   if (typeof v !== "string") return v;
   if (v.startsWith("[") && v.endsWith("]") || v.startsWith("{") && v.endsWith("}")) {
@@ -2442,40 +2774,40 @@ function createConfiguredMcpServer() {
   for (const tool of allTools) {
     const def = tool.inputSchema._def;
     const shape = def.shape?.() ?? {};
-    server.tool(
-      tool.name,
-      tool.description,
-      coerceShape(shape),
-      async (params) => {
-        const result = await callExtensionTool(tool.name, params);
-        const first = result.content[0];
-        if (tool.name === "browser_event_subscribe" && first?.type === "text") {
-          try {
-            const parsed = JSON.parse(first.text);
-            if (parsed.subscriptionId) {
-              const p = params;
-              addSubscription({
-                id: parsed.subscriptionId,
-                agentId: getDefaultAgentId(),
-                eventTypes: p.eventTypes ?? [],
-                urlPattern: p.urlPattern,
-                createdAt: Date.now()
-              });
-            }
-          } catch {
+    const coerced = coerceShape(shape);
+    coerced.chromeProfile = z2.preprocess(
+      coerceValue,
+      z2.string().optional().describe('Target Chrome profile ID (e.g. "chrome-0", "chrome-1")')
+    );
+    server.tool(tool.name, tool.description, coerced, async (params) => {
+      const result = await callExtensionTool(tool.name, params);
+      const first = result.content[0];
+      if (tool.name === "browser_event_subscribe" && first?.type === "text") {
+        try {
+          const parsed = JSON.parse(first.text);
+          if (parsed.subscriptionId) {
+            const p = params;
+            addSubscription({
+              id: parsed.subscriptionId,
+              agentId: getDefaultAgentId(),
+              eventTypes: p.eventTypes ?? [],
+              urlPattern: p.urlPattern,
+              createdAt: Date.now()
+            });
           }
-        } else if (tool.name === "browser_event_unsubscribe" && first?.type === "text") {
-          try {
-            const parsed = JSON.parse(first.text);
-            if (parsed.subscriptionId) {
-              removeSubscription(parsed.subscriptionId);
-            }
-          } catch {
+        } catch {
+        }
+      } else if (tool.name === "browser_event_unsubscribe" && first?.type === "text") {
+        try {
+          const parsed = JSON.parse(first.text);
+          if (parsed.subscriptionId) {
+            removeSubscription(parsed.subscriptionId);
           }
+        } catch {
         }
-        return result;
       }
-    );
+      return result;
+    });
   }
   const listener = (event) => {
     server.sendLoggingMessage({
@@ -2494,6 +2826,7 @@ async function startMcpServer(agentName, options) {
   if (agentName) {
     setDefaultAgentId(agentName);
   }
+  configuredChromeProfile = options?.chromeProfile;
   connectToBridge();
   if (options?.transport === "sse") {
     const sessions2 = /* @__PURE__ */ new Map();
@@ -2797,7 +3130,7 @@ function connectToBridge() {
   let cleanup = null;
   function connect() {
     bridgeClosingReceived = false;
-    const socket = createConnection({ port: BRIDGE.TCP_PORT, host: BRIDGE.TCP_HOST });
+    const socket = createConnection2({ port: BRIDGE.TCP_PORT, host: BRIDGE.TCP_HOST });
     socket.on("connect", () => {
       retryCount = 0;
       cleanup = setupBridgeConnection(socket, () => {
@@ -2866,6 +3199,9 @@ function setupBridgeConnection(socket, onBridgeClosing) {
     protocolVersion: PROTOCOL_VERSION,
     timestamp: Date.now()
   };
+  if (configuredChromeProfile) {
+    initMsg.chromeProfile = configuredChromeProfile;
+  }
   socket.write(`${JSON.stringify(initMsg)}
 `);
   const heartbeatInterval = setInterval(() => {
@@ -2964,6 +3300,11 @@ function handleExtensionMessage(message) {
 `
       );
     }
+  } else if (type === "bridge_status") {
+    const profiles = msg.chromeProfiles;
+    if (profiles) {
+      setChromeProfiles(profiles);
+    }
   } else if (type === "browser_event") {
     process.stderr.write(`[viyv-browser:mcp] Browser event: ${String(msg.eventType)}
 `);
@@ -3120,14 +3461,18 @@ async function callExtensionTool(tool, input) {
       },
       timer
     });
+    const { chromeProfile, ...cleanInput } = input;
     const request = {
       id: requestId,
       type: "tool_call",
       agentId,
       tool,
-      input,
+      input: cleanInput,
       timestamp: Date.now()
     };
+    if (typeof chromeProfile === "string" && chromeProfile) {
+      request.chromeProfile = chromeProfile;
+    }
     const written = sock.write(`${JSON.stringify(request)}
 `);
     if (!written) {
@@ -3385,6 +3730,8 @@ if (args.includes("setup")) {
   }
   const portIdx = args.indexOf("--port");
   const port = portIdx >= 0 ? Number(args[portIdx + 1]) : void 0;
-  startMcpServer(agentName, { transport: transportMode, port });
+  const chromeProfileIdx = args.indexOf("--chrome-profile");
+  const chromeProfile = chromeProfileIdx >= 0 ? args[chromeProfileIdx + 1] : process.env.VIYV_CHROME_PROFILE;
+  startMcpServer(agentName, { transport: transportMode, port, chromeProfile });
 }
 //# sourceMappingURL=index.js.map