2manytabs-mcp-host 2.0.0 → 3.0.0

package/tools/present.js

@@ -0,0 +1,131 @@
+import {
+  compact,
+  tabLabel,
+  TITLE_TRUNCATE_FULL,
+  HISTOGRAM_BAR_MAX,
+} from '../lib/tabs.js';
+import {
+  buildFlags,
+  formatFlags,
+  drawBar,
+  formatHistogramLine,
+  formatDomainHeader,
+  formatWindowHeader,
+  formatGroupPrefix,
+  formatIdPrefix,
+} from './rendering.js';
+
+function renderHistogram(histogram) {
+  const maxCount = Math.max(...histogram.map((x) => x.count));
+  const lines = ['Domains:'];
+
+  for (const { domain, count } of histogram) {
+    const bar = drawBar(count, maxCount, HISTOGRAM_BAR_MAX);
+    lines.push(formatHistogramLine(domain, count, bar));
+  }
+
+  return lines;
+}
+
+function renderByDomain(tabs, groupMap) {
+  const grouped = {};
+  for (const t of tabs) {
+    const domain = t.url ? new URL(t.url).hostname : '(local)';
+    (grouped[domain] ??= []).push(t);
+  }
+
+  const lines = [];
+  for (const [domain, tabsInDomain] of Object.entries(grouped)) {
+    lines.push(formatDomainHeader(domain, tabsInDomain.length));
+    for (const t of tabsInDomain) {
+      const label = tabLabel(t);
+      const flags = buildFlags(t);
+      const flagStr = formatFlags(flags);
+      lines.push(`    · ${formatIdPrefix(t)}${formatGroupPrefix(groupMap, t)}${label}${flagStr}`);
+    }
+    lines.push('');
+  }
+
+  return lines;
+}
+
+function renderByWindow(tabs, groupMap) {
+  const grouped = {};
+  for (const t of tabs) {
+    const key = t.browser ? `${t.browser}:${t.windowId}` : `${t.windowId}`;
+    (grouped[key] ??= []).push(t);
+  }
+
+  const lines = [];
+  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);
+      const flagStr = formatFlags(flags);
+      lines.push(`    · ${formatIdPrefix(t)}${formatGroupPrefix(groupMap, t)}${label}${flagStr}`);
+    }
+    lines.push('');
+  }
+
+  return lines;
+}
+
+function renderFlat(tabs, groupMap) {
+  const lines = [];
+  for (const t of tabs) {
+    const c = compact(t);
+    const label =
+      c.title.length > TITLE_TRUNCATE_FULL
+        ? c.title.slice(0, TITLE_TRUNCATE_FULL - 3) + '…'
+        : c.title;
+    const flags = buildFlags(c);
+    const flagStr = formatFlags(flags);
+    lines.push(`  · ${formatIdPrefix(t)}${formatGroupPrefix(groupMap, t)}${label}${flagStr}`);
+  }
+
+  return lines;
+}
+
+export function formatTabData(data) {
+  const {
+    tabs,
+    histogram,
+    groupMap,
+    group_by,
+    query,
+    duplicates_only,
+    windows,
+    dupCount,
+  } = 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)${browserSummary} ${windows} window(s)` +
+      (query ? ` matching "${query}"` : '') +
+      (duplicates_only ? ' (duplicates only)' : '') +
+      (dupCount > 0 ? ` · ${dupCount} duplicate(s) found` : '') +
+      '\n',
+  );
+
+  lines.push(...renderHistogram(histogram));
+  lines.push('');
+
+  if (group_by === 'domain') {
+    lines.push(...renderByDomain(tabs, groupMap));
+  } else if (group_by === 'window') {
+    lines.push(...renderByWindow(tabs, groupMap));
+  } else {
+    lines.push(...renderFlat(tabs, groupMap));
+  }
+
+  return lines.join('\n');
+}

package/tools/rendering.js

@@ -0,0 +1,40 @@
+export function buildFlags(tab) {
+  const flags = [];
+  if (tab.pinned) flags.push('📌');
+  if (tab.audible) flags.push('🔊');
+  return flags;
+}
+
+export function formatFlags(flags) {
+  return flags.length ? ' ' + flags.join('') : '';
+}
+
+export function drawBar(count, maxCount, maxWidth) {
+  return '▇'.repeat(Math.max(1, Math.round((count / maxCount) * maxWidth)));
+}
+
+export function formatHistogramLine(domain, count, bar) {
+  return `  ${bar}  ${domain.padEnd(28)} ${count} tab(s)`;
+}
+
+export function formatDomainHeader(domain, count) {
+  return `📁 ${domain} — ${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)`;
+}
+
+export function formatGroupPrefix(groupMap, tab) {
+  if (tab.groupId === undefined || tab.groupId === -1) return '';
+  const g = groupMap.get(tab.browser ? `${tab.browser}:${tab.groupId}` : tab.groupId);
+  return g ? `[Group: ${g.title || 'Group ' + g.id}] ` : '';
+}
+
+export function formatIdPrefix(tab) {
+  if (tab.browser) {
+    return `[id:${tab.browser}:${tab.id}] `;
+  }
+  return `[id:${tab.id}] `;
+}

package/tools/ungroup-tabs.tool.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { callExtension } from '../bridge.js';
+
+export const ungroupTabsTool = {
+  name: 'ungroup_tabs',
+  title: 'Ungroup Tabs',
+  description: 'Remove one or more open tabs from their current native tab groups.',
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  inputSchema: {
+    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, browser }) => {
+    const res = await callExtension('ungroup_tabs', { tab_ids, browser });
+    return JSON.stringify({
+      message: `Successfully ungrouped ${res.ungrouped} tab(s).`,
+      ungrouped: res.ungrouped,
+    }, null, 2);
+  },
+};

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { callExtension } from '../bridge.js';
+
+export const updateTabGroupTool = {
+  name: 'update_tab_group',
+  title: 'Update Tab Group',
+  description:
+    'Update properties of an existing native browser tab group, including ' +
+    'its title, color, or collapsed/expanded state.',
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  inputSchema: {
+    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, 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,
+    }, null, 2);
+  },
+};

package/tools/update-tab.tool.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { callExtension } from '../bridge.js';
+
+export const updateTabTool = {
+  name: 'update_tab',
+  title: 'Update Tab',
+  description:
+    'Modify properties of an open browser tab, such as navigating it to a new URL, ' +
+    'pinning/unpinning it, or muting/unmuting its audio.',
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  inputSchema: {
+    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, 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,
+    }, null, 2);
+  },
+};