@swarmai/local-agent 0.1.0

package/src/auth.js

@@ -0,0 +1,180 @@
+/**
+ * Auth flow for Local Agent CLI
+ *
+ * 1. POST /api/local-agents/auth/init → get sessionId + authUrl
+ * 2. Open authUrl in browser
+ * 3. Poll GET /api/local-agents/auth/status/:sessionId until approved/denied/expired
+ * 4. Save API key to config
+ */
+
+const http = require('http');
+const https = require('https');
+const os = require('os');
+const { loadConfig, saveConfig } = require('./config');
+
+const POLL_INTERVAL_MS = 2000;
+const MAX_POLL_ATTEMPTS = 150; // 5 minutes at 2s intervals
+
+/**
+ * Make an HTTP(S) request (minimal, no external deps needed)
+ */
+function request(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const mod = urlObj.protocol === 'https:' ? https : http;
+
+    const reqOptions = {
+      method: options.method || 'GET',
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      path: urlObj.pathname + urlObj.search,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    };
+
+    const req = mod.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    });
+
+    req.on('error', reject);
+
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+    req.end();
+  });
+}
+
+/**
+ * Initiate auth flow
+ */
+async function initAuth(serverUrl, deviceName) {
+  const url = new URL('/api/local-agents/auth/init', serverUrl);
+  const response = await request(url.toString(), {
+    method: 'POST',
+    body: {
+      deviceName,
+      hostname: os.hostname(),
+      os: os.platform(),
+      osVersion: os.release(),
+    },
+  });
+
+  if (response.status !== 200) {
+    throw new Error(`Auth init failed: ${response.data?.error || 'Unknown error'}`);
+  }
+
+  return response.data;
+}
+
+/**
+ * Poll for auth status
+ */
+async function pollAuthStatus(serverUrl, sessionId, onPoll) {
+  // Validate sessionId to prevent URL injection (must be UUID format)
+  if (!sessionId || !/^[a-f0-9-]{36}$/i.test(sessionId)) {
+    throw new Error('Invalid session ID format');
+  }
+
+  let attempts = 0;
+
+  return new Promise((resolve, reject) => {
+    const poll = async () => {
+      attempts++;
+
+      if (attempts > MAX_POLL_ATTEMPTS) {
+        reject(new Error('Auth timed out'));
+        return;
+      }
+
+      try {
+        const url = new URL(`/api/local-agents/auth/status/${encodeURIComponent(sessionId)}`, serverUrl);
+        const response = await request(url.toString());
+
+        if (onPoll) onPoll(attempts);
+
+        if (response.status !== 200) {
+          reject(new Error(`Status check failed: ${response.data?.error || 'Unknown'}`));
+          return;
+        }
+
+        const { status, apiKey, agentId } = response.data;
+
+        if (status === 'approved') {
+          if (!apiKey) {
+            reject(new Error('API key already retrieved. Run login again to generate a new key.'));
+          } else {
+            resolve({ apiKey, agentId });
+          }
+          return;
+        }
+
+        if (status === 'denied') {
+          reject(new Error('Authorization denied by user'));
+          return;
+        }
+
+        if (status === 'expired') {
+          reject(new Error('Authorization request expired'));
+          return;
+        }
+
+        // status === 'pending' — schedule next poll
+        setTimeout(poll, POLL_INTERVAL_MS);
+      } catch (err) {
+        // Network error, retry
+        setTimeout(poll, POLL_INTERVAL_MS);
+      }
+    };
+
+    setTimeout(poll, POLL_INTERVAL_MS);
+  });
+}
+
+/**
+ * Full login flow
+ */
+async function login(serverUrl, deviceName) {
+  // 1. Init auth challenge
+  const { sessionId, authUrl } = await initAuth(serverUrl, deviceName);
+
+  // 2. Open browser
+  let opened = false;
+  try {
+    const open = require('open');
+    await open(authUrl);
+    opened = true;
+  } catch {
+    // open may fail in headless environments
+  }
+
+  // 3. Poll for result
+  const result = await pollAuthStatus(serverUrl, sessionId);
+
+  // 4. Save config
+  const config = loadConfig();
+  config.server = serverUrl;
+  config.apiKey = result.apiKey;
+  config.agentId = result.agentId;
+  config.deviceName = deviceName;
+  saveConfig(config);
+
+  return { ...result, authUrl, opened };
+}
+
+module.exports = {
+  initAuth,
+  pollAuthStatus,
+  login,
+  request,
+};

