promethios-bridge 2.1.2 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promethios-bridge",
-  "version": "2.1.2",
+  "version": "2.1.5",
   "description": "Run Promethios agent frameworks locally on your computer with full file, terminal, browser access, ambient context capture, and the always-on-top floating chat overlay. Native Framework Mode supports OpenClaw and other frameworks via the bridge.",
   "main": "src/index.js",
   "bin": {

package/src/bridge.js

@@ -21,7 +21,8 @@ const ora = require('ora');
 const fetch = require('node-fetch');
 const { executeLocalTool } = require('./executor');
 const { captureContext } = require('./contextCapture');
-const { startMcpServer } = require('./mcp-server');
+const { startMcpServer, FULL_MANIFEST } = require('./mcp-server');
+const mcpRegistry = require('./mcp-registry');
 const { setPinnedRegion, setPinnedApps, registerBrowserPageAccessor } = require('./tools/desktop');
 
 // Wire the browser-dom tools to the shared Playwright context.
@@ -210,6 +211,111 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
   // Health check
   app.get('/health', (req, res) => res.json({ ok: true, version: require('../package.json').version }));
 
+  // ── /open-external ─────────────────────────────────────────────────────────
+  // POST /open-external?url=<encoded-url>
+  // Called by the Promethios web app when the user clicks "Open [Provider] ↗"
+  // in a provider thread. Opens the URL in the user's real default browser.
+  // No auth required — only accessible from localhost.
+  app.post('/open-external', (req, res) => {
+    const url = (req.query.url || req.body?.url || '').trim();
+    if (!url || !/^https?:\/\//.test(url)) {
+      return res.status(400).json({ error: 'Invalid or missing url parameter' });
+    }
+    const { exec } = require('child_process');
+    const platform = process.platform;
+    let cmd;
+    if (platform === 'win32') {
+      cmd = `start "" "${url.replace(/"/g, '')}"`;
+    } else if (platform === 'darwin') {
+      cmd = `open "${url.replace(/"/g, '')}"`;
+    } else {
+      cmd = `xdg-open "${url.replace(/"/g, '')}"`;
+    }
+    exec(cmd, (err) => {
+      if (err) console.error('[open-external] Failed to open URL:', err.message);
+    });
+    res.json({ status: 'ok', url });
+  });
+
+  // ── /mcp/* ── MCP Marketplace endpoints ────────────────────────────────────────────
+  // All /mcp/* endpoints are localhost-only (no auth token required).
+  // They are called by the Promethios web app marketplace UI.
+
+  // GET /mcp/catalog — serve the curated marketplace catalog
+  app.get('/mcp/catalog', (req, res) => {
+    try {
+      const catalog = require('./mcp-catalog.json');
+      const installed = mcpRegistry.listInstalled();
+      const installedIds = new Set(installed.map(e => e.id));
+      const enriched = catalog.map(item => ({ ...item, installed: installedIds.has(item.id) }));
+      res.json({ ok: true, catalog: enriched });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /mcp/list — list all installed MCP servers (built-ins + user-installed)
+  app.get('/mcp/list', (req, res) => {
+    const all = mcpRegistry.listAll();
+    res.json({ ok: true, servers: all });
+  });
+
+  // GET /mcp/tools — aggregated tool list from all running MCP servers
+  // Also includes the built-in Promethios desktop + android tools.
+  app.get('/mcp/tools', (req, res) => {
+    const builtinTools = FULL_MANIFEST.map(t => ({ ...t, _mcpServerId: 'promethios-desktop' }));
+    const installedTools = mcpRegistry.getAggregatedTools();
+    res.json({ ok: true, tools: [...builtinTools, ...installedTools] });
+  });
+
+  // POST /mcp/install — install an MCP server from the marketplace
+  // Body: { id, name, package, description, icon, env, args }
+  app.post('/mcp/install', async (req, res) => {
+    const { id, name, package: pkg, description, icon, env, args } = req.body || {};
+    if (!id || !pkg) return res.status(400).json({ error: 'id and package are required' });
+    if (mcpRegistry.isInstalled(id)) {
+      return res.status(409).json({ error: `${id} is already installed` });
+    }
+    log(`[mcp-marketplace] Installing ${pkg}...`);
+    const result = await mcpRegistry.npmInstall(pkg);
+    if (!result.ok) {
+      return res.status(500).json({ error: 'npm install failed', detail: result.error });
+    }
+    const entry = { id, name, package: pkg, version: result.version, description, icon, env: env || {}, args: args || [] };
+    mcpRegistry.addEntry(entry);
+    // Start the server immediately so tools are available right away
+    try {
+      const tools = await mcpRegistry.startServer(entry, log);
+      return res.json({ ok: true, id, version: result.version, toolCount: tools.length });
+    } catch (err) {
+      return res.json({ ok: true, id, version: result.version, toolCount: 0, warning: 'Installed but failed to start: ' + err.message });
+    }
+  });
+
+  // DELETE /mcp/uninstall — uninstall an MCP server
+  // Body: { id }
+  app.delete('/mcp/uninstall', async (req, res) => {
+    const { id } = req.body || {};
+    if (!id) return res.status(400).json({ error: 'id is required' });
+    const entry = mcpRegistry.getById(id);
+    if (!entry) return res.status(404).json({ error: `${id} not found` });
+    mcpRegistry.stopServer(id);
+    const uninstallResult = await mcpRegistry.npmUninstall(entry.package);
+    mcpRegistry.removeEntry(id);
+    res.json({ ok: true, id, npmResult: uninstallResult });
+  });
+
+  // PATCH /mcp/toggle — enable or disable an installed MCP server
+  // Body: { id, enabled }
+  app.patch('/mcp/toggle', (req, res) => {
+    const { id, enabled } = req.body || {};
+    if (!id || typeof enabled !== 'boolean') return res.status(400).json({ error: 'id and enabled (boolean) required' });
+    if (!mcpRegistry.isInstalled(id)) return res.status(404).json({ error: `${id} not found` });
+    mcpRegistry.setEnabled(id, enabled);
+    if (!enabled) mcpRegistry.stopServer(id);
+    res.json({ ok: true, id, enabled });
+  });
+
   // ── /status: used by the Electron overlay to auto-connect without manual token entry ──
   // Only accessible from localhost (127.0.0.1 or ::1) for security.
   let bridgeUsername = null; // set after registerBridge resolves
@@ -818,7 +924,12 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
     process.exit(1);
   }
 
-  // ── Step 3b: Check for updates (non-blocking) ───────────────────────────
+  //  // ── Step 3b: Start installed MCP servers (non-blocking) ───────────────────
+  mcpRegistry.startAllEnabled(log).catch(err => {
+    log('[mcp-registry] startAllEnabled error:', err.message);
+  });
+
+  // ── Step 3c: Check for updates (non-blocking) ───────────────────────
   const currentVersion = require('../package.json').version;
   checkForUpdates(currentVersion, log).catch(() => {}); // fire-and-forget
 

package/src/mcp-catalog.json

@@ -0,0 +1,163 @@
+[
+  {
+    "id": "github-mcp",
+    "name": "GitHub",
+    "package": "@modelcontextprotocol/server-github",
+    "description": "Read repos, create pull requests, check issues, search code, and manage GitHub Actions — all from any AI provider in Promethios.",
+    "icon": "🐙",
+    "category": "developer",
+    "featured": true,
+    "requiresEnv": [
+      { "key": "GITHUB_PERSONAL_ACCESS_TOKEN", "label": "GitHub Personal Access Token", "hint": "github.com → Settings → Developer settings → Personal access tokens" }
+    ],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/github",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-github"
+    }
+  },
+  {
+    "id": "filesystem-mcp",
+    "name": "File System",
+    "package": "@modelcontextprotocol/server-filesystem",
+    "description": "Give any AI provider read and write access to files and folders on your computer. Scope it to specific directories for safety.",
+    "icon": "📁",
+    "category": "productivity",
+    "featured": true,
+    "requiresEnv": [],
+    "args": ["--allowed-directories", "~/Documents", "~/Desktop"],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-filesystem"
+    }
+  },
+  {
+    "id": "brave-search-mcp",
+    "name": "Brave Search",
+    "package": "@modelcontextprotocol/server-brave-search",
+    "description": "Real-time web search for any AI provider. No tracking, no filter bubbles. Requires a free Brave Search API key.",
+    "icon": "🦁",
+    "category": "search",
+    "featured": true,
+    "requiresEnv": [
+      { "key": "BRAVE_API_KEY", "label": "Brave Search API Key", "hint": "api.search.brave.com → Get API Key (free tier available)" }
+    ],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-brave-search"
+    }
+  },
+  {
+    "id": "postgres-mcp",
+    "name": "PostgreSQL",
+    "package": "@modelcontextprotocol/server-postgres",
+    "description": "Connect any AI provider to your PostgreSQL database. Run queries, inspect schemas, and analyze data without leaving your AI session.",
+    "icon": "🐘",
+    "category": "database",
+    "featured": false,
+    "requiresEnv": [
+      { "key": "POSTGRES_CONNECTION_STRING", "label": "PostgreSQL Connection String", "hint": "e.g. postgresql://user:password@localhost:5432/mydb" }
+    ],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/postgres",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-postgres"
+    }
+  },
+  {
+    "id": "sqlite-mcp",
+    "name": "SQLite",
+    "package": "@modelcontextprotocol/server-sqlite",
+    "description": "Query and write to local SQLite databases. Perfect for local apps, Electron data stores, and offline-first projects.",
+    "icon": "🗃️",
+    "category": "database",
+    "featured": false,
+    "requiresEnv": [],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-sqlite"
+    }
+  },
+  {
+    "id": "slack-mcp",
+    "name": "Slack",
+    "package": "@modelcontextprotocol/server-slack",
+    "description": "Read channels, send messages, search conversations, and manage your Slack workspace from any AI provider in Promethios.",
+    "icon": "💬",
+    "category": "communication",
+    "featured": false,
+    "requiresEnv": [
+      { "key": "SLACK_BOT_TOKEN", "label": "Slack Bot Token", "hint": "api.slack.com → Your Apps → OAuth & Permissions → Bot User OAuth Token" },
+      { "key": "SLACK_TEAM_ID", "label": "Slack Team ID", "hint": "Found in your Slack workspace URL: app.slack.com/client/TXXXXXXXX" }
+    ],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/slack",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-slack"
+    }
+  },
+  {
+    "id": "google-maps-mcp",
+    "name": "Google Maps",
+    "package": "@modelcontextprotocol/server-google-maps",
+    "description": "Geocoding, directions, place search, and distance calculations. Let any AI provider reason about location and navigation.",
+    "icon": "🗺️",
+    "category": "productivity",
+    "featured": false,
+    "requiresEnv": [
+      { "key": "GOOGLE_MAPS_API_KEY", "label": "Google Maps API Key", "hint": "console.cloud.google.com → APIs & Services → Credentials" }
+    ],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/google-maps",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-google-maps"
+    }
+  },
+  {
+    "id": "memory-mcp",
+    "name": "Memory",
+    "package": "@modelcontextprotocol/server-memory",
+    "description": "Persistent knowledge graph memory for AI providers. Store facts, relationships, and context that survives across sessions.",
+    "icon": "🧠",
+    "category": "productivity",
+    "featured": true,
+    "requiresEnv": [],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-memory"
+    }
+  },
+  {
+    "id": "puppeteer-mcp",
+    "name": "Puppeteer Browser",
+    "package": "@modelcontextprotocol/server-puppeteer",
+    "description": "Full browser automation — navigate pages, fill forms, click elements, take screenshots, and scrape content from any website.",
+    "icon": "🤖",
+    "category": "automation",
+    "featured": true,
+    "requiresEnv": [],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-puppeteer"
+    }
+  },
+  {
+    "id": "sequential-thinking-mcp",
+    "name": "Sequential Thinking",
+    "package": "@modelcontextprotocol/server-sequential-thinking",
+    "description": "Structured multi-step reasoning for complex problems. Helps AI providers break down tasks, revise plans, and think through edge cases.",
+    "icon": "🔗",
+    "category": "reasoning",
+    "featured": false,
+    "requiresEnv": [],
+    "args": [],
+    "links": {
+      "docs": "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
+      "npm": "https://www.npmjs.com/package/@modelcontextprotocol/server-sequential-thinking"
+    }
+  }
+]

