2manytabs-mcp-host 2.1.0 → 3.0.0

package/package.json

@@ -1,12 +1,32 @@
 {
   "name": "2manytabs-mcp-host",
-  "version": "2.1.0",
-  "description": "MCP server that exposes Chrome tabs via the 2ManyTabs MCP extension",
+  "version": "3.0.0",
+  "description": "MCP server that exposes Chrome and Firefox tabs via the 2ManyTabs MCP extension",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "claude",
+    "ai-agent",
+    "browser",
+    "tabs",
+    "tab-manager",
+    "tab-groups",
+    "browser-automation",
+    "chrome-extension",
+    "firefox-extension",
+    "librewolf"
+  ],
   "type": "module",
   "main": "host.js",
   "bin": {
     "2manytabs-mcp": "host.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jamubc/2ManyTabs-MCP.git"
+  },
+  "homepage": "https://github.com/jamubc/2ManyTabs-MCP#readme",
   "files": [
     "host.js",
     "bridge.js",
@@ -16,7 +36,10 @@
   "scripts": {
     "start": "node host.js",
     "test":  "node --test lib/tabs.test.js lib/background.test.js",
-    "lint":  "eslint ."
+    "test:multibrowser": "MANYTABS_BRIDGE_PORT=19878 node test/multibrowser.js",
+    "lint":  "eslint .",
+    "prepack": "cp ../README.md ../LICENSE .",
+    "postpack": "rm -f README.md LICENSE"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",

package/tools/activate-tab.tool.js

@@ -14,12 +14,14 @@ export const activateTabTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_id: z.number().int()
-      .describe('The numeric ID of the tab to activate.'),
+    tab_id: z.union([z.number().int(), z.string()])
+      .describe('The numeric ID of the tab (or composite like "chrome:123") to activate.'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if tab_id is numeric.'),
   },
 
-  execute: async ({ tab_id }) => {
-    const res = await callExtension('activate_tab', { tab_id });
+  execute: async ({ tab_id, browser }) => {
+    const res = await callExtension('activate_tab', { tab_id, browser });
     return JSON.stringify({
       message: `Successfully activated tab ${tab_id}.`,
       tabId: res.activated,

package/tools/close-tabs.tool.js

@@ -6,7 +6,7 @@ export const closeTabsTool = {
   name: 'close_tabs',
   title: 'Close Tabs',
   description:
-    'Close Chrome tabs by one selection mode: `tab_ids` (explicit), `match` (substring of ' +
+    'Close browser tabs by one selection mode: `tab_ids` (explicit), `match` (substring of ' +
     'title/URL), or `duplicates` (every tab sharing a URL with an earlier one). Set `dry_run` ' +
     'to preview the exact tabs that would close without touching them. Destructive — closed ' +
     'tabs cannot be recovered through this tool.\n\n' +
@@ -30,18 +30,19 @@ export const closeTabsTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_ids: z.array(z.number().int()).optional()
-      .describe('Explicit tab IDs to close (from list_tabs).'),
+    tab_ids: z.array(z.union([z.number().int(), z.string()])).optional()
+      .describe('Explicit tab IDs to close (numbers or composite like "chrome:123" from list_tabs).'),
     match: z.string().optional()
       .describe('Close every tab whose title or URL contains this substring (case-insensitive).'),
     duplicates: z.boolean().default(false)
       .describe('Close duplicate tabs, keeping the first occurrence of each URL.'),
     dry_run: z.boolean().default(false)
       .describe('Preview the tabs that would close — does not close anything. Recommended for bulk closes.'),
+    browser: z.string().optional()
+      .describe('Optional browser filter ("chrome", "firefox") to limit close actions to a single browser.'),
   },
 
-  execute: async ({ tab_ids, match, duplicates, dry_run }) => {
-    // Enforce exactly one selection mode.
+  execute: async ({ tab_ids, match, duplicates, dry_run, browser }) => {
     const modes = [tab_ids?.length ? 'tab_ids' : null, match ? 'match' : null, duplicates ? 'duplicates' : null]
       .filter(Boolean);
     if (modes.length === 0) {
@@ -58,13 +59,30 @@ export const closeTabsTool = {
       console.error('Failed to fetch tabs:', err);
       throw new Error('Failed to fetch open tabs from extension.');
     }
+    if (browser) {
+      all = all.filter((t) => (t.browser || '').toLowerCase() === browser.toLowerCase());
+    }
+
     const byId = new Map(all.map((t) => [t.id, t]));
+    const byComposite = new Map(all.map((t) => [`${t.browser}:${t.id}`, t]));
 
     let targets, reason;
     if (tab_ids?.length) {
-      targets = tab_ids.filter((id) => byId.has(id)).map((id) => byId.get(id));
+      targets = [];
+      const missing = [];
+      for (const rawId of tab_ids) {
+        if (typeof rawId === 'string' && rawId.includes(':')) {
+          const found = byComposite.get(rawId.toLowerCase());
+          if (found) targets.push(found);
+          else missing.push(rawId);
+        } else {
+          const numId = Number(rawId);
+          const found = byId.get(numId);
+          if (found) targets.push(found);
+          else missing.push(rawId);
+        }
+      }
       reason = `${targets.length} tab(s) by id`;
-      const missing = tab_ids.filter((id) => !byId.has(id));
       if (missing.length) reason += ` (${missing.length} id(s) no longer exist, skipped)`;
     } else if (duplicates) {
       const dupIds = new Set(findDuplicateIds(all));
@@ -87,14 +105,20 @@ export const closeTabsTool = {
         acc[d] = (acc[d] ?? 0) + 1;
         return acc;
       }, {}),
-      sample: targets.slice(0, 10).map((t) => ({ id: t.id, title: t.title || '(untitled)' })),
+      sample: targets.slice(0, 10).map((t) => ({
+        id: t.browser ? `${t.browser}:${t.id}` : t.id,
+        title: t.title || '(untitled)',
+      })),
     };
 
     if (dry_run) {
       return JSON.stringify({ dry_run: true, ...preview }, null, 2);
     }
 
-    const res = await callExtension('close_tabs', { tab_ids: targets.map((t) => t.id) });
+    const res = await callExtension('close_tabs', {
+      tab_ids: targets.map((t) => t.browserInstance ? `${t.browserInstance}:${t.id}` : t.browser ? `${t.browser}:${t.id}` : t.id),
+      browser,
+    });
     return JSON.stringify({ dry_run: false, closed: res.closed, reason, by_domain: preview.by_domain, sample: preview.sample }, null, 2);
   },
 };

package/tools/execute-script.tool.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { callExtension } from '../bridge.js';
+
+const MAX_OUTPUT_CHARS = 50_000;
+
+export const executeScriptTool = {
+  name: 'execute_script',
+  title: 'Execute Script in Tab',
+  description:
+    'Execute a JavaScript expression or script in the context of an open browser tab and return the serialized result. ' +
+    'Useful for pulling elements from pages (e.g. images, links, tables, article bodies), clicking elements, or extracting dynamic DOM state. ' +
+    'Firefox only: Chrome tabs return an error, so use a firefox: tab id. ' +
+    'Fails on restricted system URLs (e.g. chrome://, about:, extensions).',
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  inputSchema: {
+    tab_id: z.union([z.number().int(), z.string()])
+      .describe('The target tab ID (number or composite ID like "chrome:12" or "firefox:34").'),
+    script: z.string()
+      .describe('The JavaScript code or expression to run in the tab. Can return a value or a Promise (e.g. Array.from(document.images).map(i => i.src)).'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if tab_id is numeric and ambiguous.'),
+    world: z.enum(['ISOLATED', 'MAIN']).default('ISOLATED')
+      .describe('Execution context world. "ISOLATED" (default) has full DOM access. "MAIN" runs in the page JavaScript window context.'),
+  },
+
+  execute: async ({ tab_id, script, browser, world }) => {
+    const res = await callExtension('execute_script', { tab_id, script, browser, world });
+    if (!res || res.success === false) {
+      throw new Error(res?.error || 'Script execution failed without error details.');
+    }
+
+    const value = res.result;
+    let output;
+    if (typeof value === 'string') {
+      output = value;
+    } else if (value === null || value === undefined) {
+      output = '(null / undefined returned)';
+    } else {
+      output = JSON.stringify(value, null, 2);
+    }
+
+    if (output.length > MAX_OUTPUT_CHARS) {
+      output = output.slice(0, MAX_OUTPUT_CHARS) +
+        `\n\n... [Result truncated: exceeded ${MAX_OUTPUT_CHARS} characters]`;
+    }
+
+    return output;
+  },
+};

package/tools/get-tab-text.tool.js

@@ -15,12 +15,14 @@ export const getTabTextTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_id: z.number().int()
-      .describe('The numeric ID of the tab whose body text to extract.'),
+    tab_id: z.union([z.number().int(), z.string()])
+      .describe('The numeric ID (or composite like "chrome:123") of the tab whose body text to extract.'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if tab_id is numeric.'),
   },
 
-  execute: async ({ tab_id }) => {
-    const res = await callExtension('get_tab_text', { tab_id });
+  execute: async ({ tab_id, browser }) => {
+    const res = await callExtension('get_tab_text', { tab_id, browser });
     if (!res.text) {
       return `Tab ${tab_id} returned no text content (it might be empty, loading, or restricted).`;
     }

package/tools/group-tabs.tool.js

@@ -5,7 +5,7 @@ export const groupTabsTool = {
   name: 'group_tabs',
   title: 'Group Tabs',
   description:
-    'Group open Chrome tabs into native Chrome Tab Groups. Can create a new group or ' +
+    'Group open tabs into native browser tab groups. Can create a new group or ' +
     'add tabs to an existing group. Optionally set a title and a color for the group.',
   annotations: {
     readOnlyHint: false,
@@ -14,18 +14,20 @@ export const groupTabsTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_ids: z.array(z.number().int()).min(1)
-      .describe('Array of tab IDs to add to the group.'),
-    group_id: z.number().int().optional()
-      .describe('Add to an existing group ID. If omitted, a new group is created.'),
+    tab_ids: z.array(z.union([z.number().int(), z.string()])).min(1)
+      .describe('Tab IDs to add to the group (numbers or composite like "chrome:12"). All must be in the same browser.'),
+    group_id: z.union([z.number().int(), z.string()]).optional()
+      .describe('Add to an existing group ID (number or composite like "chrome:5"). If omitted, a new group is created.'),
     title: z.string().optional()
       .describe('Title to set on the group (new or existing).'),
     color: z.enum(['grey', 'blue', 'red', 'yellow', 'green', 'pink', 'purple', 'cyan', 'orange']).optional()
       .describe('Color to set on the group (new or existing).'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if ids are numeric.'),
   },
 
-  execute: async ({ tab_ids, group_id, title, color }) => {
-    const res = await callExtension('group_tabs', { tab_ids, group_id, title, color });
+  execute: async ({ tab_ids, group_id, title, color, browser }) => {
+    const res = await callExtension('group_tabs', { tab_ids, group_id, title, color, browser });
     return JSON.stringify({
       message: `Successfully grouped ${tab_ids.length} tab(s).`,
       groupId: res.groupId,

package/tools/index.js

@@ -1,7 +1,3 @@
-// Tool registry — the single place that knows which tools exist.
-// To add a tool: create ./my-thing.tool.js exporting a tool object, then add it here.
-// host.js handles all SDK wiring (schema generation, validation, dispatch) generically.
-
 import { listTabsTool }  from './list-tabs.tool.js';
 import { closeTabsTool } from './close-tabs.tool.js';
 import { openTabsTool }  from './open-tabs.tool.js';
@@ -12,6 +8,7 @@ import { updateTabGroupTool } from './update-tab-group.tool.js';
 import { activateTabTool } from './activate-tab.tool.js';
 import { updateTabTool } from './update-tab.tool.js';
 import { getTabTextTool } from './get-tab-text.tool.js';
+import { executeScriptTool } from './execute-script.tool.js';
 
 export const toolRegistry = [
   listTabsTool,
@@ -24,4 +21,5 @@ export const toolRegistry = [
   activateTabTool,
   updateTabTool,
   getTabTextTool,
+  executeScriptTool,
 ];

package/tools/list-tab-groups.tool.js

@@ -5,7 +5,7 @@ export const listTabGroupsTool = {
   name: 'list_tab_groups',
   title: 'List Tab Groups',
   description:
-    'List all existing native Chrome Tab Groups in the current browser session. ' +
+    'List all existing native tab groups across all connected browsers. ' +
     'Returns their IDs, titles, colors, collapsed states, and parent window IDs.',
   annotations: { readOnlyHint: true, openWorldHint: true },
   inputSchema: {
@@ -13,7 +13,6 @@ export const listTabGroupsTool = {
       .describe('Case-insensitive substring filter for group titles.'),
   },
 
-  // fallow-ignore-next-line complexity
   execute: async ({ title_query }) => {
     let groups;
     try {
@@ -38,7 +37,7 @@ export const listTabGroupsTool = {
     for (const g of filtered) {
       const titleStr = g.title ? `"${g.title}"` : '(unnamed)';
       const collapsedStr = g.collapsed ? ' ⏸ (collapsed)' : ' ▶ (expanded)';
-      lines.push(`  · [ID: ${g.id}] ${titleStr} [Color: ${g.color}] [Window: ${g.windowId}]${collapsedStr}`);
+      lines.push(`  · [ID: ${g.browser ? `${g.browser}:${g.id}` : g.id}] ${titleStr} [Color: ${g.color}] [Window: ${g.windowId}]${collapsedStr}`);
     }
 
     return lines.join('\n');

package/tools/list-tabs.tool.js

@@ -10,7 +10,7 @@ export const listTabsTool = {
   name: 'list_tabs',
   title: 'List Tabs',
   description:
-    'Read open Chrome tabs. Returns a domain histogram (the fastest way to understand a large ' +
+    'Read open browser tabs. Returns a domain histogram (the fastest way to understand a large ' +
     'tab set) plus a detailed view. When summarizing the results for the user, you should ' +
     'include the histogram bar graph in your response. Filter with `query`, reshape with ' +
     '`group_by`, or isolate redundant tabs with `duplicates_only`. Read-only — never closes anything.',
@@ -23,20 +23,24 @@ export const listTabsTool = {
         "'window' groups by browser window; 'none' returns a flat list."),
     duplicates_only: z.boolean().default(false)
       .describe('Only include tabs that are duplicates (share a URL with an earlier tab).'),
+    browser: z.string().optional()
+      .describe('Filter tabs to a specific browser (e.g. "chrome", "firefox"). Omit to list tabs across all open browsers.'),
   },
 
-  execute: async ({ query, group_by, duplicates_only }) => {
-    const all = await callExtension('query_tabs');
+  execute: async ({ query, group_by, duplicates_only, browser }) => {
+    let all = await callExtension('query_tabs');
+    if (browser) {
+      all = all.filter((t) => (t.browser || '').toLowerCase() === browser.toLowerCase());
+    }
 
-    let groups;
+    let groups = [];
     try {
       groups = await callExtension('query_groups');
-    } catch (err) {
-      console.error('Failed to fetch tab groups:', err);
-      throw new Error('Failed to fetch tab groups from extension.');
+    } catch {
+      groups = [];
     }
 
-    const groupMap = new Map(groups.map(g => [g.id, g]));
+    const groupMap = new Map((Array.isArray(groups) ? groups : []).map(g => [g.browser ? `${g.browser}:${g.id}` : g.id, g]));
 
     let tabs = all;
     if (query) tabs = tabs.filter((t) => matchesQuery(t, query));
@@ -45,13 +49,12 @@ export const listTabsTool = {
       tabs = tabs.filter((t) => dupIds.has(t.id));
     }
 
-    // Apply MAX_TAB_LIST limit to prevent token overflow
     if (tabs.length > MAX_TAB_LIST) {
       tabs = tabs.slice(0, MAX_TAB_LIST);
     }
 
     const histogram = domainHistogram(tabs);
-    const windows = new Set(tabs.map((t) => t.windowId)).size;
+    const windows = new Set(tabs.map((t) => t.browser ? `${t.browser}:${t.windowId}` : t.windowId)).size;
     const dupCount = findDuplicateIds(tabs).length;
 
     return formatTabData({

package/tools/open-tabs.tool.js

@@ -5,7 +5,7 @@ export const openTabsTool = {
   name: 'open_tabs',
   title: 'Open Tabs',
   description:
-    'Open one or more URLs in new Chrome tabs. This tool allows you to navigate the user to ' +
+    'Open one or more URLs in new browser tabs. This tool allows you to navigate the user to ' +
     'specific web pages or search queries.\n\n' +
     'Examples:\n' +
     '- {"urls": ["https://github.com", "https://youtube.com"]}\n' +
@@ -15,21 +15,23 @@ export const openTabsTool = {
     '  - opened (int): Number of tabs successfully opened',
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false, // opening tabs is non-destructive
+    destructiveHint: false,
     idempotentHint: false,
     openWorldHint: true,
   },
   inputSchema: {
     urls: z.array(z.string()).min(1)
       .describe('An array of URLs to open. If no protocol is provided, https:// will be prepended automatically.'),
+    browser: z.string().optional()
+      .describe('Target browser to open tabs in (e.g. "chrome", "firefox"). Defaults to the active browser.'),
   },
 
-  execute: async ({ urls }) => {
+  execute: async ({ urls, browser }) => {
     if (!urls || urls.length === 0) {
       throw new Error('Provide at least one URL to open.');
     }
 
-    const res = await callExtension('open_tabs', { urls });
+    const res = await callExtension('open_tabs', { urls, browser });
     return JSON.stringify({ opened: res.opened }, null, 2);
   },
 };

package/tools/present.js

@@ -52,12 +52,15 @@ function renderByDomain(tabs, groupMap) {
 function renderByWindow(tabs, groupMap) {
   const grouped = {};
   for (const t of tabs) {
-    (grouped[t.windowId] ??= []).push(t);
+    const key = t.browser ? `${t.browser}:${t.windowId}` : `${t.windowId}`;
+    (grouped[key] ??= []).push(t);
   }
 
   const lines = [];
-  for (const [winId, tabsInWin] of Object.entries(grouped)) {
-    lines.push(formatWindowHeader(winId, tabsInWin.length));
+  for (const [key, tabsInWin] of Object.entries(grouped)) {
+    const browser = tabsInWin[0]?.browser;
+    const winId = tabsInWin[0]?.windowId ?? key;
+    lines.push(formatWindowHeader(winId, tabsInWin.length, browser));
     for (const t of tabsInWin) {
       const label = tabLabel(t);
       const flags = buildFlags(t);
@@ -100,8 +103,13 @@ export function formatTabData(data) {
 
   const lines = [];
 
+  const browsers = [...new Set(tabs.map((t) => t.browser).filter(Boolean))];
+  const browserSummary = browsers.length > 1
+    ? ` across ${browsers.length} browsers (${browsers.map((b) => `${b}: ${tabs.filter((t) => t.browser === b).length}`).join(', ')}) and`
+    : ' across';
+
   lines.push(
-    `📊 ${tabs.length} tab(s) across ${windows} window(s)` +
+    `📊 ${tabs.length} tab(s)${browserSummary} ${windows} window(s)` +
       (query ? ` matching "${query}"` : '') +
       (duplicates_only ? ' (duplicates only)' : '') +
       (dupCount > 0 ? ` · ${dupCount} duplicate(s) found` : '') +

package/tools/rendering.js

@@ -1,6 +1,3 @@
-/** Rendering adapters for tab display - delegates to dedicated formatters. */
-
-/** Build emoji flags for tab metadata attributes. */
 export function buildFlags(tab) {
   const flags = [];
   if (tab.pinned) flags.push('📌');
@@ -8,41 +5,36 @@ export function buildFlags(tab) {
   return flags;
 }
 
-/** Format emoji flags as display string. */
 export function formatFlags(flags) {
   return flags.length ? ' ' + flags.join('') : '';
 }
 
-/** Draw ASCII histogram bar for a domain count. */
 export function drawBar(count, maxCount, maxWidth) {
   return '▇'.repeat(Math.max(1, Math.round((count / maxCount) * maxWidth)));
 }
 
-/** Draw a single histogram line. */
 export function formatHistogramLine(domain, count, bar) {
   return `  ${bar}  ${domain.padEnd(28)} ${count} tab(s)`;
 }
 
-/** Draw domain header. */
 export function formatDomainHeader(domain, count) {
   return `📁 ${domain} — ${count} tab(s)`;
 }
 
-/** Draw window header. */
-export function formatWindowHeader(winId, count) {
-  return `🪟 Window ${winId} — ${count} tab(s)`;
+export function formatWindowHeader(winId, count, browser) {
+  const browserPrefix = browser ? `[${browser.charAt(0).toUpperCase() + browser.slice(1)}] ` : '';
+  return `🪟 ${browserPrefix}Window ${winId} — ${count} tab(s)`;
 }
 
-/** Draw group prefix. */
 export function formatGroupPrefix(groupMap, tab) {
   if (tab.groupId === undefined || tab.groupId === -1) return '';
-  const g = groupMap.get(tab.groupId);
+  const g = groupMap.get(tab.browser ? `${tab.browser}:${tab.groupId}` : tab.groupId);
   return g ? `[Group: ${g.title || 'Group ' + g.id}] ` : '';
 }
 
-/** Draw the tab's numeric id - every id-based tool (activate_tab, update_tab,
- * get_tab_text, group_tabs, ungroup_tabs, close_tabs' tab_ids mode) needs one,
- * and this is the only place callers can read it from. */
 export function formatIdPrefix(tab) {
+  if (tab.browser) {
+    return `[id:${tab.browser}:${tab.id}] `;
+  }
   return `[id:${tab.id}] `;
 }

package/tools/ungroup-tabs.tool.js

@@ -4,7 +4,7 @@ import { callExtension } from '../bridge.js';
 export const ungroupTabsTool = {
   name: 'ungroup_tabs',
   title: 'Ungroup Tabs',
-  description: 'Remove one or more open Chrome tabs from their current native Tab Groups.',
+  description: 'Remove one or more open tabs from their current native tab groups.',
   annotations: {
     readOnlyHint: false,
     destructiveHint: false,
@@ -12,12 +12,14 @@ export const ungroupTabsTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_ids: z.array(z.number().int()).min(1)
-      .describe('Array of tab IDs to remove from any groups.'),
+    tab_ids: z.array(z.union([z.number().int(), z.string()])).min(1)
+      .describe('Tab IDs to remove from any groups (numbers or composite like "chrome:12").'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if ids are numeric.'),
   },
 
-  execute: async ({ tab_ids }) => {
-    const res = await callExtension('ungroup_tabs', { tab_ids });
+  execute: async ({ tab_ids, browser }) => {
+    const res = await callExtension('ungroup_tabs', { tab_ids, browser });
     return JSON.stringify({
       message: `Successfully ungrouped ${res.ungrouped} tab(s).`,
       ungrouped: res.ungrouped,

package/tools/update-tab-group.tool.js

@@ -5,7 +5,7 @@ export const updateTabGroupTool = {
   name: 'update_tab_group',
   title: 'Update Tab Group',
   description:
-    'Update properties of an existing native Chrome Tab Group, including ' +
+    'Update properties of an existing native browser tab group, including ' +
     'its title, color, or collapsed/expanded state.',
   annotations: {
     readOnlyHint: false,
@@ -14,18 +14,20 @@ export const updateTabGroupTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    group_id: z.number().int()
-      .describe('The numeric ID of the tab group to update (obtained from list_tab_groups or list_tabs).'),
+    group_id: z.union([z.number().int(), z.string()])
+      .describe('The ID (number or composite like "chrome:5") of the tab group to update (obtained from list_tab_groups or list_tabs).'),
     title: z.string().optional()
       .describe('New title for the group.'),
     color: z.enum(['grey', 'blue', 'red', 'yellow', 'green', 'pink', 'purple', 'cyan', 'orange']).optional()
       .describe('New color for the group.'),
     collapsed: z.boolean().optional()
       .describe('Whether the group should be collapsed (true) or expanded (false).'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if ids are numeric.'),
   },
 
-  execute: async ({ group_id, title, color, collapsed }) => {
-    const res = await callExtension('update_group', { group_id, title, color, collapsed });
+  execute: async ({ group_id, title, color, collapsed, browser }) => {
+    const res = await callExtension('update_group', { group_id, title, color, collapsed, browser });
     return JSON.stringify({
       message: `Successfully updated tab group ${group_id}.`,
       groupId: res.updated,

package/tools/update-tab.tool.js

@@ -14,18 +14,20 @@ export const updateTabTool = {
     openWorldHint: true,
   },
   inputSchema: {
-    tab_id: z.number().int()
-      .describe('The numeric ID of the tab to update.'),
+    tab_id: z.union([z.number().int(), z.string()])
+      .describe('The numeric ID (or composite like "chrome:123") of the tab to update.'),
     url: z.string().optional()
       .describe('A new URL to navigate the tab to. If no protocol is provided, https:// will be prepended.'),
     pinned: z.boolean().optional()
       .describe('Set to true to pin the tab, or false to unpin it.'),
     muted: z.boolean().optional()
       .describe('Set to true to mute the tab, or false to unmute it.'),
+    browser: z.string().optional()
+      .describe('Optional browser hint ("chrome", "firefox") if tab_id is numeric.'),
   },
 
-  execute: async ({ tab_id, url, pinned, muted }) => {
-    const res = await callExtension('update_tab', { tab_id, url, pinned, muted });
+  execute: async ({ tab_id, url, pinned, muted, browser }) => {
+    const res = await callExtension('update_tab', { tab_id, url, pinned, muted, browser });
     return JSON.stringify({
       message: `Successfully updated tab ${tab_id}.`,
       tabId: res.updated,