@swarmai/local-agent 0.1.0

package/src/mcpManager.js

@@ -0,0 +1,276 @@
+/**
+ * MCP Manager for Local Agent
+ *
+ * Manages MCP (Model Context Protocol) server connections locally.
+ * Uses @modelcontextprotocol/sdk to spawn stdio-based MCP server processes,
+ * discover their tools, and execute tool calls.
+ *
+ * Mirrors patterns from server/services/mcp/MCPClientManager.cjs
+ * but adapted for client-side use without database access.
+ */
+
+const os = require('os');
+
+const TOOL_CALL_TIMEOUT = 60000; // 60s
+
+/**
+ * Pre-configured MCP server recipes
+ */
+const MCP_RECIPES = {
+  playwright: {
+    name: 'playwright',
+    description: 'Browser automation via Playwright',
+    command: 'npx',
+    args: ['-y', '@playwright/mcp@latest'],
+  },
+  filesystem: {
+    name: 'filesystem',
+    description: 'Local filesystem access',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', os.homedir()],
+  },
+  sqlite: {
+    name: 'sqlite',
+    description: 'SQLite database access',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sqlite'],
+  },
+  git: {
+    name: 'git',
+    description: 'Git repository operations',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+  },
+  docker: {
+    name: 'docker',
+    description: 'Docker container management',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-docker'],
+  },
+};
+
+class MCPManager {
+  constructor() {
+    /** @type {Map<string, { client: Object, transport: Object, tools: Array, config: Object }>} */
+    this._connections = new Map();
+    this._log = console.log;
+  }
+
+  /**
+   * Set log function (called from connection.js)
+   */
+  setLogger(logFn) {
+    this._log = logFn || console.log;
+  }
+
+  /**
+   * Start all configured MCP servers
+   * @param {Object} mcpConfig - { serverName: { command, args, env } }
+   */
+  async startAll(mcpConfig) {
+    if (!mcpConfig || typeof mcpConfig !== 'object') return;
+
+    const entries = Object.entries(mcpConfig);
+    if (entries.length === 0) return;
+
+    for (const [name, config] of entries) {
+      try {
+        await this.connect(name, config);
+      } catch (e) {
+        this._log(`MCP: Failed to start "${name}": ${e.message}`);
+      }
+    }
+  }
+
+  /**
+   * Connect to a single MCP server
+   * @param {string} name - Server name
+   * @param {Object} config - { command, args, env }
+   */
+  async connect(name, config) {
+    if (this._connections.has(name)) {
+      this._log(`MCP: "${name}" already connected`);
+      return;
+    }
+
+    if (!config.command) {
+      throw new Error(`MCP server "${name}" has no command configured`);
+    }
+
+    const { Client } = require('@modelcontextprotocol/sdk/client');
+    const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+    const args = Array.isArray(config.args) ? config.args : [];
+    const env = config.env && typeof config.env === 'object'
+      ? { ...process.env, ...config.env }
+      : undefined;
+
+    // On Windows, npx needs shell resolution
+    const isWindows = os.platform() === 'win32';
+    const command = isWindows && config.command === 'npx' ? 'npx.cmd' : config.command;
+
+    this._log(`MCP: Starting "${name}" (${config.command} ${args.join(' ')})`);
+
+    const transport = new StdioClientTransport({ command, args, env });
+
+    const client = new Client(
+      { name: 'swarmai-local-agent', version: '0.1.0' },
+      { capabilities: {} }
+    );
+
+    try {
+      await client.connect(transport);
+    } catch (err) {
+      throw new Error(`Failed to connect MCP server "${name}": ${err.message}`);
+    }
+
+    const entry = { client, transport, tools: [], config };
+    this._connections.set(name, entry);
+
+    // Discover tools
+    try {
+      const result = await client.listTools();
+      entry.tools = (result.tools || []).map(t => ({
+        server: name,
+        name: t.name,
+        description: t.description || '',
+        inputSchema: t.inputSchema || { type: 'object', properties: {} },
+      }));
+      this._log(`MCP: "${name}" connected — ${entry.tools.length} tools discovered`);
+    } catch (err) {
+      this._log(`MCP: "${name}" connected but tool discovery failed: ${err.message}`);
+    }
+
+    // Handle unexpected disconnect
+    if (transport.onclose) {
+      const originalOnClose = transport.onclose;
+      transport.onclose = () => {
+        originalOnClose();
+        if (this._connections.has(name)) {
+          this._log(`MCP: "${name}" disconnected unexpectedly`);
+          this._connections.delete(name);
+        }
+      };
+    }
+  }
+
+  /**
+   * Disconnect a single MCP server
+   * @param {string} name
+   */
+  async disconnect(name) {
+    const entry = this._connections.get(name);
+    if (!entry) return;
+
+    try {
+      await entry.client.close();
+    } catch (err) {
+      this._log(`MCP: Error closing "${name}": ${err.message}`);
+    }
+
+    this._connections.delete(name);
+  }
+
+  /**
+   * Disconnect all MCP servers
+   */
+  async disconnectAll() {
+    const names = [...this._connections.keys()];
+    const promises = names.map(name => this.disconnect(name));
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * Call a tool on a specific MCP server
+   * @param {string} serverName
+   * @param {string} toolName
+   * @param {Object} args
+   * @returns {Promise<Object>}
+   */
+  async callTool(serverName, toolName, args = {}) {
+    const entry = this._connections.get(serverName);
+    if (!entry) {
+      throw new Error(`MCP server "${serverName}" not connected. Connected servers: ${this.getConnectedServers().join(', ') || 'none'}`);
+    }
+
+    // Validate tool exists
+    const tool = entry.tools.find(t => t.name === toolName);
+    if (!tool) {
+      const available = entry.tools.map(t => t.name).join(', ');
+      throw new Error(`Tool "${toolName}" not found on MCP server "${serverName}". Available: ${available || 'none'}`);
+    }
+
+    // Execute with timeout
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`MCP tool call timed out after ${TOOL_CALL_TIMEOUT / 1000}s`)), TOOL_CALL_TIMEOUT);
+    });
+
+    const callPromise = entry.client.callTool({
+      name: toolName,
+      arguments: args,
+    });
+
+    const result = await Promise.race([callPromise, timeoutPromise]);
+    return result.content || result;
+  }
+
+  /**
+   * Get all discovered tools from all connected servers (flat array)
+   * @returns {Array<{ server: string, name: string, description: string, inputSchema: Object }>}
+   */
+  getAllTools() {
+    const tools = [];
+    for (const entry of this._connections.values()) {
+      tools.push(...entry.tools);
+    }
+    return tools;
+  }
+
+  /**
+   * Get list of connected server names
+   * @returns {string[]}
+   */
+  getConnectedServers() {
+    return [...this._connections.keys()];
+  }
+
+  /**
+   * Get a pre-configured recipe
+   * @param {string} name
+   * @returns {Object|null}
+   */
+  static getRecipe(name) {
+    return MCP_RECIPES[name] || null;
+  }
+
+  /**
+   * Get all recipe names
+   * @returns {string[]}
+   */
+  static getRecipeNames() {
+    return Object.keys(MCP_RECIPES);
+  }
+
+  /**
+   * Get recipe descriptions for display
+   * @returns {Array<{name: string, description: string}>}
+   */
+  static getRecipeList() {
+    return Object.values(MCP_RECIPES).map(r => ({
+      name: r.name,
+      description: r.description,
+    }));
+  }
+}
+
+// Singleton
+let _instance = null;
+
+function getMcpManager() {
+  if (!_instance) {
+    _instance = new MCPManager();
+  }
+  return _instance;
+}
+
+module.exports = { MCPManager, getMcpManager, MCP_RECIPES };

