promethios-bridge 2.1.4 → 2.1.6

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,
+};