@dacodedbeat/mcp-browser-buddy 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,734 +1,180 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { spawn } from "node:child_process";
-// ─── Constants ────────────────────────────────────────────────────────────────
-const ALLOWED_BROWSERS = [
-    "Google Chrome",
-    "Brave Browser",
-    "Chromium",
-    "Google Chrome Canary",
-];
-// ─── Logger ───────────────────────────────────────────────────────────────────
-function log(level, message) {
-    const timestamp = new Date().toISOString();
-    process.stderr.write(`[${timestamp}] [${level}] ${message}\n`);
-}
-// ASCII control chars — never appear in URLs or page titles
-const FIELD_SEP = "\x1f";
-const RECORD_SEP = "\x1e";
-// ─── AppleScript helpers ──────────────────────────────────────────────────────
-// Safe AppleScript string literal from arbitrary JS string — no shell quoting needed
-function asAS(value) {
-    if (value === "")
-        return '""';
-    const tokens = [];
-    let buf = "";
-    for (const ch of value) {
-        const code = ch.charCodeAt(0);
-        if (ch === '"') {
-            if (buf) {
-                tokens.push(`"${buf}"`);
-                buf = "";
-            }
-            tokens.push("quote");
-        }
-        else if (code < 32 || code === 127) {
-            if (buf) {
-                tokens.push(`"${buf}"`);
-                buf = "";
-            }
-            tokens.push(`(ASCII character ${code})`);
-        }
-        else {
-            buf += ch;
-        }
-    }
-    if (buf)
-        tokens.push(`"${buf}"`);
-    return tokens.length > 0 ? tokens.join(" & ") : '""';
-}
-function runAppleScript(script, timeoutMs = 30000) {
-    return new Promise((resolve, reject) => {
-        log("INFO", `Executing AppleScript: ${script.substring(0, 50)}...`);
-        const proc = spawn("osascript", ["-"]);
-        let stdout = "";
-        let stderr = "";
-        const timer = setTimeout(() => {
-            proc.kill();
-            log("ERROR", `AppleScript timed out after ${timeoutMs}ms`);
-            reject(new Error(`osascript timed out after ${timeoutMs}ms (browser may be showing a dialog)`));
-        }, timeoutMs);
-        proc.stdout.on("data", (d) => (stdout += d.toString("utf8")));
-        proc.stderr.on("data", (d) => (stderr += d.toString("utf8")));
-        proc.on("close", (code) => {
-            clearTimeout(timer);
-            if (code === 0) {
-                resolve(stdout);
-            }
-            else {
-                const err = stderr.trim() || `osascript exited with code ${code}`;
-                log("ERROR", `AppleScript failed: ${err}`);
-                reject(new Error(err));
-            }
-        });
-        proc.stdin.write(script, "utf8");
-        proc.stdin.end();
-    });
-}
-// AppleScript body: find tab by ID across all windows, run `action`, error if not found.
-// `action` has access to: t (tab), w (window), tIdx (1-based position).
-function findTabScript(tabId, action) {
-    return `
-  set tid to ${asAS(tabId)}
-  repeat with wIdx from 1 to (count of windows)
-    set w to window wIdx
-    repeat with tIdx from 1 to (count of tabs of w)
-      set t to tab tIdx of w
-      if (id of t) as string = tid then
-        ${action}
-        return
-      end if
-    end repeat
-  end repeat
-  error "Tab " & tid & " not found"`;
-}
-// ─── AppleScript operations ───────────────────────────────────────────────────
-async function getTabs(browser) {
-    const script = `
-tell application "${browser}"
-  set fs to (ASCII character 31)
-  set rs to (ASCII character 30)
-  set output to ""
-  set winCount to count of windows
-  repeat with wIdx from 1 to winCount
-    set w to window wIdx
-    set wID to id of w
-    set wName to name of w
-    set wMode to mode of w
-    set activeIdx to active tab index of w
-    set tabCount to count of tabs of w
-    repeat with tIdx from 1 to tabCount
-      set t to tab tIdx of w
-      set tID to (id of t) as string
-      set isActive to (tIdx = activeIdx)
-      set isLoading to loading of t
-      set output to output & wID & fs & wIdx & fs & wName & fs & wMode & fs & tID & fs & tIdx & fs & isActive & fs & isLoading & fs & (title of t) & fs & (URL of t) & rs
-    end repeat
-  end repeat
-  return output
-end tell
-`;
-    const raw = await runAppleScript(script);
-    const records = raw.split(RECORD_SEP).filter((r) => r.length > 0);
-    const windowMap = new Map();
-    for (const record of records) {
-        const [wId, wIdx, wName, wMode, tId, tIdx, isActive, isLoading, title, url] = record.split(FIELD_SEP);
-        if (!windowMap.has(wId)) {
-            windowMap.set(wId, {
-                windowId: wId,
-                windowIndex: parseInt(wIdx, 10),
-                windowName: wName ?? "",
-                mode: wMode ?? "normal",
-                tabs: [],
-            });
-        }
-        windowMap.get(wId).tabs.push({
-            id: tId,
-            windowId: wId,
-            title: title ?? "",
-            url: url ?? "",
-            isActive: isActive === "true",
-            loading: isLoading === "true",
-            windowIndex: parseInt(wIdx, 10),
-            tabIndex: parseInt(tIdx, 10),
-        });
-    }
-    return Array.from(windowMap.values());
-}
-async function getActiveTab(browser) {
-    const script = `
-tell application "${browser}"
-  if (count of windows) = 0 then return ""
-  set w to window 1
-  set wID to id of w
-  set wIdx to index of w
-  set t to active tab of w
-  set tID to (id of t) as string
-  set tIdx to active tab index of w
-  set fs to (ASCII character 31)
-  return wID & fs & wIdx & fs & tID & fs & tIdx & fs & (loading of t) & fs & (title of t) & fs & (URL of t)
-end tell
-`;
-    const raw = await runAppleScript(script);
-    if (!raw.trim())
-        return null;
-    const [wId, wIdx, tId, tIdx, isLoading, title, url] = raw.trim().split(FIELD_SEP);
-    return {
-        id: tId,
-        windowId: wId,
-        title: title ?? "",
-        url: url ?? "",
-        isActive: true,
-        loading: isLoading === "true",
-        windowIndex: parseInt(wIdx, 10),
-        tabIndex: parseInt(tIdx, 10),
-    };
-}
-async function activateTab(browser, tabId) {
-    const action = ["set active tab index of w to tIdx", "set index of w to 1", "activate"].join("\n        ");
-    await runAppleScript(`tell application "${browser}"\n${findTabScript(tabId, action)}\nend tell`);
-}
-async function goBack(browser, tabId) {
-    await runAppleScript(`tell application "${browser}"\n${findTabScript(tabId, "go back t")}\nend tell`);
-}
-async function goForward(browser, tabId) {
-    await runAppleScript(`tell application "${browser}"\n${findTabScript(tabId, "go forward t")}\nend tell`);
-}
-async function navigateTab(browser, tabId, url) {
-    await runAppleScript(`tell application "${browser}"\n${findTabScript(tabId, `set URL of t to ${asAS(url)}`)}\nend tell`);
-}
-async function executeScript(browser, tabId, javascript) {
-    const action = [
-        `set jsCode to ${asAS(javascript)}`,
-        "set jsResult to execute t javascript jsCode",
-        "if jsResult is missing value then",
-        '  return "null"',
-        "end if",
-        "return jsResult as string",
-    ].join("\n        ");
-    const result = await runAppleScript(`tell application "${browser}"\n${findTabScript(tabId, action)}\nend tell`);
-    return result.trim();
-}
-async function closeTabs(browser, tabIds) {
-    const script = `
-tell application "${browser}"
-  set tids to {${tabIds.map(asAS).join(", ")}}
-  set closedCount to 0
-  set winCount to count of windows
-  repeat with wIdx from 1 to winCount
-    -- Guard: closing the last tab in a window auto-closes it, shrinking the list
-    if wIdx > (count of windows) then exit repeat
-    set w to window wIdx
-    set tabCount to count of tabs of w
-    -- Backwards: closing tab N shifts indices N+1… down, never N-1…1
-    repeat with tIdx from tabCount to 1 by -1
-      try
-        set t to tab tIdx of w
-        if (id of t) as string is in tids then
-          close t
-          set closedCount to closedCount + 1
-        end if
-      end try
-    end repeat
-  end repeat
-  return closedCount
-end tell
-`;
-    const result = await runAppleScript(script);
-    return { count: parseInt(result.trim(), 10) || 0 };
-}
-async function closeWindow(browser, windowId) {
-    await runAppleScript(`
-tell application "${browser}"
-  set wid to ${asAS(windowId)}
-  repeat with i from 1 to (count of windows)
-    set w to window i
-    if (id of w) as string = wid then
-      close w
-      return
-    end if
-  end repeat
-  error "Window " & wid & " not found"
-end tell`);
-}
-// Runs a single AppleScript command verb on all tabs matching the given IDs
-async function bulkTabCommand(browser, tabIds, command) {
-    await runAppleScript(`
-tell application "${browser}"
-  set tids to {${tabIds.map(asAS).join(", ")}}
-  repeat with wIdx from 1 to (count of windows)
-    set w to window wIdx
-    repeat with tIdx from 1 to (count of tabs of w)
-      set t to tab tIdx of w
-      if (id of t) as string is in tids then
-        ${command} t
-      end if
-    end repeat
-  end repeat
-end tell`);
-}
-const reloadTabs = (b, ids) => bulkTabCommand(b, ids, "reload");
-const stopTabs = (b, ids) => bulkTabCommand(b, ids, "stop");
-async function createWindow(browser, mode) {
-    const result = await runAppleScript(`
-tell application "${browser}"
-  set newWin to make new window with properties {mode: ${asAS(mode)}}
-  return (id of newWin) as string
-end tell`);
-    return result.trim();
-}
-async function openTabs(browser, urls, windowId, activate = false) {
-    const windowSetup = windowId
-        ? `set wid to ${asAS(windowId)}
-  repeat with i from 1 to (count of windows)
-    set w to window i
-    if (id of w) as string = wid then
-      set targetWin to w
-      exit repeat
-    end if
-  end repeat
-  if targetWin is missing value then error "Window " & wid & " not found"`
-        : `if (count of windows) = 0 then make new window
-  set targetWin to window 1`;
-    const activateBlock = activate
-        ? `set active tab index of targetWin to (count of tabs of targetWin)
-  set index of targetWin to 1
-  activate`
-        : "";
-    const result = await runAppleScript(`
-tell application "${browser}"
-  set targetWin to missing value
-  ${windowSetup}
-  set newIds to {}
-  repeat with uRef in {${urls.map(asAS).join(", ")}}
-    set u to contents of uRef
-    set newTab to make new tab at end of tabs of targetWin with properties {URL:u}
-    copy (id of newTab) as string to end of newIds
-  end repeat
-  ${activateBlock}
-  set AppleScript's text item delimiters to ","
-  return newIds as string
-end tell`);
-    return result
-        .trim()
-        .split(",")
-        .filter((id) => id.length > 0);
-}
-// ─── Zod schemas ──────────────────────────────────────────────────────────────
-const BrowserParam = z
+import { createRequire } from "node:module";
+import * as chrome from "./applescript.js";
+import { ALLOWED_BROWSERS } from "./applescript.js";
+import { DEFAULT_LIMIT, MAX_LIMIT, TAB_LINE_LEGEND, countTabs, filterTabs, formatClosed, formatDuplicates, formatTabs, summarizeWindows, tabLine, } from "./format.js";
+// Keep serverInfo in sync with the published package version (dist/ -> ../package.json)
+const PKG_VERSION = createRequire(import.meta.url)("../package.json").version;
+// ─── Shared schema pieces ─────────────────────────────────────────────────────
+const browserField = z
     .enum(ALLOWED_BROWSERS)
     .default("Google Chrome")