package/src/startup.js

@@ -0,0 +1,297 @@
+/**
+ * Cross-OS auto-start at boot management
+ * Supports Windows (Registry), macOS (LaunchAgent), Linux (systemd user service)
+ */
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const APP_NAME = 'swarmai-agent';
+const APP_LABEL = 'com.swarmai.agent';
+
+/**
+ * Get the full path to the swarmai-agent executable
+ */
+function getExecutablePath() {
+  const platform = os.platform();
+  try {
+    if (platform === 'win32') {
+      return execSync('where swarmai-agent', { encoding: 'utf-8' }).trim().split('\n')[0].trim();
+    } else {
+      return execSync('which swarmai-agent', { encoding: 'utf-8' }).trim();
+    }
+  } catch {
+    // Fallback: use the current process
+    return process.argv[1] || 'swarmai-agent';
+  }
+}
+
+/**
+ * Enable auto-start at boot
+ */
+function enableStartup() {
+  const platform = os.platform();
+  const execPath = getExecutablePath();
+
+  switch (platform) {
+    case 'win32':
+      return enableWindows(execPath);
+    case 'darwin':
+      return enableMacOS(execPath);
+    case 'linux':
+      return enableLinux(execPath);
+    default:
+      throw new Error(`Unsupported platform: ${platform}. Supported: Windows, macOS, Linux`);
+  }
+}
+
+/**
+ * Disable auto-start at boot
+ */
+function disableStartup() {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'win32':
+      return disableWindows();
+    case 'darwin':
+      return disableMacOS();
+    case 'linux':
+      return disableLinux();
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+/**
+ * Check if auto-start is enabled
+ */
+function isStartupEnabled() {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'win32':
+      return isEnabledWindows();
+    case 'darwin':
+      return isEnabledMacOS();
+    case 'linux':
+      return isEnabledLinux();
+    default:
+      return false;
+  }
+}
+
+// ================
+// Windows: Registry
+// ================
+
+function enableWindows(execPath) {
+  // Sanitize execPath to prevent command injection via quotes in path
+  const safePath = execPath.replace(/"/g, '');
+  const cmd = `"${safePath}" start`;
+  try {
+    execSync(
+      `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${APP_NAME}" /t REG_SZ /d "${cmd}" /f`,
+      { encoding: 'utf-8', stdio: 'pipe' }
+    );
+    return { method: 'registry', path: 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run' };
+  } catch (err) {
+    throw new Error(`Failed to set Windows registry: ${err.message}`);
+  }
+}
+
+function disableWindows() {
+  try {
+    execSync(
+      `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${APP_NAME}" /f`,
+      { encoding: 'utf-8', stdio: 'pipe' }
+    );
+    return true;
+  } catch {
+    return false; // Already removed
+  }
+}
+
+function isEnabledWindows() {
+  try {
+    const output = execSync(
+      `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${APP_NAME}"`,
+      { encoding: 'utf-8', stdio: 'pipe' }
+    );
+    return output.includes(APP_NAME);
+  } catch {
+    return false;
+  }
+}
+
+// ================
+// macOS: LaunchAgent
+// ================
+
+function getLaunchAgentPath() {
+  return path.join(os.homedir(), 'Library', 'LaunchAgents', `${APP_LABEL}.plist`);
+}
+
+function enableMacOS(execPath) {
+  const plistPath = getLaunchAgentPath();
+  const plistDir = path.dirname(plistPath);
+
+  if (!fs.existsSync(plistDir)) {
+    fs.mkdirSync(plistDir, { recursive: true });
+  }
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${APP_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${execPath}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${path.join(os.homedir(), '.swarmai', 'agent.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(os.homedir(), '.swarmai', 'agent-error.log')}</string>
+</dict>
+</plist>`;
+
+  fs.writeFileSync(plistPath, plist, 'utf-8');
+
+  try {
+    execSync(`launchctl load "${plistPath}"`, { stdio: 'pipe' });
+  } catch {
+    // May already be loaded
+  }
+
+  return { method: 'launchagent', path: plistPath };
+}
+
+function disableMacOS() {
+  const plistPath = getLaunchAgentPath();
+
+  try {
+    execSync(`launchctl unload "${plistPath}"`, { stdio: 'pipe' });
+  } catch {
+    // May not be loaded
+  }
+
+  if (fs.existsSync(plistPath)) {
+    fs.unlinkSync(plistPath);
+    return true;
+  }
+  return false;
+}
+
+function isEnabledMacOS() {
+  return fs.existsSync(getLaunchAgentPath());
+}
+
+// ================
+// Linux: systemd user service
+// ================
+
+function getSystemdServicePath() {
+  return path.join(os.homedir(), '.config', 'systemd', 'user', `${APP_NAME}.service`);
+}
+
+function enableLinux(execPath) {
+  const servicePath = getSystemdServicePath();
+  const serviceDir = path.dirname(servicePath);
+
+  if (!fs.existsSync(serviceDir)) {
+    fs.mkdirSync(serviceDir, { recursive: true });
+  }
+
+  const service = `[Unit]
+Description=SwarmAI Local Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execPath} start
+Restart=on-failure
+RestartSec=10
+Environment=HOME=${os.homedir()}
+
+[Install]
+WantedBy=default.target
+`;
+
+  fs.writeFileSync(servicePath, service, 'utf-8');
+
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+    execSync(`systemctl --user enable ${APP_NAME}.service`, { stdio: 'pipe' });
+    return { method: 'systemd', path: servicePath };
+  } catch (err) {
+    // systemd might not be available, try XDG autostart fallback
+    return enableLinuxXdg(execPath);
+  }
+}
+
+function enableLinuxXdg(execPath) {
+  const autostartDir = path.join(os.homedir(), '.config', 'autostart');
+  const desktopPath = path.join(autostartDir, `${APP_NAME}.desktop`);
+
+  if (!fs.existsSync(autostartDir)) {
+    fs.mkdirSync(autostartDir, { recursive: true });
+  }
+
+  const desktop = `[Desktop Entry]
+Type=Application
+Name=SwarmAI Local Agent
+Exec=${execPath} start
+Hidden=false
+NoDisplay=true
+X-GNOME-Autostart-enabled=true
+`;
+
+  fs.writeFileSync(desktopPath, desktop, 'utf-8');
+  return { method: 'xdg-autostart', path: desktopPath };
+}
+
+function disableLinux() {
+  // Try systemd first
+  const servicePath = getSystemdServicePath();
+  if (fs.existsSync(servicePath)) {
+    try {
+      execSync(`systemctl --user disable ${APP_NAME}.service`, { stdio: 'pipe' });
+      execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+    } catch {
+      // systemd might not be available
+    }
+    fs.unlinkSync(servicePath);
+    return true;
+  }
+
+  // Try XDG autostart
+  const desktopPath = path.join(os.homedir(), '.config', 'autostart', `${APP_NAME}.desktop`);
+  if (fs.existsSync(desktopPath)) {
+    fs.unlinkSync(desktopPath);
+    return true;
+  }
+
+  return false;
+}
+
+function isEnabledLinux() {
+  if (fs.existsSync(getSystemdServicePath())) return true;
+  if (fs.existsSync(path.join(os.homedir(), '.config', 'autostart', `${APP_NAME}.desktop`))) return true;
+  return false;
+}
+
+module.exports = {
+  enableStartup,
+  disableStartup,
+  isStartupEnabled,
+};