package/src/mcp-registry.js

@@ -0,0 +1,397 @@
+/**
+ * Promethios MCP Registry
+ *
+ * Manages the local registry of user-installed MCP servers.
+ * Each entry describes an MCP server package that the bridge
+ * installs, starts as a subprocess, and exposes to all connected
+ * AI providers (Manus, Claude, ChatGPT, OpenClaw, etc.).
+ *
+ * Registry file location:
+ *   %APPDATA%/promethios/mcp-registry.json  (Windows)
+ *   ~/.config/promethios/mcp-registry.json  (Linux/macOS)
+ *
+ * Registry entry schema:
+ * {
+ *   id:          string   — unique slug, e.g. "github-mcp"
+ *   name:        string   — display name, e.g. "GitHub"
+ *   package:     string   — npm package name, e.g. "@modelcontextprotocol/server-github"
+ *   version:     string   — installed version, e.g. "1.2.0"
+ *   description: string   — short description shown in marketplace
+ *   icon:        string   — emoji or URL
+ *   env:         object   — env vars required (keys only, values set by user)
+ *   args:        string[] — extra CLI args passed to the server process
+ *   installedAt: string   — ISO timestamp
+ *   enabled:     boolean  — whether the server should be started on bridge launch
+ *   pid:         number|null — PID of the running subprocess (runtime only)
+ *   tools:       object[] — cached tool manifest from last successful connection
+ * }
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── Registry file path ────────────────────────────────────────────────────────
+
+function getRegistryDir() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || os.homedir(), 'promethios');
+  }
+  return path.join(os.homedir(), '.config', 'promethios');
+}
+
+function getRegistryPath() {
+  return path.join(getRegistryDir(), 'mcp-registry.json');
+}
+
+// ── Read / write ──────────────────────────────────────────────────────────────
+
+function readRegistry() {
+  const registryPath = getRegistryPath();
+  if (!fs.existsSync(registryPath)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(entries) {
+  const dir = getRegistryDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(getRegistryPath(), JSON.stringify(entries, null, 2), 'utf8');
+}
+
+// ── CRUD ──────────────────────────────────────────────────────────────────────
+
+function listInstalled() {
+  return readRegistry().map(e => ({ ...e, pid: null })); // strip runtime pid from persisted data
+}
+
+function getById(id) {
+  return readRegistry().find(e => e.id === id) || null;
+}
+
+function isInstalled(id) {
+  return readRegistry().some(e => e.id === id);
+}
+
+function addEntry(entry) {
+  const entries = readRegistry().filter(e => e.id !== entry.id); // replace if exists
+  entries.push({
+    ...entry,
+    installedAt: entry.installedAt || new Date().toISOString(),
+    enabled:     entry.enabled !== false,
+    tools:       entry.tools || [],
+  });
+  writeRegistry(entries);
+}
+
+function removeEntry(id) {
+  const entries = readRegistry().filter(e => e.id !== id);
+  writeRegistry(entries);
+}
+
+function updateEntry(id, patch) {
+  const entries = readRegistry().map(e => e.id === id ? { ...e, ...patch } : e);
+  writeRegistry(entries);
+}
+
+function setEnabled(id, enabled) {
+  updateEntry(id, { enabled });
+}
+
+function cacheTools(id, tools) {
+  updateEntry(id, { tools });
+}
+
+// ── Built-in servers (always present, not in registry) ────────────────────────
+// These are the Promethios-native tools already running in the bridge.
+// They are included in the combined tool list but cannot be uninstalled.
+
+const BUILTIN_SERVERS = [
+  {
+    id:          'promethios-desktop',
+    name:        'Desktop Bridge',
+    description: 'Screen capture, active window, clipboard, file system, and app control on your computer.',
+    icon:        '🖥️',
+    builtin:     true,
+    enabled:     true,
+    tools:       [], // populated at runtime from FULL_MANIFEST in mcp-server.js
+  },
+  {
+    id:          'promethios-android',
+    name:        'Android Bridge',
+    description: 'Connect your Android phone — share screen, send messages, control apps remotely.',
+    icon:        '📱',
+    builtin:     true,
+    enabled:     true,
+    tools:       [],
+  },
+];
+
+function listAll() {
+  const installed = readRegistry();
+  return [...BUILTIN_SERVERS, ...installed];
+}
+
+// ── npm install helper ────────────────────────────────────────────────────────
+
+/**
+ * Install an npm package into the bridge's local node_modules.
+ * Returns { ok, version, error }.
+ */
+async function npmInstall(packageName) {
+  const { execFile } = require('child_process');
+  const bridgeDir = path.join(__dirname, '..');
+
+  return new Promise((resolve) => {
+    execFile(
+      process.platform === 'win32' ? 'npm.cmd' : 'npm',
+      ['install', '--save', packageName],
+      { cwd: bridgeDir, timeout: 120_000 },
+      (err, stdout, stderr) => {
+        if (err) {
+          resolve({ ok: false, error: err.message + '\n' + stderr });
+          return;
+        }
+        // Extract installed version from npm output
+        const match = (stdout + stderr).match(new RegExp(packageName.replace(/[@/]/g, '.') + '@([\\d.]+)'));
+        resolve({ ok: true, version: match ? match[1] : 'unknown' });
+      }
+    );
+  });
+}
+
+/**
+ * Uninstall an npm package from the bridge's local node_modules.
+ */
+async function npmUninstall(packageName) {
+  const { execFile } = require('child_process');
+  const bridgeDir = path.join(__dirname, '..');
+
+  return new Promise((resolve) => {
+    execFile(
+      process.platform === 'win32' ? 'npm.cmd' : 'npm',
+      ['uninstall', packageName],
+      { cwd: bridgeDir, timeout: 60_000 },
+      (err, stdout, stderr) => {
+        if (err) resolve({ ok: false, error: err.message });
+        else resolve({ ok: true });
+      }
+    );
+  });
+}
+
+// ── Subprocess manager ────────────────────────────────────────────────────────
+
+// Map of id → { process, tools }
+const _running = new Map();
+
+/**
+ * Start an installed MCP server as a stdio subprocess.
+ * Connects via MCP stdio transport and fetches the tool list.
+ * Returns the tool list on success.
+ */
+async function startServer(entry, log = () => {}) {
+  if (_running.has(entry.id)) {
+    log(`[mcp-registry] ${entry.id} already running`);
+    return _running.get(entry.id).tools;
+  }
+
+  const { spawn } = require('child_process');
+  const env = { ...process.env, ...(entry.env || {}) };
+
+  // Resolve the binary: try npx first, fall back to node + main file
+  const args = ['--yes', entry.package, ...(entry.args || [])];
+  const child = spawn(
+    process.platform === 'win32' ? 'npx.cmd' : 'npx',
+    args,
+    { env, stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+
+  child.on('error', (err) => {
+    log(`[mcp-registry] ${entry.id} process error: ${err.message}`);
+    _running.delete(entry.id);
+  });
+
+  child.on('exit', (code) => {
+    log(`[mcp-registry] ${entry.id} exited with code ${code}`);
+    _running.delete(entry.id);
+  });
+
+  // Give the process a moment to start, then probe for tools via MCP stdio
+  await new Promise(r => setTimeout(r, 1500));
+
+  let tools = [];
+  try {
+    tools = await fetchToolsViaStdio(child, entry.id, log);
+    cacheTools(entry.id, tools);
+    log(`[mcp-registry] ${entry.id} started — ${tools.length} tools available`);
+  } catch (err) {
+    log(`[mcp-registry] ${entry.id} tool fetch failed: ${err.message}`);
+  }
+
+  _running.set(entry.id, { process: child, tools });
+  return tools;
+}
+
+/**
+ * Stop a running MCP server subprocess.
+ */
+function stopServer(id) {
+  const running = _running.get(id);
+  if (running) {
+    try { running.process.kill(); } catch {}
+    _running.delete(id);
+  }
+}
+
+/**
+ * Send a tools/list request over stdio to an MCP subprocess and return the tools.
+ */
+async function fetchToolsViaStdio(child, id, log) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`tools/list timeout for ${id}`));
+    }, 8000);
+
+    let buffer = '';
+    const onData = (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // keep incomplete line
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === 1 && msg.result?.tools) {
+            clearTimeout(timeout);
+            child.stdout.off('data', onData);
+            resolve(msg.result.tools);
+          }
+        } catch {}
+      }
+    };
+
+    child.stdout.on('data', onData);
+
+    // Send tools/list request
+    const request = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/list',
+      params: {},
+    }) + '\n';
+
+    child.stdin.write(request, (err) => {
+      if (err) {
+        clearTimeout(timeout);
+        reject(err);
+      }
+    });
+  });
+}
+
+/**
+ * Call a tool on a running MCP server subprocess.
+ */
+async function callTool(id, toolName, args) {
+  const running = _running.get(id);
+  if (!running) throw new Error(`MCP server ${id} is not running`);
+
+  return new Promise((resolve, reject) => {
+    const callId = Date.now();
+    const timeout = setTimeout(() => {
+      reject(new Error(`Tool call timeout: ${toolName} on ${id}`));
+    }, 30_000);
+
+    let buffer = '';
+    const onData = (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === callId) {
+            clearTimeout(timeout);
+            running.process.stdout.off('data', onData);
+            if (msg.error) reject(new Error(msg.error.message));
+            else resolve(msg.result);
+          }
+        } catch {}
+      }
+    };
+
+    running.process.stdout.on('data', onData);
+
+    const request = JSON.stringify({
+      jsonrpc: '2.0',
+      id: callId,
+      method: 'tools/call',
+      params: { name: toolName, arguments: args || {} },
+    }) + '\n';
+
+    running.process.stdin.write(request, (err) => {
+      if (err) {
+        clearTimeout(timeout);
+        reject(err);
+      }
+    });
+  });
+}
+
+/**
+ * Get the combined tool list from all running MCP servers.
+ * Each tool is tagged with its source server id.
+ */
+function getAggregatedTools() {
+  const tools = [];
+  for (const [id, { tools: serverTools }] of _running.entries()) {
+    for (const tool of serverTools) {
+      tools.push({ ...tool, _mcpServerId: id });
+    }
+  }
+  return tools;
+}
+
+/**
+ * Start all enabled installed servers on bridge launch.
+ */
+async function startAllEnabled(log = () => {}) {
+  const entries = readRegistry().filter(e => e.enabled);
+  for (const entry of entries) {
+    try {
+      await startServer(entry, log);
+    } catch (err) {
+      log(`[mcp-registry] Failed to start ${entry.id}: ${err.message}`);
+    }
+  }
+}
+
+module.exports = {
+  // Registry CRUD
+  listInstalled,
+  listAll,
+  getById,
+  isInstalled,
+  addEntry,
+  removeEntry,
+  updateEntry,
+  setEnabled,
+  cacheTools,
+  BUILTIN_SERVERS,
+  // npm helpers
+  npmInstall,
+  npmUninstall,
+  // Subprocess manager
+  startServer,
+  stopServer,
+  callTool,
+  getAggregatedTools,
+  startAllEnabled,
+  // Paths
+  getRegistryPath,
+};