2manytabs-mcp-host 2.0.0 → 3.0.0

package/bridge.js

@@ -1,41 +1,21 @@
-// 2ManyTabs MCP – Extension Bridge (self-organizing, multi-host)
-//
-// Why this exists
-// ----------------
-// MCP-over-stdio is 1:1 by design: every client (each Hermes instance, the
-// mcpjam inspector) spawns its OWN host.js and owns that process's stdio pipes.
-// That part is correct. The catch is one layer down — all those independent
-// hosts reach for a SINGLE shared resource: there is one browser, one extension,
-// one port (9876), one set of tabs. N MCP servers, a rank-1 resource.
-//
-// Previously the first host to start bound 9876 and every other host's tab tools
-// failed with "extension not connected". Worse, the winner was often a stale
-// session's host, so the session you were actually using couldn't see the tabs.
-//
-// Fix: the hosts self-organize onto the shared resource instead of fighting over it.
-//   • Exactly one host binds 9876 and owns the extension socket  → the OWNER.
-//   • Every other host connects to the owner and proxies its calls → a FOLLOWER.
-//   • If the owner dies, followers race to re-bind; one becomes the new owner and
-//     the extension reconnects to it. No external daemon, no config, and the
-//     extension never knows the difference.
-//
-//   Hermes A ─stdio▶ host(OWNER)    ─ws:9876──────▶ extension ─▶ browser tabs
-//   Hermes B ─stdio▶ host(FOLLOWER) ─ws:9876/peer─▶ OWNER ─────┘
-//
-// Public API is unchanged: startBridge(), callExtension(), isExtensionConnected().
-
 import http                         from 'http';
 import { WebSocketServer, WebSocket } from 'ws';
 
-const WS_PORT         = Number(process.env.MANYTABS_BRIDGE_PORT) || 9876; // env override is a test seam; the extension uses 9876
-const PEER_PATH       = '/peer';        // followers connect here; the extension connects to '/'
+const WS_PORT         = Number(process.env.MANYTABS_BRIDGE_PORT) || 9876;
+const PEER_PATH       = '/peer';
 const CALL_TIMEOUT_MS = 10_000;
-const ROUTE_GRACE_MS  = 3_500;          // absorb brief owner↔follower failover before erroring
+const ROUTE_GRACE_MS  = 3_500;
+
+const ALLOWED_EXTENSION_ORIGIN_PREFIXES = ['chrome-extension://', 'moz-extension://'];
 
 const EXT_NOT_CONNECTED_MSG =
-  'Chrome extension is not connected. Load the 2ManyTabs MCP extension in your browser ' +
+  'Browser extension is not connected. Load the 2ManyTabs MCP extension in Chrome or Firefox ' +
   'and confirm its popup shows "Connected".';
 