-    .describe('Browser to control. One of: "Google Chrome", "Brave Browser", "Chromium", "Google Chrome Canary". Defaults to "Google Chrome".');
-const TabIdParam = z
+    .describe(`Browser to control. One of: ${ALLOWED_BROWSERS.join(", ")}. Defaults to Google Chrome.`);
+const tabIdField = z
     .string()
     .regex(/^\d+$/, "Tab ID must be digits only")
-    .describe("Unique numeric string identifying a tab. Extract from [Tab ID: XXXXX] in get_tabs output, or from the tabs_json block.");
-const TabIdSchema = z.object({ tabId: TabIdParam, browser: BrowserParam });
-const BulkTabSchema = z.object({
-    tabIds: z.array(TabIdParam).min(1).describe("List of Tab IDs to operate on."),
-    browser: BrowserParam,
-});
-const WindowIdParam = z
+    .describe("Numeric tab ID: the first token of each line in get_tabs / search_tabs output.");
+const windowIdField = z
     .string()
     .regex(/^\d+$/)
-    .describe("Window ID. Get from tabs_json in get_tabs output.");
-const CloseWindowSchema = z.object({ windowId: WindowIdParam, browser: BrowserParam });
-const OpenTabsSchema = z.object({
+    .describe("Window ID: the `[ID: …]` in a window header of get_tabs output.");
+const paging = {
+    windowId: windowIdField.optional().describe("Only include tabs in this window."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_LIMIT)
+        .default(DEFAULT_LIMIT)
+        .describe(`Max tabs to return (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}).`),
+    offset: z.number().int().min(0).default(0).describe("Tabs to skip, for paging."),
+};
+const tabIdsField = z.array(tabIdField).min(1).describe("List of Tab IDs to operate on.");
+// ─── Tool plumbing ────────────────────────────────────────────────────────────
+// Explicit values: MCP defaults destructiveHint/openWorldHint to true when omitted.
+const READ = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const WRITE = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+const DESTRUCTIVE = { ...WRITE, destructiveHint: true };
+const text = (s, isError = false) => ({
+    content: [{ type: "text", text: s }],
+    ...(isError && { isError }),
+});
+const server = new McpServer({ name: "mcp-browser-buddy", version: PKG_VERSION });
+// Adding a tool = one registerTool call: schema, annotations and handler live together.
+function tool(name, title, description, annotations, inputSchema, handler) {
+    server.registerTool(name, {
+        title,
+        description,
+        inputSchema: inputSchema,
+        annotations: { title, ...annotations },
+    }, async (args) => {
+        try {
+            return text(await handler(args));
+        }
+        catch (error) {
+            return text(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+        }
+    });
+}
+// ─── Tools ────────────────────────────────────────────────────────────────────
+tool("get_tabs", "Get Tabs", "List open tabs grouped by window, one line each (Tab ID first). Paged. With many tabs, call with summary=true first, then drill into a window with windowId.", READ, {
+    summary: z
+        .boolean()
+        .default(false)
+        .describe("If true, return one block per window (id, tab count, active tab, top domains) instead of every tab."),
+    ...paging,
+    browser: browserField,
+}, async ({ browser, windowId, summary, limit, offset }) => {
+    const { windows, skipped } = await chrome.getTabs(browser, windowId);
+    const head = `${countTabs(windows)} tab(s) in ${windows.length} window(s) of ${browser}.`;
+    const warn = skipped ? ` (${skipped} window(s) could not be read and were skipped)` : "";
+    const body = summary ? summarizeWindows(windows) : formatTabs(windows, limit, offset);
+    return `${head}${warn}\n${TAB_LINE_LEGEND}\n\n${body}`;
+});
+tool("search_tabs", "Search Tabs", "Find tabs whose title or URL contains every word of the query (case-insensitive). Paged; same line format as get_tabs.", READ, {
+    query: z.string().describe("Words to search for in tab titles and URLs; all must match."),
+    ...paging,
+    browser: browserField,
+}, async ({ browser, query, windowId, limit, offset }) => {
+    const { windows } = await chrome.getTabs(browser, windowId);
+    const matched = filterTabs(windows, query);
+    return `Found ${countTabs(matched)} tab(s) matching "${query}".\n${TAB_LINE_LEGEND}\n\n${formatTabs(matched, limit, offset, "matching tab")}`;
+});
+tool("find_duplicates", "Find Duplicate Tabs", "Group tabs that have the same URL (ignoring #fragment and trailing slash). Cheaper than listing every tab; follow with close_tabs on the redundant IDs.", READ, {
+    windowId: windowIdField.optional().describe("Only look in this window."),
+    browser: browserField,
+}, async ({ browser, windowId }) => formatDuplicates((await chrome.getTabs(browser, windowId)).windows));
+tool("get_active_tab", "Get Active Tab", "Get details about the currently focused tab in the frontmost window.", READ, { browser: browserField }, async ({ browser }) => {
+    const tab = await chrome.getActiveTab(browser);
+    return tab
+        ? `Active tab in frontmost window:\n${tabLine(tab)}\n[Window ID: ${tab.windowId}]`
+        : "No active window found.";
+});
+tool("open_tabs", "Open Tabs", "Open one or more URLs in new tabs.", { ...WRITE, openWorldHint: true }, {
     urls: z.array(z.string().url()).min(1).describe("List of fully-qualified URLs to open."),
-    windowId: WindowIdParam.optional().describe("Window ID to open the tabs in. Omit to use the frontmost window."),
+    windowId: windowIdField
+        .optional()
+        .describe("Window to open the tabs in. Omit to use the frontmost window."),
     activate: z
         .boolean()
         .default(false)
         .describe("If true, focus the last opened tab and bring its window to the front."),
-    browser: BrowserParam,
+    browser: browserField,
+}, async ({ browser, urls, windowId, activate }) => {
+    const ids = await chrome.openTabs(browser, urls, windowId, activate);
+    return `Opened ${ids.length} tab(s). New Tab IDs: ${ids.join(", ")}`;
 });
-const CreateWindowSchema = z.object({
+tool("close_tabs", "Close Tabs", "Close one or more tabs by Tab ID. Returns the title and URL of every closed tab (reopen with open_tabs) and any IDs that were not found (e.g. stale after a listing).", DESTRUCTIVE, { tabIds: tabIdsField, browser: browserField }, async ({ browser, tabIds }) => {
+    const closed = await chrome.closeTabs(browser, tabIds);
+    const missing = tabIds.filter((id) => !closed.some((t) => t.id === id));
+    return `Closed ${closed.length} tab(s).${missing.length ? ` Not found: ${missing.join(", ")}.` : ""}${formatClosed(closed)}`;
+});
+tool("close_window", "Close Window", "Close an entire window and all its tabs. Returns the title and URL of every tab that was in it (reopen with open_tabs).", DESTRUCTIVE, { windowId: windowIdField, browser: browserField }, async ({ browser, windowId }) => {
+    const { windows } = await chrome.getTabs(browser, windowId);
+    await chrome.closeWindow(browser, windowId);
+    return `Closed window [ID: ${windowId}]${formatClosed(windows.flatMap((w) => w.tabs))}`;
+});
+tool("create_window", "Create Window", "Open a new browser window, optionally in incognito mode.", WRITE, {
     mode: z
         .enum(["normal", "incognito"])
         .default("normal")
         .describe('Window mode: "normal" or "incognito".'),
-    browser: BrowserParam,
+    browser: browserField,
+}, async ({ browser, mode }) => `Created ${mode} window [ID: ${await chrome.createWindow(browser, mode)}]`);
+tool("activate_tab", "Activate Tab", "Bring a tab into focus.", { ...WRITE, idempotentHint: true }, { tabId: tabIdField, browser: browserField }, async ({ browser, tabId }) => {
+    await chrome.activateTab(browser, tabId);
+    return `Activated tab [Tab ID: ${tabId}]`;
+});
+// Reload can resubmit a POST or drop unsaved form input, so it is not a harmless read.
+tool("reload_tabs", "Reload Tabs", "Reload one or more tabs by Tab ID.", { ...DESTRUCTIVE, idempotentHint: true }, { tabIds: tabIdsField, browser: browserField }, async ({ browser, tabIds }) => {
+    await chrome.reloadTabs(browser, tabIds);
+    return `Reloaded ${tabIds.length} tab(s).`;
 });
-const NavigateTabSchema = z.object({
-    tabId: TabIdParam,
+tool("stop_tabs", "Stop Tabs", "Stop loading one or more tabs by Tab ID.", { ...WRITE, idempotentHint: true }, { tabIds: tabIdsField, browser: browserField }, async ({ browser, tabIds }) => {
+    await chrome.stopTabs(browser, tabIds);
+    return `Stopped ${tabIds.length} tab(s).`;
+});
+tool("go_back", "Go Back", "Navigate back in the tab's history.", WRITE, { tabId: tabIdField, browser: browserField }, async ({ browser, tabId }) => {
+    await chrome.goBack(browser, tabId);
+    return `Navigated back in tab [Tab ID: ${tabId}]`;
+});
+tool("go_forward", "Go Forward", "Navigate forward in the tab's history.", WRITE, { tabId: tabIdField, browser: browserField }, async ({ browser, tabId }) => {
+    await chrome.goForward(browser, tabId);
+    return `Navigated forward in tab [Tab ID: ${tabId}]`;
+});
+tool("navigate_tab", "Navigate Tab", "Change the URL of an existing tab.", { ...DESTRUCTIVE, openWorldHint: true }, {
+    tabId: tabIdField,
     url: z
         .string()
         .url()
         .describe("Fully-qualified URL to navigate the tab to, e.g. https://example.com"),
-    browser: BrowserParam,
+    browser: browserField,
+}, async ({ browser, tabId, url }) => {
+    await chrome.navigateTab(browser, tabId, url);
+    return `Navigated tab [Tab ID: ${tabId}] to ${url}`;
 });
-const ExecuteScriptSchema = z.object({
-    tabId: TabIdParam,
+tool("execute_script", "Execute Script", "Run JavaScript in a tab's page context. Requires Chrome's View > Developer > Allow JavaScript from Apple Events to be enabled.", { ...DESTRUCTIVE, openWorldHint: true }, {
+    tabId: tabIdField,
     javascript: z
         .string()
         .describe('JavaScript expression or statement(s) to run in the tab\'s page context. The return value is coerced to string via AppleScript. Returns "null" if the result is undefined or null. For complex return types (arrays, objects), wrap in JSON.stringify(...) to get valid JSON back.'),
-    browser: BrowserParam,
-});
-const SearchTabsSchema = z.object({
-    query: z.string().describe("Keyword to search for in tab titles and URLs."),
-    browser: BrowserParam,
-});
-const GetTabsSchema = z.object({ browser: BrowserParam });
-// ─── MCP server ───────────────────────────────────────────────────────────────
-const server = new Server({ name: "mcp-browser-buddy", version: "0.0.1" }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: "get_tabs",
-            description: "List every open tab across all windows.",
-            inputSchema: z.toJSONSchema(GetTabsSchema),
-            annotations: {
-                title: "Get Tabs",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "search_tabs",
-            description: "Search for tabs by keyword in title or URL.",
-            inputSchema: z.toJSONSchema(SearchTabsSchema),
-            annotations: {
-                title: "Search Tabs",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "get_active_tab",
-            description: "Get details about the currently focused tab in the frontmost window.",
-            inputSchema: z.toJSONSchema(GetTabsSchema),
-            annotations: {
-                title: "Get Active Tab",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "open_tabs",
-            description: "Open one or more URLs in new tabs.",
-            inputSchema: z.toJSONSchema(OpenTabsSchema),
-            annotations: {
-                title: "Open Tabs",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: true,
-            },
-        },
-        {
-            name: "close_tabs",
-            description: "Permanently close one or more tabs by Tab ID.",
-            inputSchema: z.toJSONSchema(BulkTabSchema),
-            annotations: {
-                title: "Close Tabs",
-                readOnlyHint: false,
-                destructiveHint: true,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "close_window",
-            description: "Close an entire window and all its tabs.",
-            inputSchema: z.toJSONSchema(CloseWindowSchema),
-            annotations: {
-                title: "Close Window",
-                readOnlyHint: false,
-                destructiveHint: true,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "create_window",
-            description: "Open a new browser window, optionally in incognito mode.",
-            inputSchema: z.toJSONSchema(CreateWindowSchema),
-            annotations: {
-                title: "Create Window",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "activate_tab",
-            description: "Bring a tab into focus.",
-            inputSchema: z.toJSONSchema(TabIdSchema),
-            annotations: {
-                title: "Activate Tab",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "reload_tabs",
-            description: "Reload one or more tabs by Tab ID.",
-            inputSchema: z.toJSONSchema(BulkTabSchema),
-            annotations: {
-                title: "Reload Tabs",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "stop_tabs",
-            description: "Stop loading one or more tabs by Tab ID.",
-            inputSchema: z.toJSONSchema(BulkTabSchema),
-            annotations: {
-                title: "Stop Tabs",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "go_back",
-            description: "Navigate back in the tab's history.",
-            inputSchema: z.toJSONSchema(TabIdSchema),
-            annotations: {
-                title: "Go Back",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "go_forward",
-            description: "Navigate forward in the tab's history.",
-            inputSchema: z.toJSONSchema(TabIdSchema),
-            annotations: {
-                title: "Go Forward",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "navigate_tab",
-            description: "Change the URL of an existing tab.",
-            inputSchema: z.toJSONSchema(NavigateTabSchema),
-            annotations: {
-                title: "Navigate Tab",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: true,
-            },
-        },
-        {
-            name: "execute_script",
-            description: "Run JavaScript in a tab's page context.",
-            inputSchema: z.toJSONSchema(ExecuteScriptSchema),
-            annotations: {
-                title: "Execute Script",
-                readOnlyHint: false,
-                destructiveHint: true,
-                idempotentHint: false,
-                openWorldHint: true,
-            },
-        },
-    ],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        const { name, arguments: args = {} } = request.params;
-        if (name === "get_tabs") {
-            const { browser } = GetTabsSchema.parse(args);
-            const windows = await getTabs(browser);
-            const totalTabs = windows.reduce((n, w) => n + w.tabs.length, 0);
-            const humanReadable = windows
-                .map((w) => {
-                const incognito = w.mode === "incognito" ? " [incognito]" : "";
-                const nameStr = w.windowName ? ` (${w.windowName})` : "";
-                const header = `Window ${w.windowIndex}${nameStr}${incognito} [ID: ${w.windowId}]:`;
-                const tabLines = w.tabs
-                    .map((t) => {
-                    const active = t.isActive ? " ★" : "";
-                    const loading = t.loading ? " [loading]" : "";
-                    return [
-                        `  ${w.windowIndex}-${t.tabIndex}.${active} ${t.title}${loading}`,
-                        `     ${t.url}`,
-                        `     [Tab ID: ${t.id}]`,
-                    ].join("\n");
-                })
-                    .join("\n");
-                return `${header}\n${tabLines}`;
-            })
-                .join("\n\n");
-            const tabsJson = windows.flatMap((w) => w.tabs.map((t) => ({
-                tabId: t.id,
-                windowId: w.windowId,
-                windowIndex: w.windowIndex,
-                windowName: w.windowName,
-                tabIndex: t.tabIndex,
-                windowMode: w.mode,
-                title: t.title,
-                url: t.url,
-                active: t.isActive,
-                loading: t.loading,
-            })));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `${totalTabs} tab(s) open in ${browser}:`,
-                            "",
-                            humanReadable,
-                            "",
-                            "---",
-                            "Use tabId from tabs_json for all tab operations.",
-                            "<tabs_json>",
-                            JSON.stringify(tabsJson, null, 2),
-                            "</tabs_json>",
-                        ].join("\n"),
-                    },
-                ],
-            };
-        }
-        if (name === "search_tabs") {
-            const { query, browser } = SearchTabsSchema.parse(args);
-            const windows = await getTabs(browser);
-            const q = query.toLowerCase();
-            const results = windows
-                .flatMap((w) => w.tabs.map((t) => ({ ...t, windowName: w.windowName, windowMode: w.mode })))
-                .filter((t) => t.title.toLowerCase().includes(q) || t.url.toLowerCase().includes(q));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `Found ${results.length} tab(s) matching "${query}":`,
-                            "",
-                            results
-                                .map((t) => `  - ${t.title}\n     ${t.url}\n     [Tab ID: ${t.id}]`)
-                                .join("\n\n"),
-                            "",
-                            "<tabs_json>",
-                            JSON.stringify(results, null, 2),
-                            "</tabs_json>",
-                        ].join("\n"),
-                    },
-                ],
-            };
-        }
-        if (name === "get_active_tab") {
-            const { browser } = GetTabsSchema.parse(args);
-            const tab = await getActiveTab(browser);
-            if (!tab)
-                return { content: [{ type: "text", text: "No active window found." }] };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            "Active tab in frontmost window:",
-                            `  ${tab.title}`,
-                            `  ${tab.url}`,
-                            `  [Tab ID: ${tab.id}] [Window ID: ${tab.windowId}]`,
-                            "",
-                            "<tabs_json>",
-                            JSON.stringify([tab], null, 2),
-                            "</tabs_json>",
-                        ].join("\n"),
-                    },
-                ],
-            };
-        }
-        if (name === "open_tabs") {
-            const { urls, windowId, activate, browser } = OpenTabsSchema.parse(args);
-            const newTabIds = await openTabs(browser, urls, windowId, activate);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Opened ${newTabIds.length} tab(s). New Tab IDs: ${newTabIds.join(", ")}`,
-                    },
-                ],
-            };
-        }
-        if (name === "close_tabs") {
-            const { tabIds, browser } = BulkTabSchema.parse(args);
-            const { count } = await closeTabs(browser, tabIds);
-            return { content: [{ type: "text", text: `Closed ${count} tab(s).` }] };
-        }
-        if (name === "close_window") {
-            const { windowId, browser } = CloseWindowSchema.parse(args);
-            await closeWindow(browser, windowId);
-            return { content: [{ type: "text", text: `Closed window [ID: ${windowId}]` }] };
-        }
-        if (name === "create_window") {
-            const { mode, browser } = CreateWindowSchema.parse(args);
-            const windowId = await createWindow(browser, mode);
-            return {
-                content: [{ type: "text", text: `Created ${mode} window [ID: ${windowId}]` }],
-            };
-        }
-        if (name === "activate_tab") {
-            const { tabId, browser } = TabIdSchema.parse(args);
-            await activateTab(browser, tabId);
-            return { content: [{ type: "text", text: `Activated tab [Tab ID: ${tabId}]` }] };
-        }
-        if (name === "reload_tabs") {
-            const { tabIds, browser } = BulkTabSchema.parse(args);
-            await reloadTabs(browser, tabIds);
-            return { content: [{ type: "text", text: `Reloaded ${tabIds.length} tab(s).` }] };
-        }
-        if (name === "stop_tabs") {
-            const { tabIds, browser } = BulkTabSchema.parse(args);
-            await stopTabs(browser, tabIds);
-            return { content: [{ type: "text", text: `Stopped ${tabIds.length} tab(s).` }] };
-        }
-        if (name === "go_back") {
-            const { tabId, browser } = TabIdSchema.parse(args);
-            await goBack(browser, tabId);
-            return {
-                content: [{ type: "text", text: `Navigated back in tab [Tab ID: ${tabId}]` }],
-            };
-        }
-        if (name === "go_forward") {
-            const { tabId, browser } = TabIdSchema.parse(args);
-            await goForward(browser, tabId);
-            return {
-                content: [{ type: "text", text: `Navigated forward in tab [Tab ID: ${tabId}]` }],
-            };
-        }
-        if (name === "navigate_tab") {
-            const { tabId, url, browser } = NavigateTabSchema.parse(args);
-            await navigateTab(browser, tabId, url);
-            return {
-                content: [{ type: "text", text: `Navigated tab [Tab ID: ${tabId}] to ${url}` }],
-            };
-        }
-        if (name === "execute_script") {
-            const { tabId, javascript, browser } = ExecuteScriptSchema.parse(args);
-            const result = await executeScript(browser, tabId, javascript);
-            return { content: [{ type: "text", text: result }] };
-        }
-        throw new Error(`Unknown tool: ${name}`);
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
+    browser: browserField,
+}, async ({ browser, tabId, javascript }) => chrome.executeScript(browser, tabId, javascript));
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    await server.connect(new StdioServerTransport());
     console.error("mcp-browser-buddy running on stdio");
 }
 main().catch((err) => {