package/src/cli.js

@@ -0,0 +1,334 @@
+/**
+ * CLI command definitions for SwarmAI Local Agent
+ */
+
+const os = require('os');
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { loadConfig, saveConfig, isConfigured, DEFAULT_SERVER, CONFIG_FILE } = require('./config');
+const { login } = require('./auth');
+const { AgentConnection } = require('./connection');
+const { enableStartup, disableStartup, isStartupEnabled } = require('./startup');
+
+function createCli() {
+  const program = new Command();
+
+  program
+    .name('swarmai-agent')
+    .description('SwarmAI Local Agent — Connect your device to SwarmAI')
+    .version('0.1.0');
+
+  // ==================
+  // LOGIN
+  // ==================
+  program
+    .command('login')
+    .description('Authenticate this device with SwarmAI server')
+    .option('-a, --api <url>', 'SwarmAI server URL', DEFAULT_SERVER)
+    .option('-s, --server <url>', 'SwarmAI server URL (alias for --api)')
+    .option('-n, --name <name>', 'Device name', os.hostname())
+    .action(async (opts) => {
+      // --api takes priority, --server is alias for backwards compat
+      const serverUrl = opts.api || opts.server || DEFAULT_SERVER;
+      opts.server = serverUrl;
+
+      console.log(chalk.cyan.bold('\n  SwarmAI Local Agent\n'));
+      console.log(chalk.gray(`  Server: ${serverUrl}`));
+      console.log(chalk.gray(`  Device: ${opts.name}\n`));
+
+      try {
+        console.log(chalk.yellow('  Initiating authorization...'));
+
+        const result = await login(serverUrl, opts.name);
+
+        if (result.opened) {
+          console.log(chalk.gray('  Browser opened for authorization.'));
+        } else {
+          console.log(chalk.yellow('  Could not open browser. Please visit:'));
+          console.log(chalk.cyan(`  ${result.authUrl}\n`));
+        }
+
+        console.log(chalk.green.bold('\n  Device authorized successfully!\n'));
+        console.log(chalk.gray(`  Agent ID: ${result.agentId}`));
+        console.log(chalk.gray(`  Config saved to: ${CONFIG_FILE}\n`));
+        console.log(chalk.cyan('  Run `swarmai-agent start` to connect.\n'));
+      } catch (error) {
+        console.log(chalk.red(`\n  Error: ${error.message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // ==================
+  // START
+  // ==================
+  program
+    .command('start')
+    .description('Connect to SwarmAI server and listen for commands')
+    .option('--runat-startup', 'Register to auto-start at system boot')
+    .option('--remove-startup', 'Remove auto-start at system boot')
+    .action(async (opts) => {
+      // Handle startup registration
+      if (opts.runatStartup) {
+        try {
+          const result = enableStartup();
+          console.log(chalk.green(`\n  Auto-start enabled (${result.method})`));
+          console.log(chalk.gray(`  Path: ${result.path}\n`));
+          console.log(chalk.gray('  SwarmAI Agent will now start automatically on boot.'));
+          console.log(chalk.gray('  Use --remove-startup to disable.\n'));
+        } catch (err) {
+          console.log(chalk.red(`\n  Failed to enable auto-start: ${err.message}\n`));
+          process.exit(1);
+        }
+        // Continue to also start the agent
+      }
+
+      if (opts.removeStartup) {
+        const removed = disableStartup();
+        if (removed) {
+          console.log(chalk.green('\n  Auto-start removed.\n'));
+        } else {
+          console.log(chalk.yellow('\n  Auto-start was not enabled.\n'));
+        }
+        return;
+      }
+
+      if (!isConfigured()) {
+        console.log(chalk.red('\n  Not configured. Run `swarmai-agent login` first.\n'));
+        process.exit(1);
+      }
+
+      const config = loadConfig();
+
+      // Check for updates (non-blocking)
+      checkForUpdates(config.server || DEFAULT_SERVER).catch(() => {});
+
+      console.log(chalk.cyan.bold('\n  SwarmAI Local Agent\n'));
+      console.log(chalk.gray(`  Server: ${config.server}`));
+      console.log(chalk.gray(`  Device: ${config.deviceName || 'Unknown'}`));
+      console.log(chalk.gray(`  Agent ID: ${config.agentId}\n`));
+
+      const connection = new AgentConnection(config.server, config.apiKey, {
+        onStatusChange: (status) => {
+          if (status === 'connected') {
+            console.log(chalk.green(`  [${timestamp()}] Connected`));
+          } else if (status === 'disconnected') {
+            console.log(chalk.yellow(`  [${timestamp()}] Disconnected — will reconnect`));
+          } else if (status === 'error') {
+            console.log(chalk.red(`  [${timestamp()}] Connection error`));
+          }
+        },
+        onLog: (msg) => {
+          console.log(chalk.gray(`  [${timestamp()}] ${msg}`));
+        },
+      });
+
+      // Handle graceful shutdown
+      const shutdown = () => {
+        console.log(chalk.yellow('\n  Disconnecting...'));
+        connection.disconnect();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+
+      try {
+        await connection.connect();
+        console.log(chalk.green('\n  Listening for commands. Press Ctrl+C to stop.\n'));
+
+        // Keep process alive
+        await new Promise(() => {});
+      } catch (error) {
+        console.log(chalk.red(`\n  Failed to connect: ${error.message}`));
+        console.log(chalk.gray('  Make sure the server is running and your API key is valid.\n'));
+        process.exit(1);
+      }
+    });
+
+  // ==================
+  // STATUS
+  // ==================
+  program
+    .command('status')
+    .description('Show current configuration and connection status')
+    .action(() => {
+      const config = loadConfig();
+      console.log(chalk.cyan.bold('\n  SwarmAI Local Agent Status\n'));
+
+      if (!isConfigured()) {
+        console.log(chalk.yellow('  Not configured. Run `swarmai-agent login` first.\n'));
+        return;
+      }
+
+      console.log(chalk.white(`  Server:      ${config.server}`));
+      console.log(chalk.white(`  Device:      ${config.deviceName || 'Unknown'}`));
+      console.log(chalk.white(`  Agent ID:    ${config.agentId || 'N/A'}`));
+      console.log(chalk.white(`  API Key:     ${config.apiKey ? config.apiKey.substring(0, 12) + '...' : 'N/A'}`));
+      console.log(chalk.white(`  Auto-start:  ${isStartupEnabled() ? chalk.green('Enabled') : chalk.gray('Disabled')}`));
+      console.log(chalk.white(`  Config file: ${CONFIG_FILE}`));
+      console.log();
+    });
+
+  // ==================
+  // LOGOUT
+  // ==================
+  program
+    .command('logout')
+    .description('Remove local configuration')
+    .action(() => {
+      const config = loadConfig();
+      if (config.apiKey) {
+        saveConfig({});
+        console.log(chalk.green('\n  Logged out. Config cleared.\n'));
+      } else {
+        console.log(chalk.gray('\n  Not logged in.\n'));
+      }
+    });
+
+  // ==================
+  // MCP
+  // ==================
+  const mcpCommand = program
+    .command('mcp')
+    .description('Manage MCP (Model Context Protocol) servers');
+
+  mcpCommand
+    .command('add <nameOrRecipe>')
+    .description('Add an MCP server. Use a recipe name (playwright, filesystem, sqlite, git, docker) or provide custom config with --command')
+    .option('-c, --command <cmd>', 'Server command (e.g., "npx")')
+    .option('-a, --args <args>', 'Server arguments (comma-separated)')
+    .option('-e, --env <env>', 'Environment variables (KEY=VAL,KEY2=VAL2)')
+    .action((nameOrRecipe, opts) => {
+      const config = loadConfig();
+      const mcpServers = config.mcpServers || {};
+
+      const { MCPManager } = require('./mcpManager');
+      const recipe = MCPManager.getRecipe(nameOrRecipe);
+
+      if (recipe && !opts.command) {
+        mcpServers[nameOrRecipe] = {
+          command: recipe.command,
+          args: recipe.args,
+          env: {},
+        };
+        console.log(chalk.green(`\n  MCP server "${nameOrRecipe}" added (recipe: ${recipe.description}).\n`));
+      } else if (opts.command) {
+        mcpServers[nameOrRecipe] = {
+          command: opts.command,
+          args: opts.args ? opts.args.split(',').map(s => s.trim()) : [],
+          env: opts.env ? parseEnvString(opts.env) : {},
+        };
+        console.log(chalk.green(`\n  MCP server "${nameOrRecipe}" added (custom).\n`));
+      } else {
+        console.log(chalk.red(`\n  Unknown recipe "${nameOrRecipe}". Provide --command for custom server.`));
+        console.log(chalk.gray(`  Available recipes: ${MCPManager.getRecipeNames().join(', ')}\n`));
+        return;
+      }
+
+      config.mcpServers = mcpServers;
+      saveConfig(config);
+      console.log(chalk.gray('  Restart the agent to activate: swarmai-agent start\n'));
+    });
+
+  mcpCommand
+    .command('remove <name>')
+    .description('Remove an MCP server')
+    .action((name) => {
+      const config = loadConfig();
+      const mcpServers = config.mcpServers || {};
+
+      if (!mcpServers[name]) {
+        console.log(chalk.yellow(`\n  MCP server "${name}" not found.\n`));
+        return;
+      }
+
+      delete mcpServers[name];
+      config.mcpServers = mcpServers;
+      saveConfig(config);
+      console.log(chalk.green(`\n  MCP server "${name}" removed.\n`));
+    });
+
+  mcpCommand
+    .command('list')
+    .description('List configured MCP servers and available recipes')
+    .action(() => {
+      const config = loadConfig();
+      const mcpServers = config.mcpServers || {};
+      const names = Object.keys(mcpServers);
+
+      console.log(chalk.cyan.bold('\n  Configured MCP Servers\n'));
+
+      if (names.length === 0) {
+        console.log(chalk.gray('  None configured.\n'));
+      } else {
+        for (const name of names) {
+          const s = mcpServers[name];
+          console.log(chalk.white(`  ${chalk.green('*')} ${name}`));
+          console.log(chalk.gray(`    ${s.command} ${(s.args || []).join(' ')}`));
+        }
+        console.log();
+      }
+
+      console.log(chalk.cyan.bold('  Available Recipes\n'));
+      const { MCPManager } = require('./mcpManager');
+      for (const recipe of MCPManager.getRecipeList()) {
+        const installed = mcpServers[recipe.name] ? chalk.green(' (installed)') : '';
+        console.log(chalk.white(`  ${recipe.name}${installed}`));
+        console.log(chalk.gray(`    ${recipe.description}`));
+      }
+      console.log(chalk.gray(`\n  Add with: swarmai-agent mcp add <recipe>\n`));
+    });
+
+  return program;
+}
+
+/**
+ * Parse environment variable string (KEY=VAL,KEY2=VAL2)
+ */
+function parseEnvString(envStr) {
+  const result = {};
+  for (const part of envStr.split(',')) {
+    const [key, ...valParts] = part.split('=');
+    if (key) result[key.trim()] = valParts.join('=').trim();
+  }
+  return result;
+}
+
+function timestamp() {
+  return new Date().toLocaleTimeString();
+}
+
+/**
+ * Check for agent updates (non-blocking, best-effort)
+ */
+async function checkForUpdates(serverUrl) {
+  try {
+    const pkg = require('../package.json');
+    const currentVersion = pkg.version;
+
+    const http = serverUrl.startsWith('https') ? require('https') : require('http');
+    const url = new URL('/api/local-agents/version', serverUrl);
+
+    return new Promise((resolve) => {
+      const req = http.get(url, { timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const { latestVersion, downloadUrl } = JSON.parse(data);
+            if (latestVersion && latestVersion !== currentVersion) {
+              console.log(chalk.yellow(`\n  Update available: v${currentVersion} → v${latestVersion}`));
+              if (downloadUrl) console.log(chalk.gray(`  Download: ${downloadUrl}`));
+              console.log();
+            }
+          } catch { /* ignore parse errors */ }
+          resolve();
+        });
+      });
+      req.on('error', () => resolve());
+      req.on('timeout', () => { req.destroy(); resolve(); });
+    });
+  } catch { /* non-critical */ }
+}
+
+module.exports = { createCli };