+const CHROME_NO_SCRIPTING_MSG =
+  'Sorry, scripting is not available in Chrome: its extension rules block running script text. ' +
+  'Open the page in Firefox and use its firefox: tab id instead.';
+
 const PNA_HEADERS = {
   'Access-Control-Allow-Origin':          '*',
   'Access-Control-Allow-Private-Network': 'true',
@@ -43,50 +23,36 @@ const PNA_HEADERS = {
   'Access-Control-Allow-Methods':         'GET, OPTIONS',
 };
 
-// ---------------------------------------------------------------------------
-// Module state
-// ---------------------------------------------------------------------------
-
-let role            = 'starting';   // 'starting' | 'owner' | 'follower'
+let role            = 'starting';
 let bindInProgress  = false;
 
-// OWNER state -------------------------------------------------------
-let extensionSocket = null;         // the browser extension's socket
-const peerClients   = new Set();    // connected follower sockets
-let wireId          = 0;            // id for requests we send to the extension
-const inflight      = new Map();    // wireId → delivery descriptor (local or peer)
+const extensionClients = new Map();
+const peerClients      = new Set();
+let wireId             = 0;
+const inflight         = new Map();
+const tabClientIndex   = new Map();
+const groupClientIndex = new Map();
 
-// FOLLOWER state ----------------------------------------------------
-let peerSocket      = null;         // our client connection to the owner
-let proxyId         = 0;            // id for requests we send to the owner
-const proxyPending  = new Map();    // proxyId → { resolve, reject, timer }
+let peerSocket      = null;
+let proxyId         = 0;
+const proxyPending  = new Map();
 
-// Calls parked until a usable route appears (covers cold start / failover).
 const readyWaiters  = [];
 
 function log(msg) {
-  // stderr only — stdout is reserved for the MCP stdio transport.
   process.stderr.write(`[2manytabs-mcp] ${msg}\n`);
 }
 
-// ---------------------------------------------------------------------------
-// Entry point
-// ---------------------------------------------------------------------------
-
 export function startBridge() {
   attemptBind();
 }
 
-// ---------------------------------------------------------------------------
-// OWNER: try to bind 9876. Win → own the extension. Lose (EADDRINUSE) → follow.
-// ---------------------------------------------------------------------------
-
 function attemptBind() {
   if (bindInProgress || role === 'owner') return;
   bindInProgress = true;
 
   const httpServer = http.createServer((req, res) => {
-    if (req.method === 'OPTIONS') {            // PNA preflight before the WS upgrade
+    if (req.method === 'OPTIONS') {
       res.writeHead(204, PNA_HEADERS);
       res.end();
       return;
@@ -98,7 +64,6 @@ function attemptBind() {
   httpServer.on('error', (err) => {
     bindInProgress = false;
     if (err.code === 'EADDRINUSE') {
-      // Another host already owns the bridge — expected with multiple sessions. Follow it.
       log(`Port ${WS_PORT} already owned by another host — joining as a follower.`);
       becomeFollower();
     } else {
@@ -118,8 +83,6 @@ function attemptBind() {
     const origin = req.headers.origin || '';
 
     if (req.url === PEER_PATH) {
-      // Follower connections must be node-to-node and should not have a browser origin.
-      // Standard browsers will always send an Origin header for web-based requests.
       if (origin) {
         log(`Rejected peer connection from non-node origin: ${origin}`);
         socket.close(4003, 'Forbidden origin');
@@ -127,29 +90,58 @@ function attemptBind() {
       }
       handlePeerConnection(socket);
     } else {
-      // Extension connections must originate from a chrome-extension:// URI.
-      if (!origin.startsWith('chrome-extension://')) {
+      if (!ALLOWED_EXTENSION_ORIGIN_PREFIXES.some(prefix => origin.startsWith(prefix))) {
         log(`Rejected extension connection from unauthorized origin: ${origin}`);
         socket.close(4003, 'Unauthorized origin');
         return;
       }
-      handleExtensionConnection(socket);
+      handleExtensionConnection(socket, req);
     }
   });
 
   httpServer.listen(WS_PORT, '127.0.0.1', () => {
     bindInProgress = false;
     role = 'owner';
-    peerSocket = null;        // shed any stale follower state from a prior life
+    peerSocket = null;
     log(`Bridge OWNER listening on ws://127.0.0.1:${WS_PORT}`);
     log('Waiting for browser extension...');
   });
 }
 
-function handleExtensionConnection(socket) {
-  extensionSocket = socket;
-  log('Extension connected');
+function handleExtensionConnection(socket, req) {
+  const origin = req.headers.origin || '';
+  let browser = origin.startsWith('moz-extension://') ? 'firefox' : 'chrome';
+  let name = browser === 'firefox' ? 'Firefox' : 'Chrome';
+  let clientId = `${browser}_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+
+  try {
+    const parsedUrl = new URL(req.url, 'http://127.0.0.1');
+    const browserQuery = parsedUrl.searchParams.get('browser');
+    const nameQuery = parsedUrl.searchParams.get('name');
+    const instanceQuery = parsedUrl.searchParams.get('instance');
+
+    if (browserQuery) browser = browserQuery.toLowerCase();
+    if (nameQuery) name = nameQuery;
+    else if (browser === 'firefox') name = 'Firefox';
+    else if (browser === 'chrome') name = 'Chrome';
+
+    if (instanceQuery) clientId = instanceQuery;
+  } catch {
+  }
+
+  const client = {
+    id: clientId,
+    socket,
+    browser,
+    name,
+    origin,
+    connectedAt: Date.now(),
+  };
+
+  extensionClients.set(clientId, client);
+  log(`Extension connected: ${name} (${browser}) [${clientId}]. Total active: ${extensionClients.size}`);
   flushReady();
+  broadcastStatus();
 
   socket.on('message', (raw) => {
     let msg;
@@ -158,63 +150,248 @@ function handleExtensionConnection(socket) {
     if (!d) return;
     clearTimeout(d.timer);
     inflight.delete(msg.id);
-    deliver(d, msg.result, msg.error);
+    if (msg.error) d.reject(new Error(msg.error));
+    else           d.resolve(msg.result);
   });
 
   socket.on('close', () => {
-    if (extensionSocket === socket) {
-      extensionSocket = null;
-      log('Extension disconnected');
+    const replaced = extensionClients.has(clientId) && extensionClients.get(clientId).socket !== socket;
+    if (!replaced) extensionClients.delete(clientId);
+    for (const [id, d] of inflight.entries()) {
+      if (d.socket === socket) {
+        clearTimeout(d.timer);
+        inflight.delete(id);
+        d.reject(new Error(`Extension connection lost: ${name}`));
+      }
     }
+    if (!replaced) {
+      for (const index of [tabClientIndex, groupClientIndex]) forgetClient(index, clientId);
+    }
+    log(`Extension disconnected: ${name} [${clientId}]. Remaining: ${extensionClients.size}`);
+    broadcastStatus();
   });
-  socket.on('error', () => { /* close handles cleanup */ });
+
+  socket.on('error', () => { });
 }
 
 function handlePeerConnection(socket) {
   peerClients.add(socket);
   log(`Follower host connected (${peerClients.size} active)`);
+  broadcastStatus();
 
-  socket.on('message', (raw) => {
+  socket.on('message', async (raw) => {
     let msg;
     try { msg = JSON.parse(raw); } catch { return; }
     if (msg.type !== 'call') return;
-    forwardToExtension(msg.action, msg.params, { kind: 'peer', socket, peerReqId: msg.peerReqId });
+    try {
+      const result = await routeCall(msg.action, msg.params, [...peerClients].indexOf(socket) + 1);
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify({ type: 'reply', peerReqId: msg.peerReqId, result }));
+      }
+    } catch (err) {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify({ type: 'reply', peerReqId: msg.peerReqId, error: err.message }));
+      }
+    }
   });
 
-  socket.on('close', () => { peerClients.delete(socket); });
-  socket.on('error', () => { /* close handles cleanup */ });
+  socket.on('close', () => {
+    peerClients.delete(socket);
+    broadcastStatus();
+  });
+  socket.on('error', () => { });
 }
 
-// Send one request to the extension on behalf of a local caller or a follower.
-function forwardToExtension(action, params, descriptor) {
-  if (!extensionSocket || extensionSocket.readyState !== WebSocket.OPEN) {
-    deliver(descriptor, undefined, EXT_NOT_CONNECTED_MSG);
-    return;
+function deliver(client, action, params = {}, agent = 0) {
+  return new Promise((resolve, reject) => {
+    if (!client?.socket || client.socket.readyState !== WebSocket.OPEN) {
+      return reject(new Error(EXT_NOT_CONNECTED_MSG));
+    }
+    const id = ++wireId;
+    const timer = setTimeout(() => {
+      inflight.delete(id);
+      reject(new Error('Timed out waiting for browser extension response (10s).'));
+    }, CALL_TIMEOUT_MS);
+    inflight.set(id, { socket: client.socket, resolve, reject, timer });
+    client.socket.send(JSON.stringify({ id, action, ...params }));
+    broadcastActivity(client.id, action, agent);
+  });
+}
+
+function broadcastActivity(target, action, agent) {
+  const msg = JSON.stringify({ type: 'activity', target, action, agent, at: Date.now() });
+  for (const c of getActiveClients()) c.socket.send(msg);
+}
+
+function broadcastStatus() {
+  const clients = getActiveClients();
+  const browsers = clients.map((c) => ({ id: c.id, browser: c.browser, name: c.name }));
+  const agents = 1 + peerClients.size;
+  for (const c of clients) {
+    c.socket.send(JSON.stringify({ type: 'status', self: c.id, agents, browsers }));
+  }
+}
+
+function getActiveClients() {
+  return Array.from(extensionClients.values()).filter(c => c.socket.readyState === WebSocket.OPEN);
+}
+
+function forgetClient(index, clientId) {
+  for (const [key, owners] of index) {
+    owners.delete(clientId);
+    if (owners.size === 0) index.delete(key);
   }
-  const id = ++wireId;
-  descriptor.timer = setTimeout(() => {
-    inflight.delete(id);
-    deliver(descriptor, undefined, 'Timed out waiting for browser extension response (10s).');
-  }, CALL_TIMEOUT_MS);
-  inflight.set(id, descriptor);
-  extensionSocket.send(JSON.stringify({ id, action, ...(params || {}) }));
 }
 
-// Deliver an extension result back to wherever the request came from.
-function deliver(descriptor, result, error) {
-  if (descriptor.kind === 'local') {
-    if (error) descriptor.reject(new Error(error));
-    else       descriptor.resolve(result);
-  } else { // 'peer'
-    if (descriptor.socket.readyState === WebSocket.OPEN) {
-      descriptor.socket.send(JSON.stringify({ type: 'reply', peerReqId: descriptor.peerReqId, result, error }));
+function noteOwner(index, id, clientId) {
+  if (!index.has(id)) index.set(id, new Set());
+  index.get(id).add(clientId);
+}
+
+function resolveTarget(rawId, browserHint, index, kind = 'tab') {
+  const clients = getActiveClients();
+  if (clients.length === 0) throw new Error(EXT_NOT_CONNECTED_MSG);
+
+  let prefix = null;
+  let idPart = rawId;
+  if (typeof rawId === 'string' && rawId.includes(':')) {
+    const at = rawId.lastIndexOf(':');
+    prefix = rawId.slice(0, at);
+    idPart = rawId.slice(at + 1);
+  }
+  const cleanId = Number(idPart);
+  if (!Number.isInteger(cleanId)) throw new Error(`Invalid ${kind} id: ${rawId}`);
+
+  const want = prefix ?? browserHint;
+  if (want) {
+    const w = want.toLowerCase();
+    const matches = clients.filter((c) => c.id === want || c.browser === w);
+    if (matches.length === 1) return { client: matches[0], cleanId };
+    if (matches.length === 0) {
+      throw new Error(`No connected browser matches "${want}" for ${kind} ${rawId}. Connected: ${clients.map((c) => c.browser).join(', ')}.`);
     }
+    const owners = [...(index.get(cleanId) ?? [])].filter((id) => matches.some((c) => c.id === id));
+    if (owners.length === 1) return { client: extensionClients.get(owners[0]), cleanId };
+    throw new Error(`${kind} ${rawId} is ambiguous across ${matches.length} ${w} instances; use "<instance>:${cleanId}".`);
+  }
+
+  if (clients.length === 1) return { client: clients[0], cleanId };
+
+  const owners = [...(index.get(cleanId) ?? [])].filter((id) => extensionClients.get(id)?.socket.readyState === WebSocket.OPEN);
+  if (owners.length === 1) return { client: extensionClients.get(owners[0]), cleanId };
+  const hint = clients.map((c) => `"${c.browser}:${cleanId}"`).join(' or ');
+  throw new Error(owners.length > 1
+    ? `${kind} id ${cleanId} exists in more than one browser; use ${hint}.`
+    : `Unknown ${kind} id ${cleanId} with several browsers connected; run list_tabs first or use ${hint}.`);
+}
+
+function batchByClient(rawIds, browserHint) {
+  const batches = new Map();
+  for (const rawId of rawIds) {
+    const { client, cleanId } = resolveTarget(rawId, browserHint, tabClientIndex);
+    if (!batches.has(client)) batches.set(client, []);
+    batches.get(client).push(cleanId);
+  }
+  return batches;
+}
+
+async function fanOut(action, params, clients, onItem, onClient, agent = 0) {
+  const results = await Promise.allSettled(clients.map((c) => deliver(c, action, params, agent)));
+  if (clients.length === 1 && results[0].status === 'fulfilled' && !Array.isArray(results[0].value)) {
+    return results[0].value;
   }
+  const failed = results.filter((res) => res.status === 'rejected');
+  if (failed.length === results.length) throw failed[0].reason;
+  const all = [];
+  results.forEach((res, i) => {
+    if (res.status !== 'fulfilled' || !Array.isArray(res.value)) return;
+    onClient?.(clients[i]);
+    for (const item of res.value) {
+      onItem(item, clients[i]);
+      all.push(item);
+    }
+  });
+  return all;
+}
+
+function withoutBrowser(params, extra) {
+  const out = { ...params, ...extra };
+  delete out.browser;
+  return out;
 }
 
-// ---------------------------------------------------------------------------
-// FOLLOWER: proxy calls to the owner; re-elect if the owner vanishes.
-// ---------------------------------------------------------------------------
+async function routeCall(action, params = {}, agent = 0) {
+  const sendToClient = (c, a, p) => deliver(c, a, p, agent);
+  const clients = getActiveClients();
+  if (clients.length === 0) {
+    throw new Error(EXT_NOT_CONNECTED_MSG);
+  }
+
+  if (action === 'query_tabs') {
+    return fanOut(action, params, clients, (tab, client) => {
+      tab.browser = client.browser;
+      tab.browserInstance = client.id;
+      tab.browserName = client.name;
+      noteOwner(tabClientIndex, tab.id, client.id);
+    }, (client) => forgetClient(tabClientIndex, client.id), agent);
+  }
+
+  if (action === 'query_groups') {
+    return fanOut(action, params, clients, (grp, client) => {
+      grp.browser = client.browser;
+      grp.browserInstance = client.id;
+      noteOwner(groupClientIndex, grp.id, client.id);
+    }, (client) => forgetClient(groupClientIndex, client.id), agent);
+  }
+
+  if (action === 'group_tabs') {
+    const batches = batchByClient(params.tab_ids, params.browser);
+    let groupTarget = null;
+    if (params.group_id !== undefined) {
+      groupTarget = resolveTarget(params.group_id, params.browser, groupClientIndex, 'group');
+      batches.set(groupTarget.client, batches.get(groupTarget.client) ?? []);
+    }
+    if (batches.size > 1) throw new Error('Cannot group tabs from different browsers into one group.');
+    const [[client, ids]] = batches;
+    const res = await sendToClient(client, action, withoutBrowser(params, { tab_ids: ids, group_id: groupTarget?.cleanId }));
+    if (res && typeof res.groupId === 'number') noteOwner(groupClientIndex, res.groupId, client.id);
+    return res;
+  }
+
+  if (action === 'update_group') {
+    const { client, cleanId } = resolveTarget(params.group_id, params.browser, groupClientIndex, 'group');
+    return sendToClient(client, action, withoutBrowser(params, { group_id: cleanId }));
+  }
+
+  if (Array.isArray(params.tab_ids)) {
+    const sumKey = action === 'close_tabs' ? 'closed' : action === 'ungroup_tabs' ? 'ungrouped' : null;
+    const batches = batchByClient(params.tab_ids, params.browser);
+    if (!sumKey && batches.size > 1) throw new Error(`${action} cannot span browsers.`);
+    let total = 0;
+    let last;
+    for (const [client, ids] of batches) {
+      last = await sendToClient(client, action, withoutBrowser(params, { tab_ids: ids }));
+      if (sumKey && typeof last?.[sumKey] === 'number') total += last[sumKey];
+    }
+    return sumKey ? { ...last, [sumKey]: total } : last;
+  }
+
+  if (params.tab_id !== undefined) {
+    const { client, cleanId } = resolveTarget(params.tab_id, params.browser, tabClientIndex);
+    if (action === 'execute_script' && client.browser === 'chrome') {
+      throw new Error(CHROME_NO_SCRIPTING_MSG);
+    }
+    return sendToClient(client, action, withoutBrowser(params, { tab_id: cleanId }));
+  }
+
+  if (params.browser) {
+    const match = clients.find(c => c.browser === params.browser.toLowerCase() || c.id === params.browser);
+    if (!match) throw new Error(`No connected browser matches "${params.browser}".`);
+    return sendToClient(match, action, withoutBrowser(params));
+  }
+
+  return sendToClient(clients[0], action, params);
+}
 
 function becomeFollower() {
   role = 'follower';
@@ -252,14 +429,11 @@ function connectPeer() {
   socket.on('close', () => {
     if (peerSocket === socket) peerSocket = null;
     failProxyPending();
-    scheduleReElection();   // owner may have died — try to take over
+    scheduleReElection();
   });
-  socket.on('error', () => { /* close follows */ });
+  socket.on('error', () => { });
 }
 
-// The owner connection dropped. After a little jitter (to avoid a thundering
-// herd of followers), try to become the owner. Whoever wins the port wins;
-// the rest will EADDRINUSE and fall back to following the new owner.
 function scheduleReElection() {
   const delay = 200 + Math.floor(Math.random() * 300);
   setTimeout(() => {
@@ -292,15 +466,14 @@ function failProxyPending() {
   proxyPending.clear();
 }
 
-// ---------------------------------------------------------------------------
-// Routing readiness — a call needs a live route (owner+extension, or
-// follower+owner). In steady state this resolves instantly; during a cold
-// start or a brief failover it parks the call up to ROUTE_GRACE_MS.
-// ---------------------------------------------------------------------------
-
 function hasRoute() {
-  if (role === 'owner')    return !!extensionSocket && extensionSocket.readyState === WebSocket.OPEN;
-  if (role === 'follower') return !!peerSocket      && peerSocket.readyState      === WebSocket.OPEN;
+  if (role === 'owner') {
+    for (const client of extensionClients.values()) {
+      if (client.socket.readyState === WebSocket.OPEN) return true;
+    }
+    return false;
+  }
+  if (role === 'follower') return !!peerSocket && peerSocket.readyState === WebSocket.OPEN;
   return false;
 }
 
@@ -327,16 +500,10 @@ function waitForRoute() {
   });
 }
 
-// ---------------------------------------------------------------------------
-// Public primitive used by every tool.
-// ---------------------------------------------------------------------------
-
 export async function callExtension(action, params = {}) {
-  const activeRole = await waitForRoute();          // throws the clear error after the grace window
+  const activeRole = await waitForRoute();
   if (activeRole === 'owner') {
-    return new Promise((resolve, reject) => {
-      forwardToExtension(action, params, { kind: 'local', resolve, reject });
-    });
+    return routeCall(action, params);
   }
   return followerCall(action, params);
 }
@@ -345,11 +512,12 @@ export function isExtensionConnected() {
   return hasRoute();
 }
 
-// Lightweight introspection for logging / a future status tool.
 export function bridgeStatus() {
+  const clients = getActiveClients();
   return {
     role,
-    extension_connected: !!extensionSocket && extensionSocket.readyState === WebSocket.OPEN,
+    extension_connected: clients.length > 0,
+    clients: clients.map(c => ({ id: c.id, browser: c.browser, name: c.name })),
     followers: peerClients.size,
     owner_reachable: role === 'follower' ? (!!peerSocket && peerSocket.readyState === WebSocket.OPEN) : undefined,
   };

package/host.js

@@ -1,31 +1,19 @@
 #!/usr/bin/env node
-// 2ManyTabs MCP – Host (MCP server over stdio)
-//
-//   Hermes ─stdio(JSON-RPC)─▶ host.js ─ws/127.0.0.1:9876─▶ background.js ─▶ chrome.tabs
-//
-// Architecture mirrors gemini-mcp-tool's "unified tool" pattern: one self-contained
-// file per tool, collected in tools/index.js. The difference — and the point of this
-// rewrite — is that SDK 1.x's McpServer.registerTool() absorbs the hand-rolled
-// registry.ts (zod-to-json-schema, getToolDefinitions, executeTool, manual Zod parsing)
-// that the 0.5-era SDK forced us to write. We keep the modular philosophy; the SDK
-// keeps the boilerplate.
-
-import { McpServer }            from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { startBridge }          from './bridge.js';
-import { toolRegistry }         from './tools/index.js';
+import { startBridge } from './bridge.js';
+import { toolRegistry } from './tools/index.js';
 
-const server = new McpServer({ name: '2manytabs-mcp', version: '2.0.0' });
+const server = new McpServer({ name: '2manytabs-mcp', version: '3.0.0' });
 
-// Register every tool generically. Adding a tool requires zero changes here.
 for (const tool of toolRegistry) {
   server.registerTool(
     tool.name,
     {
-      title:       tool.title,
+      title: tool.title,
       description: tool.description,
-      inputSchema: tool.inputSchema,   // raw Zod shape — SDK derives JSON Schema + validates
-      annotations: tool.annotations,    // readOnly/destructive hints (new in modern MCP)
+      inputSchema: tool.inputSchema,
+      annotations: tool.annotations,
     },
     async (args) => {
       try {
@@ -41,14 +29,12 @@ for (const tool of toolRegistry) {
   );
 }
 
-// Bring up the extension bridge, then connect MCP over stdio.
 startBridge();
 
 const transport = new StdioServerTransport();
 await server.connect(transport);
 process.stderr.write(`[2manytabs-mcp] MCP server ready (${toolRegistry.length} tools) on stdio\n`);
 
-// Ensure clean exit when the parent process disconnects or terminates
 const cleanup = () => process.exit(0);
 process.stdin.on('close', cleanup);
 process.stdin.on('end', cleanup);