viyv-browser-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1473 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync as existsSync3, readdirSync } from "fs";
+
+// src/server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync, unlinkSync } from "fs";
+import { createServer } from "net";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../shared/dist/constants.js
+var PROTOCOL_VERSION = "1.0.0";
+var NATIVE_HOST_NAME = "com.viyv.browser";
+var TIMEOUTS = {
+  /** Overall MCP tool timeout */
+  MCP_TOOL: 3e4,
+  /** Native Messaging request timeout */
+  NATIVE_MESSAGE: 15e3,
+  /** CDP command timeout */
+  CDP_COMMAND: 1e4,
+  /** Screenshot capture timeout */
+  SCREENSHOT: 5e3,
+  /** Navigation timeout */
+  NAVIGATION: 3e4,
+  /** Chunk reassembly timeout */
+  CHUNK_REASSEMBLY: 1e4,
+  /** Default wait_for timeout */
+  WAIT_FOR: 3e4,
+  /** Heartbeat interval */
+  HEARTBEAT: 3e4,
+  /** CDP idle detach delay */
+  CDP_IDLE_DETACH: 5e3,
+  /** Tab lock TTL (deadlock prevention) */
+  TAB_LOCK_TTL: 6e4
+};
+var LIMITS = {
+  /** Native Messaging max message size (Chrome limit) */
+  NATIVE_MESSAGE_MAX_BYTES: 1024 * 1024,
+  /** Chunk size for large payloads */
+  CHUNK_SIZE: 768 * 1024,
+  /** A11y tree max elements */
+  A11Y_MAX_ELEMENTS: 5e3,
+  /** A11y tree default depth */
+  A11Y_DEFAULT_DEPTH: 8,
+  /** A11y tree default max chars */
+  A11Y_DEFAULT_MAX_CHARS: 5e4,
+  /** Event buffer max entries */
+  EVENT_BUFFER_MAX: 1e3,
+  /** Event buffer max bytes */
+  EVENT_BUFFER_MAX_BYTES: 10 * 1024 * 1024,
+  /** Message buffer during disconnection */
+  MESSAGE_BUFFER_MAX: 1e3,
+  /** Default screenshot JPEG quality */
+  SCREENSHOT_JPEG_QUALITY: 80,
+  /** Console buffer per tab */
+  CONSOLE_BUFFER_MAX: 1e3,
+  /** Network buffer per tab */
+  NETWORK_BUFFER_MAX: 1e3
+};
+var RECONNECT = {
+  /** Initial delay (ms) */
+  INITIAL_DELAY: 1e3,
+  /** Max delay (ms) */
+  MAX_DELAY: 3e4,
+  /** Backoff multiplier */
+  MULTIPLIER: 2
+};
+var MCP_SERVER = {
+  /** Server name for MCP protocol */
+  NAME: "viyv-browser",
+  /** Server version */
+  VERSION: "0.1.0",
+  /** Unix socket path template */
+  SOCKET_PATH_TEMPLATE: "/tmp/viyv-browser-{pid}.sock"
+};
+
+// src/agent-session.ts
+import { randomUUID } from "crypto";
+var sessions = /* @__PURE__ */ new Map();
+var configuredDefaultAgentId = "default";
+function setDefaultAgentId(id) {
+  configuredDefaultAgentId = id;
+}
+function createSession(agentId, agentName) {
+  const existing = sessions.get(agentId);
+  if (existing) {
+    existing.lastActivity = Date.now();
+    existing.status = "active";
+    return existing;
+  }
+  const session = {
+    agentId,
+    sessionToken: randomUUID(),
+    agentName: agentName ?? agentId,
+    status: "active",
+    lastActivity: Date.now(),
+    createdAt: Date.now()
+  };
+  sessions.set(agentId, session);
+  return session;
+}
+function touchSession(agentId) {
+  const session = sessions.get(agentId);
+  if (session) {
+    session.lastActivity = Date.now();
+  }
+}
+function closeSession(agentId) {
+  sessions.delete(agentId);
+}
+function getDefaultAgentId() {
+  const active = Array.from(sessions.values()).find((s) => s.status === "active");
+  if (active) return active.agentId;
+  const defaultSession = createSession(configuredDefaultAgentId);
+  return defaultSession.agentId;
+}
+var STALE_SESSION_TTL = 5 * 60 * 1e3;
+var CLEANUP_INTERVAL = 60 * 1e3;
+function cleanupStaleSessions() {
+  const now = Date.now();
+  let cleaned = 0;
+  for (const [agentId, session] of sessions) {
+    if (now - session.lastActivity > STALE_SESSION_TTL) {
+      sessions.delete(agentId);
+      cleaned++;
+    }
+  }
+  if (cleaned > 0) {
+    process.stderr.write(
+      `[viyv-browser:mcp] Cleaned up ${cleaned} stale session(s)
+`
+    );
+  }
+  return cleaned;
+}
+var cleanupTimer = setInterval(cleanupStaleSessions, CLEANUP_INTERVAL);
+cleanupTimer.unref();
+
+// src/event-bridge.ts
+var subscriptions = /* @__PURE__ */ new Map();
+var eventCallback = null;
+function setEventCallback(callback) {
+  eventCallback = callback;
+}
+function addSubscription(sub) {
+  subscriptions.set(sub.id, sub);
+}
+function removeSubscription(subId) {
+  return subscriptions.delete(subId);
+}
+function removeSubscriptionsByAgent(agentId) {
+  let removed = 0;
+  for (const [id, sub] of subscriptions) {
+    if (sub.agentId === agentId) {
+      subscriptions.delete(id);
+      removed++;
+    }
+  }
+  return removed;
+}
+function processEvent(event) {
+  for (const sub of subscriptions.values()) {
+    if (sub.agentId !== event.agentId) continue;
+    if (!sub.eventTypes.includes(event.eventType)) continue;
+    if (sub.urlPattern && !event.url.includes(sub.urlPattern)) continue;
+    eventCallback?.({
+      type: "browser_event",
+      subscriptionId: sub.id,
+      ...event,
+      timestamp: Date.now()
+    });
+  }
+}
+
+// src/health.ts
+var extensionConnected = false;
+var lastHeartbeat = null;
+function setExtensionConnected(connected) {
+  extensionConnected = connected;
+  if (connected) lastHeartbeat = Date.now();
+}
+function recordHeartbeat() {
+  lastHeartbeat = Date.now();
+}
+var HEARTBEAT_STALENESS_MS = 6e4;
+function isExtensionConnected() {
+  if (!extensionConnected) return false;
+  if (lastHeartbeat !== null && Date.now() - lastHeartbeat > HEARTBEAT_STALENESS_MS) {
+    return false;
+  }
+  return true;
+}
+
+// src/native-host/compression.ts
+import { gzipSync, gunzipSync } from "zlib";
+var CHUNK_SIZE = 768 * 1024;
+function compressPayload(data) {
+  const original = Buffer.from(data, "utf-8");
+  const gzipped = gzipSync(original);
+  if (gzipped.length < original.length) {
+    return { compressed: gzipped.toString("base64"), wasCompressed: true };
+  }
+  return { compressed: data, wasCompressed: false };
+}
+function decompressPayload(data, isCompressed) {
+  if (!isCompressed) return data;
+  const buf = Buffer.from(data, "base64");
+  return gunzipSync(buf).toString("utf-8");
+}
+
+// src/tools/index.ts
+import { z } from "zod";
+
+// src/tools/advanced/gif-creator.ts
+var GIF_CREATOR_DESCRIPTION = `Record a GIF of browser activity.
+Captures a sequence of screenshots over a specified duration
+and assembles them into an animated GIF. Useful for documenting
+visual interactions or creating shareable recordings of workflows.`;
+
+// src/tools/advanced/resize-window.ts
+var RESIZE_WINDOW_DESCRIPTION = `Resize the browser window to specified dimensions.
+Sets the width and height of the browser viewport, useful for
+testing responsive layouts or ensuring consistent screenshot
+dimensions across different operations.`;
+
+// src/tools/advanced/shortcuts-execute.ts
+var SHORTCUTS_EXECUTE_DESCRIPTION = `Execute a shortcut or workflow by command name or ID.
+
+Runs the specified shortcut in the side panel using the current tab.
+Look up by command name or shortcutId. Use shortcuts_list first
+to see available shortcuts.`;
+
+// src/tools/advanced/shortcuts-list.ts
+var SHORTCUTS_LIST_DESCRIPTION = `List all available shortcuts and workflows.
+
+Returns registered shortcuts with their commands, descriptions,
+and whether they are workflows. Shortcuts can be executed using
+the shortcuts_execute tool.`;
+
+// src/tools/advanced/switch-browser.ts
+var SWITCH_BROWSER_DESCRIPTION = `Switch to a different Chrome browser instance.
+
+Disconnects the current Extension connection and waits for a new
+Chrome browser to connect (up to 60s). The user should click
+"Connect" in the desired browser's extension.`;
+
+// src/tools/advanced/update-plan.ts
+var UPDATE_PLAN_DESCRIPTION = `Present a step-by-step plan to the user for review.
+Displays the proposed sequence of actions the agent intends to take,
+allowing the user to approve, modify, or reject the plan before
+execution begins.`;
+
+// src/tools/advanced/upload-image.ts
+var UPLOAD_IMAGE_DESCRIPTION = `Upload an image to a file input element on the page.
+Accepts a local file path or base64-encoded image data and
+programmatically sets it on the target file input. Supports
+common image formats including PNG, JPEG, GIF, and WebP.`;
+
+// src/tools/core/click.ts
+var CLICK_DESCRIPTION = `Click at coordinates or on a referenced element.
+
+Provide either coordinate [x, y] or ref (element reference from read_page/find).
+Actions: left_click (default), right_click, double_click, triple_click.
+Supports modifier keys: ctrl, shift, alt, cmd (e.g., "ctrl+shift").`;
+
+// src/tools/core/drag.ts
+var DRAG_DESCRIPTION = `Drag from one coordinate to another.
+
+Performs mousedown at start, mousemove to end, then mouseup.`;
+
+// src/tools/core/find.ts
+var FIND_DESCRIPTION = `Find elements on the page using a natural language query.
+Searches the DOM for elements matching the given description,
+returning references that can be used for subsequent interactions
+such as clicking, typing, or extracting content.`;
+
+// src/tools/core/form-input.ts
+var FORM_INPUT_DESCRIPTION = `Set a value in a form element identified by its ref.
+Supports text inputs, textareas, selects, checkboxes, and radio buttons.
+The ref must be obtained from a prior find or snapshot operation
+to ensure the correct element is targeted.`;
+
+// src/tools/core/get-page-text.ts
+var GET_PAGE_TEXT_DESCRIPTION = `Extract readable text content from the current page.
+Strips away HTML tags, scripts, and styles to return a clean
+text representation of the visible page content, suitable for
+analysis, summarization, or further processing.`;
+
+// src/tools/core/handle-dialog.ts
+var HANDLE_DIALOG_DESCRIPTION = `Handle JavaScript dialogs such as alert, confirm, and prompt.
+Allows accepting or dismissing the dialog, and optionally providing
+input text for prompt dialogs. Must be called while a dialog
+is actively displayed on the page.`;
+
+// src/tools/core/hover.ts
+var HOVER_DESCRIPTION = `Move mouse to coordinates or element without clicking.
+
+Useful for revealing tooltips, dropdown menus, or triggering hover states.`;
+
+// src/tools/core/javascript-exec.ts
+var JAVASCRIPT_EXEC_DESCRIPTION = `Execute arbitrary JavaScript code in the page context.
+The script runs in the main world of the active page and can access
+the DOM, window object, and any page-level APIs. Returns the
+serialized result of the last evaluated expression.`;
+
+// src/tools/core/key.ts
+var KEY_DESCRIPTION = `Press keyboard key(s).
+
+Space-separated key names. Supports keyboard shortcuts.
+Examples: "Enter", "Tab", "Backspace", "ctrl+a", "cmd+c".
+Use repeat parameter for repeated presses (e.g., arrow keys).`;
+
+// src/tools/core/navigate.ts
+var NAVIGATE_DESCRIPTION = `Navigate to a URL, or go forward/back in browser history.
+
+Use "back" to go back in history, "forward" to go forward.
+Provide a full URL (with protocol) to navigate to a new page.
+Waits for page load to complete before returning.`;
+
+// src/tools/core/read-page.ts
+var READ_PAGE_DESCRIPTION = `Get accessibility tree representation of page elements.
+
+Supports:
+- filter: "interactive" for buttons/links/inputs only, "all" for everything
+- depth: max tree depth (1-20, default 8)
+- refId: focus on a specific element subtree
+- maxChars: limit output size (default 50000)
+
+Returns elements with ref IDs that can be used with click, form_input, etc.`;
+
+// src/tools/core/screenshot.ts
+var SCREENSHOT_DESCRIPTION = `Take a screenshot of a tab.
+
+Returns base64-encoded image data.
+Default format is JPEG with quality 80 (optimized for Native Messaging 1MB limit).
+Use PNG for lossless screenshots when needed.
+Optionally capture a specific region [x0, y0, x1, y1].`;
+
+// src/tools/core/scroll.ts
+var SCROLL_DESCRIPTION = `Scroll in a direction at given coordinates, or scroll an element into view by ref.
+
+Two modes:
+1. Directional scroll: provide coordinate + direction (+ optional amount 1-10, default 3).
+2. Scroll to element: provide ref (element reference ID from read_page/find). Scrolls the element into view using smooth scrolling.`;
+
+// src/tools/core/type.ts
+var TYPE_DESCRIPTION = `Type text into the currently focused element.
+
+Each character is typed individually with keyDown/keyUp events.
+For special keys (Enter, Tab, etc.), use the 'key' tool instead.`;
+
+// src/tools/core/wait-for.ts
+var WAIT_FOR_DESCRIPTION = `Wait for a specified condition before proceeding.
+Supports waiting for a CSS selector to appear in the DOM,
+for a navigation event to complete, or for a fixed timeout duration.
+Useful for synchronizing with asynchronous page updates.`;
+
+// src/tools/debug/read-console-messages.ts
+var READ_CONSOLE_MESSAGES_DESCRIPTION = `Read console messages captured from the page.
+Returns log, warning, error, and info messages that have been
+emitted by page scripts. Supports filtering by log level
+and limiting the number of returned entries.`;
+
+// src/tools/debug/read-network-requests.ts
+var READ_NETWORK_REQUESTS_DESCRIPTION = `Read network requests captured from the page.
+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/tabs/select-tab.ts
+var SELECT_TAB_DESCRIPTION = `Switch focus to a specific tab by its identifier.
+Makes the target tab the active tab in the agent's group,
+bringing it to the foreground for subsequent operations
+such as navigation, clicking, or content extraction.`;
+
+// src/tools/tabs/tab-close.ts
+var TAB_CLOSE_DESCRIPTION = `Close a tab by its identifier.
+Removes the specified tab from the browser and the agent's tab group.
+If the closed tab was active, focus shifts to the nearest remaining
+tab in the group.`;
+
+// src/tools/tabs/tabs-context.ts
+var TABS_CONTEXT_DESCRIPTION = `Get information about the current agent tab group.
+Returns the list of tabs belonging to the agent's assigned group,
+including each tab's ID, URL, title, and active status.
+Useful for understanding the current browsing context.`;
+
+// src/tools/tabs/tabs-create.ts
+var TABS_CREATE_DESCRIPTION = `Create a new tab within the agent's tab group.
+Opens a new tab with an optional URL and automatically assigns it
+to the current agent's group. The new tab becomes the active tab
+unless otherwise specified.`;
+
+// src/tools/viyv/agent-tab-assign.ts
+var AGENT_TAB_ASSIGN_DESCRIPTION = `Assign a tab group to a specific agent.
+Binds an existing Chrome tab group to the calling agent, granting
+exclusive control over all tabs within the group. Prevents other
+agents from interfering with the assigned tabs.`;
+
+// src/tools/viyv/agent-tab-list.ts
+var AGENT_TAB_LIST_DESCRIPTION = `List all agent-to-tab-group mappings.
+Returns a summary of which agents are assigned to which tab groups,
+including the group ID, agent identifier, and the number of tabs
+in each group.`;
+
+// src/tools/viyv/artifact-from-page.ts
+var ARTIFACT_FROM_PAGE_DESCRIPTION = `Save the current page as a persistent artifact.
+Captures the page content as HTML, PDF, or screenshot and stores it
+as a named artifact for later reference. Artifacts can be retrieved
+by other tools or returned to the user as output.`;
+
+// src/tools/viyv/browser-event-subscribe.ts
+var BROWSER_EVENT_SUBSCRIBE_DESCRIPTION = `Subscribe to browser events for real-time monitoring.
+Registers a listener for specified event types such as navigation,
+tab updates, DOM changes, or network activity. Events are queued
+and delivered on subsequent polling or callback.`;
+
+// src/tools/viyv/browser-event-unsubscribe.ts
+var BROWSER_EVENT_UNSUBSCRIBE_DESCRIPTION = `Unsubscribe from previously registered browser events.
+Removes the event listener for the specified subscription ID,
+stopping further event delivery. Cleans up associated resources
+and flushes any remaining queued events.`;
+
+// src/tools/viyv/browser-health.ts
+var BROWSER_HEALTH_DESCRIPTION = `Check the health status of the browser connection.
+Verifies that the browser process is running, the CDP connection
+is active, and the agent's tab group is accessible. Returns
+diagnostic information useful for troubleshooting connectivity issues.`;
+
+// src/tools/viyv/page-data-extract.ts
+var PAGE_DATA_EXTRACT_DESCRIPTION = `Extract structured data from the current page.
+Parses the page content according to a provided schema or natural
+language description, returning well-formed JSON. Supports extracting
+tables, lists, key-value pairs, and other structured patterns.`;
+
+// src/tools/index.ts
+var navigateTool = {
+  name: "navigate",
+  description: NAVIGATE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID to navigate"),
+    url: z.string().describe('URL to navigate to, or "back"/"forward" for history')
+  })
+};
+var screenshotTool = {
+  name: "screenshot",
+  description: SCREENSHOT_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID to capture"),
+    format: z.enum(["jpeg", "png"]).optional().describe("Image format (default: jpeg)"),
+    quality: z.number().min(1).max(100).optional().describe("JPEG quality (default: 80)"),
+    region: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional().describe("Capture region [x0, y0, x1, y1]")
+  })
+};
+var clickTool = {
+  name: "click",
+  description: CLICK_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Click position [x, y]"),
+    ref: z.string().optional().describe("Element reference ID"),
+    action: z.enum(["left_click", "right_click", "double_click", "triple_click"]).optional().describe("Click type (default: left_click)"),
+    modifiers: z.string().optional().describe('Modifier keys (e.g., "ctrl+shift")')
+  })
+};
+var typeTool = {
+  name: "type",
+  description: TYPE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    text: z.string().describe("Text to type")
+  })
+};
+var keyTool = {
+  name: "key",
+  description: KEY_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    keys: z.string().describe('Space-separated keys (e.g., "Enter", "ctrl+a")'),
+    repeat: z.number().min(1).max(100).optional().describe("Repeat count")
+  })
+};
+var scrollTool = {
+  name: "scroll",
+  description: SCROLL_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Scroll position [x, y] (required for directional scroll)"),
+    direction: z.enum(["up", "down", "left", "right"]).optional().describe("Scroll direction (required for directional scroll)"),
+    amount: z.number().min(1).max(10).optional().describe("Scroll amount (default: 3)"),
+    ref: z.string().optional().describe("Element reference ID to scroll into view")
+  })
+};
+var hoverTool = {
+  name: "hover",
+  description: HOVER_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Hover position [x, y]"),
+    ref: z.string().optional().describe("Element reference ID")
+  })
+};
+var dragTool = {
+  name: "drag",
+  description: DRAG_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    startCoordinate: z.tuple([z.number(), z.number()]).describe("Start position [x, y]"),
+    endCoordinate: z.tuple([z.number(), z.number()]).describe("End position [x, y]")
+  })
+};
+var readPageTool = {
+  name: "read_page",
+  description: READ_PAGE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    filter: z.enum(["interactive", "all"]).optional().describe('Filter: "interactive" for buttons/links/inputs, "all" for everything'),
+    depth: z.number().min(1).max(20).optional().describe("Max tree depth (default: 8)"),
+    refId: z.string().optional().describe("Focus on a specific element by ref"),
+    maxChars: z.number().optional().describe("Max output characters (default: 50000)")
+  })
+};
+var findTool = {
+  name: "find",
+  description: FIND_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    query: z.string().describe("Natural language description of what to find")
+  })
+};
+var formInputTool = {
+  name: "form_input",
+  description: FORM_INPUT_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    ref: z.string().describe("Element reference ID"),
+    value: z.union([z.string(), z.boolean(), z.number()]).describe("Value to set")
+  })
+};
+var javascriptExecTool = {
+  name: "javascript_exec",
+  description: JAVASCRIPT_EXEC_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    code: z.string().describe("JavaScript code to execute")
+  })
+};
+var waitForTool = {
+  name: "wait_for",
+  description: WAIT_FOR_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    selector: z.string().optional().describe("CSS selector to wait for"),
+    navigation: z.boolean().optional().describe("Wait for navigation to complete"),
+    timeout: z.number().optional().describe("Timeout in ms (default: 30000)")
+  })
+};
+var getPageTextTool = {
+  name: "get_page_text",
+  description: GET_PAGE_TEXT_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID")
+  })
+};
+var handleDialogTool = {
+  name: "handle_dialog",
+  description: HANDLE_DIALOG_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    action: z.enum(["accept", "dismiss"]).describe("Dialog action"),
+    text: z.string().optional().describe("Text for prompt dialog")
+  })
+};
+var tabsContextTool = {
+  name: "tabs_context",
+  description: TABS_CONTEXT_DESCRIPTION,
+  inputSchema: z.object({
+    createIfEmpty: z.boolean().optional().describe("Create a new tab group if none exists")
+  })
+};
+var tabsCreateTool = {
+  name: "tabs_create",
+  description: TABS_CREATE_DESCRIPTION,
+  inputSchema: z.object({
+    url: z.string().optional().describe("URL to open in the new tab")
+  })
+};
+var tabCloseTool = {
+  name: "tab_close",
+  description: TAB_CLOSE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID to close")
+  })
+};
+var selectTabTool = {
+  name: "select_tab",
+  description: SELECT_TAB_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID to focus")
+  })
+};
+var readConsoleMessagesTool = {
+  name: "read_console_messages",
+  description: READ_CONSOLE_MESSAGES_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    pattern: z.string().optional().describe("Regex pattern to filter messages"),
+    onlyErrors: z.boolean().optional().describe("Only return errors"),
+    limit: z.number().optional().describe("Max messages to return (default: 100)"),
+    clear: z.boolean().optional().describe("Clear messages after reading")
+  })
+};
+var readNetworkRequestsTool = {
+  name: "read_network_requests",
+  description: READ_NETWORK_REQUESTS_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    urlPattern: z.string().optional().describe("URL pattern to filter requests"),
+    limit: z.number().optional().describe("Max requests to return (default: 100)"),
+    clear: z.boolean().optional().describe("Clear requests after reading")
+  })
+};
+var gifCreatorTool = {
+  name: "gif_creator",
+  description: GIF_CREATOR_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    action: z.enum(["start_recording", "stop_recording", "export", "clear"]).describe("GIF action"),
+    filename: z.string().optional().describe("Filename for export"),
+    options: z.object({
+      showClickIndicators: z.boolean().optional(),
+      showDragPaths: z.boolean().optional(),
+      showActionLabels: z.boolean().optional(),
+      showProgressBar: z.boolean().optional(),
+      showWatermark: z.boolean().optional(),
+      quality: z.number().min(1).max(30).optional()
+    }).optional().describe("GIF rendering options"),
+    download: z.boolean().optional().describe("Download the GIF")
+  })
+};
+var uploadImageTool = {
+  name: "upload_image",
+  description: UPLOAD_IMAGE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    imageId: z.string().describe("Image ID from a previous screenshot"),
+    ref: z.string().optional().describe("Element reference for file input"),
+    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Coordinates for drag & drop")
+  })
+};
+var updatePlanTool = {
+  name: "update_plan",
+  description: UPDATE_PLAN_DESCRIPTION,
+  inputSchema: z.object({
+    domains: z.array(z.string()).describe("Domains to visit"),
+    approach: z.array(z.string()).describe("Steps in the plan")
+  })
+};
+var resizeWindowTool = {
+  name: "resize_window",
+  description: RESIZE_WINDOW_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    width: z.number().describe("Window width in pixels"),
+    height: z.number().describe("Window height in pixels")
+  })
+};
+var shortcutsListTool = {
+  name: "shortcuts_list",
+  description: SHORTCUTS_LIST_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().optional().describe("Tab ID (used to identify the tab group context)")
+  })
+};
+var shortcutsExecuteTool = {
+  name: "shortcuts_execute",
+  description: SHORTCUTS_EXECUTE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID to execute the shortcut on"),
+    command: z.string().optional().describe("Command name of the shortcut"),
+    shortcutId: z.string().optional().describe("ID of the shortcut")
+  })
+};
+var switchBrowserTool = {
+  name: "switch_browser",
+  description: SWITCH_BROWSER_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var agentTabAssignTool = {
+  name: "agent_tab_assign",
+  description: AGENT_TAB_ASSIGN_DESCRIPTION,
+  inputSchema: z.object({
+    agentId: z.string().describe("Agent ID"),
+    agentName: z.string().describe("Display name"),
+    color: z.string().optional().describe("Tab group color")
+  })
+};
+var agentTabListTool = {
+  name: "agent_tab_list",
+  description: AGENT_TAB_LIST_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var browserEventSubscribeTool = {
+  name: "browser_event_subscribe",
+  description: BROWSER_EVENT_SUBSCRIBE_DESCRIPTION,
+  inputSchema: z.object({
+    eventTypes: z.array(z.string()).describe("Event types to subscribe to"),
+    urlPattern: z.string().optional().describe("URL pattern filter"),
+    conditions: z.record(z.unknown()).optional().describe("Additional conditions")
+  })
+};
+var browserEventUnsubscribeTool = {
+  name: "browser_event_unsubscribe",
+  description: BROWSER_EVENT_UNSUBSCRIBE_DESCRIPTION,
+  inputSchema: z.object({
+    subscriptionId: z.string().describe("Subscription ID")
+  })
+};
+var artifactFromPageTool = {
+  name: "artifact_from_page",
+  description: ARTIFACT_FROM_PAGE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    type: z.string().describe("Artifact type (text, html, screenshot)"),
+    title: z.string().optional().describe("Artifact title")
+  })
+};
+var pageDataExtractTool = {
+  name: "page_data_extract",
+  description: PAGE_DATA_EXTRACT_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.number().describe("Tab ID"),
+    schema: z.record(z.unknown()).describe("Data extraction schema"),
+    selector: z.string().optional().describe("CSS selector to scope extraction")
+  })
+};
+var browserHealthTool = {
+  name: "browser_health",
+  description: BROWSER_HEALTH_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var allTools = [
+  // Core (15)
+  navigateTool,
+  screenshotTool,
+  clickTool,
+  typeTool,
+  keyTool,
+  scrollTool,
+  hoverTool,
+  dragTool,
+  readPageTool,
+  findTool,
+  formInputTool,
+  javascriptExecTool,
+  waitForTool,
+  getPageTextTool,
+  handleDialogTool,
+  // Tabs (4)
+  tabsContextTool,
+  tabsCreateTool,
+  tabCloseTool,
+  selectTabTool,
+  // Debug (2)
+  readConsoleMessagesTool,
+  readNetworkRequestsTool,
+  // Advanced (7)
+  gifCreatorTool,
+  uploadImageTool,
+  updatePlanTool,
+  resizeWindowTool,
+  shortcutsListTool,
+  shortcutsExecuteTool,
+  switchBrowserTool,
+  // viyv Integration (7)
+  agentTabAssignTool,
+  agentTabListTool,
+  browserEventSubscribeTool,
+  browserEventUnsubscribeTool,
+  artifactFromPageTool,
+  pageDataExtractTool,
+  browserHealthTool
+];
+
+// src/server.ts
+var pendingRequests = /* @__PURE__ */ new Map();
+var extensionSocket = null;
+async function startMcpServer(socketPath, agentName) {
+  if (agentName) {
+    setDefaultAgentId(agentName);
+  }
+  const socketServer = createSocketServer(socketPath);
+  const server = new McpServer({
+    name: MCP_SERVER.NAME,
+    version: MCP_SERVER.VERSION
+  });
+  for (const tool of allTools) {
+    const shape = tool.inputSchema._def.shape?.() ?? {};
+    server.tool(tool.name, tool.description, shape, async (params) => {
+      const result = await callExtensionTool(tool.name, params);
+      if (tool.name === "browser_event_subscribe" && result.content[0]) {
+        try {
+          const parsed = JSON.parse(result.content[0].text);
+          if (parsed.subscriptionId) {
+            const p = params;
+            addSubscription({
+              id: parsed.subscriptionId,
+              agentId: getDefaultAgentId(),
+              eventTypes: p.eventTypes ?? [],
+              urlPattern: p.urlPattern,
+              createdAt: Date.now()
+            });
+          }
+        } catch {
+        }
+      } else if (tool.name === "browser_event_unsubscribe" && result.content[0]) {
+        try {
+          const parsed = JSON.parse(result.content[0].text);
+          if (parsed.subscriptionId) {
+            removeSubscription(parsed.subscriptionId);
+          }
+        } catch {
+        }
+      }
+      return result;
+    });
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  setEventCallback((event) => {
+    server.sendLoggingMessage({
+      level: "info",
+      data: event
+    }).catch(() => {
+    });
+  });
+  process.stderr.write(`[viyv-browser:mcp] MCP Server started, socket: ${socketPath}
+`);
+  process.on("exit", () => {
+    socketServer.close();
+    cleanupSocket(socketPath);
+  });
+  process.on("SIGINT", () => process.exit(0));
+  process.on("SIGTERM", () => process.exit(0));
+}
+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)}
+`);
+    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}
+`);
+    });
+  });
+  server.listen(socketPath, () => {
+    process.stderr.write(`[viyv-browser:mcp] Unix socket listening on ${socketPath}
+`);
+  });
+  return server;
+}
+function handleExtensionMessage(message) {
+  if (!message || typeof message !== "object") return;
+  const msg = message;
+  const type = typeof msg.type === "string" ? msg.type : null;
+  const id = typeof msg.id === "string" ? msg.id : null;
+  if (!type) return;
+  if (type === "tool_result" && id) {
+    const pending = pendingRequests.get(id);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pendingRequests.delete(id);
+      if (msg.success) {
+        pending.resolve(msg.result ?? {});
+      } else {
+        const err = msg.error;
+        const code = typeof err?.code === "string" ? err.code : "UNKNOWN";
+        const errMsg = typeof err?.message === "string" ? err.message : "Unknown error";
+        pending.reject(new Error(`[${code}] ${errMsg}`));
+      }
+    }
+  } else if (type === "session_heartbeat") {
+    recordHeartbeat();
+    const hbAgentId = typeof msg.agentId === "string" ? msg.agentId : null;
+    if (hbAgentId) touchSession(hbAgentId);
+  } else if (type === "session_close") {
+    const closeAgentId = typeof msg.agentId === "string" ? msg.agentId : null;
+    if (closeAgentId) {
+      closeSession(closeAgentId);
+      removeSubscriptionsByAgent(closeAgentId);
+      process.stderr.write(`[viyv-browser:mcp] Session closed and cleaned up: ${closeAgentId}
+`);
+    }
+  } else if (type === "session_recovery") {
+    const recoveryAgentId = typeof msg.agentId === "string" ? msg.agentId : null;
+    if (recoveryAgentId) {
+      createSession(recoveryAgentId);
+      process.stderr.write(`[viyv-browser:mcp] Session recovered: ${recoveryAgentId}
+`);
+    }
+  } else if (type === "session_init") {
+    const remoteVersion = typeof msg.protocolVersion === "string" ? msg.protocolVersion : null;
+    if (remoteVersion && remoteVersion !== PROTOCOL_VERSION) {
+      process.stderr.write(
+        `[viyv-browser:mcp] Protocol version mismatch: local=${PROTOCOL_VERSION}, remote=${remoteVersion}
+`
+      );
+    }
+  } else if (type === "browser_event") {
+    process.stderr.write(`[viyv-browser:mcp] Browser event: ${String(msg.eventType)}
+`);
+    processEvent({
+      eventType: msg.eventType,
+      agentId: String(msg.agentId ?? ""),
+      tabId: Number(msg.tabId ?? 0),
+      url: String(msg.url ?? ""),
+      payload: msg.payload ?? {},
+      sequenceNumber: Number(msg.sequenceNumber ?? 0)
+    });
+  }
+}
+async function callExtensionTool(tool, input) {
+  if (tool === "switch_browser") {
+    return handleSwitchBrowser();
+  }
+  if (!extensionSocket || extensionSocket.destroyed || !isExtensionConnected()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: {
+              code: "EXTENSION_NOT_CONNECTED",
+              message: "Chrome Extension is not connected. Please open Chrome and click the Viyv Browser extension icon."
+            }
+          })
+        }
+      ]
+    };
+  }
+  const requestId = randomUUID2();
+  const agentId = getDefaultAgentId();
+  touchSession(agentId);
+  const sock = extensionSocket;
+  let toolTimeout = TIMEOUTS.MCP_TOOL;
+  if (tool === "wait_for" && typeof input.timeout === "number") {
+    toolTimeout = input.timeout + 5e3;
+  }
+  return new Promise((resolve2) => {
+    const onError = () => {
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        pendingRequests.delete(requestId);
+        resolve2({
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: {
+                  code: "EXTENSION_NOT_CONNECTED",
+                  message: "Socket write failed"
+                }
+              })
+            }
+          ]
+        });
+      }
+    };
+    const removeErrorListener = () => {
+      sock.removeListener("error", onError);
+    };
+    const timer = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      removeErrorListener();
+      resolve2({
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "TIMEOUT",
+                message: `Tool '${tool}' timed out after ${toolTimeout}ms`
+              }
+            })
+          }
+        ]
+      });
+    }, toolTimeout);
+    pendingRequests.set(requestId, {
+      resolve: (result) => {
+        removeErrorListener();
+        resolve2({
+          content: [{ type: "text", text: JSON.stringify(result) }]
+        });
+      },
+      reject: (error) => {
+        removeErrorListener();
+        resolve2({
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: { code: "CDP_ERROR", message: error.message }
+              })
+            }
+          ]
+        });
+      },
+      timer
+    });
+    const request = {
+      id: requestId,
+      type: "tool_call",
+      agentId,
+      tool,
+      input,
+      timestamp: Date.now()
+    };
+    const written = sock.write(`${JSON.stringify(request)}
+`);
+    if (!written) {
+      sock.once("drain", () => {
+      });
+    }
+    sock.once("error", onError);
+  });
+}
+async function handleSwitchBrowser() {
+  const SWITCH_TIMEOUT = 6e4;
+  if (extensionSocket && !extensionSocket.destroyed) {
+    process.stderr.write("[viyv-browser:mcp] switch_browser: closing current connection\n");
+    extensionSocket.destroy();
+    extensionSocket = null;
+    setExtensionConnected(false);
+  }
+  process.stderr.write("[viyv-browser:mcp] switch_browser: waiting for new browser connection...\n");
+  return new Promise((resolve2) => {
+    const checkInterval = setInterval(() => {
+      if (extensionSocket && !extensionSocket.destroyed && isExtensionConnected()) {
+        clearInterval(checkInterval);
+        clearTimeout(timer);
+        resolve2({
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                switched: true,
+                message: "Successfully connected to new browser instance."
+              })
+            }
+          ]
+        });
+      }
+    }, 500);
+    const timer = setTimeout(() => {
+      clearInterval(checkInterval);
+      resolve2({
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "TIMEOUT",
+                message: `No new browser connected within ${SWITCH_TIMEOUT / 1e3}s. Please open Chrome and click the Viyv Browser extension icon.`
+              }
+            })
+          }
+        ]
+      });
+    }, SWITCH_TIMEOUT);
+  });
+}
+function cleanupSocket(socketPath) {
+  if (existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch {
+    }
+  }
+}
+
+// src/native-host/bridge.ts
+import { createConnection } from "net";
+
+// src/native-host/transport.ts
+var MAX_MESSAGE_SIZE = 1024 * 1024;
+function encodeMessage(message) {
+  const json = JSON.stringify(message);
+  const body = Buffer.from(json, "utf-8");
+  if (body.length > MAX_MESSAGE_SIZE) {
+    throw new Error(`Message too large: ${body.length} bytes (max ${MAX_MESSAGE_SIZE})`);
+  }
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+function createMessageReader(stream, onMessage, onError, onClose) {
+  let buffer = Buffer.alloc(0);
+  let expectedLength = null;
+  stream.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      if (expectedLength === null) {
+        if (buffer.length < 4) break;
+        expectedLength = buffer.readUInt32LE(0);
+        buffer = buffer.subarray(4);
+        if (expectedLength > MAX_MESSAGE_SIZE) {
+          onError?.(new Error(`Message too large: ${expectedLength} bytes`));
+          expectedLength = null;
+          buffer = Buffer.alloc(0);
+          break;
+        }
+      }
+      if (buffer.length < expectedLength) break;
+      const jsonBuffer = buffer.subarray(0, expectedLength);
+      buffer = buffer.subarray(expectedLength);
+      expectedLength = null;
+      try {
+        const message = JSON.parse(jsonBuffer.toString("utf-8"));
+        onMessage(message);
+      } catch (error) {
+        onError?.(new Error(`Invalid JSON: ${error.message}`));
+      }
+    }
+  });
+  stream.on("error", (error) => {
+    onError?.(new Error(`Stream error: ${error.message}`));
+  });
+  stream.on("end", () => {
+    onClose?.();
+  });
+  stream.on("close", () => {
+    onClose?.();
+  });
+}
+function writeMessage(stream, message) {
+  const encoded = encodeMessage(message);
+  stream.write(encoded);
+}
+
+// src/native-host/bridge.ts
+var MAX_BUFFER_SIZE = 1e3;
+function startBridge(options) {
+  const { socketPath, onError } = options;
+  let socket = null;
+  let reconnecting = false;
+  let retryCount = 0;
+  const pendingMessages = [];
+  function flushBuffer() {
+    if (!socket || socket.destroyed) return;
+    while (pendingMessages.length > 0) {
+      const msg = pendingMessages[0];
+      try {
+        const written = socket.write(`${JSON.stringify(msg)}
+`);
+        pendingMessages.shift();
+        if (!written) {
+          socket.once("drain", () => flushBuffer());
+          return;
+        }
+      } catch (error) {
+        onError?.(error);
+        return;
+      }
+    }
+  }
+  function connectSocket() {
+    socket = createConnection(socketPath);
+    socket.on("connect", () => {
+      process.stderr.write(
+        `[viyv-browser:native-host] Connected to MCP server at ${socketPath}
+`
+      );
+      retryCount = 0;
+      flushBuffer();
+    });
+    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 message = JSON.parse(line);
+          if (message.type === "compressed" && typeof message.data === "string") {
+            const decompressed = decompressPayload(message.data, true);
+            message = JSON.parse(decompressed);
+          }
+          writeMessage(process.stdout, message);
+        } catch (error) {
+          onError?.(error);
+        }
+      }
+    });
+    socket.on("error", (error) => {
+      process.stderr.write(
+        `[viyv-browser:native-host] Socket error: ${error.message}
+`
+      );
+      onError?.(error);
+    });
+    socket.on("close", () => {
+      process.stderr.write("[viyv-browser:native-host] Socket closed\n");
+      socket = null;
+      if (!reconnecting) {
+        reconnecting = true;
+        const delay = Math.min(
+          RECONNECT.INITIAL_DELAY * Math.pow(RECONNECT.MULTIPLIER, retryCount),
+          RECONNECT.MAX_DELAY
+        );
+        retryCount++;
+        process.stderr.write(
+          `[viyv-browser:native-host] Reconnecting in ${delay}ms (attempt ${retryCount})
+`
+        );
+        setTimeout(() => {
+          reconnecting = false;
+          connectSocket();
+        }, delay);
+      }
+    });
+  }
+  createMessageReader(
+    process.stdin,
+    (message) => {
+      if (socket && !socket.destroyed) {
+        const json = JSON.stringify(message);
+        if (json.length > LIMITS.CHUNK_SIZE) {
+          const { compressed, wasCompressed } = compressPayload(json);
+          if (wasCompressed) {
+            socket.write(`${JSON.stringify({ type: "compressed", data: compressed })}
+`);
+          } else {
+            socket.write(`${json}
+`);
+          }
+        } else {
+          socket.write(`${json}
+`);
+        }
+      } else {
+        if (pendingMessages.length < MAX_BUFFER_SIZE) {
+          pendingMessages.push(message);
+        } else {
+          process.stderr.write(
+            "[viyv-browser:native-host] Message buffer full, dropping message\n"
+          );
+        }
+      }
+    },
+    onError
+  );
+  connectSocket();
+  process.on("SIGINT", () => {
+    socket?.destroy();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    socket?.destroy();
+    process.exit(0);
+  });
+  process.stdin.on("end", () => {
+    process.stderr.write("[viyv-browser:native-host] stdin closed, shutting down\n");
+    socket?.destroy();
+    process.exit(0);
+  });
+}
+
+// src/setup.ts
+import { writeFileSync, mkdirSync, chmodSync, existsSync as existsSync2 } from "fs";
+import { resolve, dirname } from "path";
+import { homedir, platform } from "os";
+import { execSync } from "child_process";
+function runSetup(options = {}) {
+  const os = platform();
+  const binaryPath = getBinaryPath();
+  console.log("Viyv Browser MCP - Native Messaging Host Setup");
+  console.log("================================================");
+  console.log(`Platform: ${os}`);
+  console.log(`Binary: ${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.");
+  }
+  const allowedOrigins = options.extensionId ? [`chrome-extension://${options.extensionId}/`] : ["chrome-extension://*/"];
+  if (!options.extensionId) {
+    process.stderr.write(
+      "WARNING: Using wildcard allowed_origins (chrome-extension://*/). This allows any Chrome extension to connect. For production, specify --extension-id to restrict access.\n"
+    );
+  }
+  const wrapperPath = createNativeHostWrapper(os, binaryPath);
+  const manifest = {
+    name: NATIVE_HOST_NAME,
+    description: "Viyv Browser MCP Native Messaging Host",
+    path: wrapperPath,
+    type: "stdio",
+    allowed_origins: allowedOrigins
+  };
+  const manifestPath = getManifestPath(os);
+  const manifestDir = dirname(manifestPath);
+  console.log(`Wrapper: ${wrapperPath}`);
+  console.log(`Manifest path: ${manifestPath}`);
+  mkdirSync(manifestDir, { recursive: true });
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  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");
+  console.log("2. Install the Viyv Browser Chrome Extension");
+  console.log("3. Click the extension icon to connect");
+}
+function getBinaryPath() {
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const found = execSync(`${whichCmd} viyv-browser-mcp`, { encoding: "utf-8" }).trim();
+    if (found) return found;
+  } catch {
+  }
+  const currentScript = process.argv[1];
+  return resolve(currentScript);
+}
+function createNativeHostWrapper(os, binaryPath) {
+  const manifestDir = dirname(getManifestPath(os));
+  mkdirSync(manifestDir, { recursive: true });
+  const nodePath = getNodePath();
+  if (os === "win32") {
+    const wrapperPath2 = resolve(manifestDir, `${NATIVE_HOST_NAME}.bat`);
+    writeFileSync(wrapperPath2, `@echo off\r
+"${nodePath}" "${binaryPath}" --native-host\r
+`);
+    return wrapperPath2;
+  }
+  const wrapperPath = resolve(manifestDir, `${NATIVE_HOST_NAME}.sh`);
+  writeFileSync(
+    wrapperPath,
+    `#!/bin/bash
+exec "${nodePath}" "${binaryPath}" --native-host
+`
+  );
+  chmodSync(wrapperPath, 493);
+  return wrapperPath;
+}
+function getNodePath() {
+  try {
+    return execSync("which node", { encoding: "utf-8" }).trim();
+  } catch {
+    return process.execPath;
+  }
+}
+function getManifestPath(os) {
+  const home = homedir();
+  switch (os) {
+    case "darwin":
+      return resolve(
+        home,
+        "Library/Application Support/Google/Chrome/NativeMessagingHosts",
+        `${NATIVE_HOST_NAME}.json`
+      );
+    case "linux":
+      return resolve(
+        home,
+        ".config/google-chrome/NativeMessagingHosts",
+        `${NATIVE_HOST_NAME}.json`
+      );
+    case "win32":
+      return resolve(
+        home,
+        "AppData/Local/Google/Chrome/User Data/NativeMessagingHosts",
+        `${NATIVE_HOST_NAME}.json`
+      );
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+if (args.includes("setup")) {
+  const extensionIdIdx = args.indexOf("--extension-id");
+  const extensionId = extensionIdIdx >= 0 ? args[extensionIdIdx + 1] : void 0;
+  runSetup({ extensionId });
+} else if (args.includes("--native-host")) {
+  const socketPath = findSocketPath();
+  if (!socketPath) {
+    process.stderr.write(
+      "[viyv-browser:native-host] No MCP server socket found. Is the MCP server running?\n"
+    );
+    process.exit(1);
+  }
+  startBridge({
+    socketPath,
+    onError: (error) => {
+      process.stderr.write(`[viyv-browser:native-host] Error: ${error.message}
+`);
+    }
+  });
+} else {
+  const socketPath = "/tmp/viyv-browser.sock";
+  const agentNameIdx = args.indexOf("--agent-name");
+  const agentName = agentNameIdx >= 0 ? args[agentNameIdx + 1] : void 0;
+  startMcpServer(socketPath, agentName);
+}
+function findSocketPath() {
+  const envSocket = process.env.VIYV_BROWSER_SOCKET;
+  if (envSocket) return envSocket;
+  const fixedPath = "/tmp/viyv-browser.sock";
+  if (existsSync3(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;
+}
+//# sourceMappingURL=index.js.map