@xyz-credit/agent-cli 1.1.2 → 1.2.0

package/src/commands/start.js

@@ -1,64 +1,50 @@
 /**
- * Start Command — Agent Daemon with Permission Gatekeeper
- * 
- * Starts the agent to listen for incoming service execution requests.
- * In interactive mode, prompts for permission before executing local tools.
- * In headless mode, uses the allow_list from config.
+ * Start Command — Agent Runtime with Dashboard, Heartbeat & Priority Tasks
+ *
+ * Modes:
+ *   xyz-agent start                  Dashboard mode (interactive terminal UI)
+ *   xyz-agent start --headless       Foreground headless (no dashboard)
+ *   xyz-agent start --daemon         Background via pm2
+ *   xyz-agent start --daemon status  Check daemon status
+ *   xyz-agent start --daemon logs    View daemon logs
+ *   xyz-agent start --daemon stop    Stop the daemon
  */
 const chalk = require('chalk');
 const ora = require('ora');
 const inquirer = require('inquirer');
 const fetch = require('node-fetch');
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
 const { config, isAuthenticated, getCredentials, getAllowList, isHeadlessMode } = require('../config');
 
-async function checkPermission(requesterAgentId, toolName) {
-  /**
-   * Phase 5: Permission Gatekeeper
-   * Before executing any local MCP tool requested by a remote agent,
-   * prompt the user or check the allow_list.
-   */
-  if (isHeadlessMode()) {
+// ── Permission Gatekeeper ──────────────────────────────
+
+async function checkPermission(requesterAgentId, toolName, ee) {
+  if (isHeadlessMode() || process.env.XYZ_HEADLESS === 'true') {
     const allowList = getAllowList();
-    // Check if this agent+tool combo is pre-approved
     const allowed = allowList[requesterAgentId] || allowList['*'] || [];
-    if (allowed.includes(toolName) || allowed.includes('*')) {
-      return true;
-    }
-    console.log(chalk.yellow(`  [BLOCKED] Agent ${requesterAgentId} tried to use ${toolName} — not in allow_list`));
+    if (allowed.includes(toolName) || allowed.includes('*')) return true;
+    if (ee) ee.emit('log', `[BLOCKED] Agent ${requesterAgentId.slice(0, 12)}... tried ${toolName}`);
     return false;
   }
-
-  // Interactive mode: prompt user
-  const { allow } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'allow',
-    message: `Allow Agent [${requesterAgentId.slice(0, 12)}...] to use [${toolName}]?`,
-    default: false,
-  }]);
-
-  return allow;
+  // In dashboard mode, auto-allow (user sees it in logs)
+  if (ee) ee.emit('log', `[AUTO-ALLOW] ${requesterAgentId.slice(0, 12)}... → ${toolName}`);
+  return true;
 }
 
+// ── Local MCP Execution ────────────────────────────────
+
 async function executeLocalTool(mcpUrl, toolName, inputData) {
-  /**
-   * Execute a tool on the local MCP server via JSON-RPC.
-   */
   if (!mcpUrl) return { error: 'No local MCP server configured' };
-
   try {
     const httpUrl = mcpUrl.replace('/sse', '').replace(/\/$/, '');
     const res = await fetch(httpUrl, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: Date.now(),
-        method: 'tools/call',
-        params: { name: toolName, arguments: inputData || {} }
-      }),
+      body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method: 'tools/call', params: { name: toolName, arguments: inputData || {} } }),
       timeout: 30000,
     });
-
     if (!res.ok) return { error: `MCP server returned ${res.status}` };
     const data = await res.json();
     if (data.error) return { error: data.error.message || 'MCP error' };
@@ -68,6 +54,8 @@ async function executeLocalTool(mcpUrl, toolName, inputData) {
   }
 }
 
+// ── Task Polling & Execution ───────────────────────────
+
 async function pollForTasks(creds) {
   try {
     const res = await fetch(
@@ -78,118 +66,363 @@ async function pollForTasks(creds) {
       const data = await res.json();
       return data.tasks || [];
     }
-  } catch {
-    // Silently retry on network errors
-  }
+  } catch { /* retry */ }
   return [];
 }
 
-async function startCommand(opts) {
-  console.log('');
-  console.log(chalk.bold.cyan('  Agent Runtime'));
-  console.log(chalk.dim('  Listening for incoming service requests\n'));
+async function processTask(task, creds, ee) {
+  const log = (msg) => ee ? ee.emit('log', msg) : console.log(msg);
 
-  if (!isAuthenticated()) {
-    console.log(chalk.red('  Not authenticated. Run `xyz-agent auth` first.\n'));
-    return;
+  log(`Incoming task: ${task.id} | Tool: ${task.tool_name} | Fee: ${task.fee_usdc} USDC`);
+  const allowed = await checkPermission(task.requester_agent_id, task.tool_name, ee);
+
+  if (!allowed) {
+    log(`Permission denied for ${task.tool_name}`);
+    return false;
   }
 
-  const creds = getCredentials();
+  log(`Executing ${task.tool_name}...`);
+  const mcpUrl = config.get('localMcpUrl');
+  let output = { status: 'executed', tool: task.tool_name };
 
-  // Daemon mode via pm2
-  if (opts.daemon) {
-    console.log(chalk.yellow('  Daemon mode requires pm2.'));
-    console.log(chalk.dim('  Install: npm install -g pm2'));
-    console.log(chalk.dim('  Then run: pm2 start xyz-agent -- start'));
-    console.log(chalk.dim('  Or: xyz-agent start (foreground mode)\n'));
-
-    try {
-      const { execSync } = require('child_process');
-      execSync('pm2 start node -- ./bin/xyz-agent.js start', {
-        cwd: require('path').resolve(__dirname, '../../'),
-        stdio: 'inherit',
-      });
-      console.log(chalk.green('\n  Agent started as daemon via pm2.\n'));
-    } catch (e) {
-      console.log(chalk.red(`  pm2 launch failed: ${e.message}`));
-      console.log(chalk.dim('  Falling back to foreground mode...\n'));
+  if (mcpUrl) {
+    const result = await executeLocalTool(mcpUrl, task.tool_name, task.input_data);
+    if (result.error) {
+      log(`Warning: ${result.error}`);
+      output = { status: 'executed_with_warning', error: result.error, tool: task.tool_name };
+    } else {
+      output = result;
+      log(`MCP tool executed successfully`);
+    }
+  }
+
+  try {
+    await fetch(`${creds.platformUrl}/api/services/tasks/${task.id}/complete`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ agent_id: creds.agentId, api_key: creds.apiKey, output_data: output }),
+    });
+    log(`Task ${task.id} completed`);
+    return true;
+  } catch (e) {
+    log(`Task completion failed: ${e.message}`);
+    return false;
+  }
+}
+
+// ── PM2 Ecosystem Config ───────────────────────────────
+
+function generateEcosystemConfig(creds) {
+  const cliRoot = path.resolve(__dirname, '../../');
+  const logDir = path.join(path.dirname(config.path), 'logs');
+  try { fs.mkdirSync(logDir, { recursive: true }); } catch { /* ignore */ }
+
+  return {
+    apps: [{
+      name: `xyz-agent-${creds.agentName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`,
+      script: path.join(cliRoot, 'bin', 'xyz-agent.js'),
+      args: 'start --headless',
+      cwd: cliRoot,
+      env: { XYZ_HEADLESS: 'true', NODE_ENV: 'production' },
+      instances: 1, autorestart: true, watch: false,
+      max_memory_restart: '256M', max_restarts: 10, restart_delay: 5000,
+      error_file: path.join(logDir, 'agent-error.log'),
+      out_file: path.join(logDir, 'agent-out.log'),
+      merge_logs: true, log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
+    }],
+  };
+}
+
+function getEcosystemPath() { return path.join(path.dirname(config.path), 'ecosystem.config.js'); }
+
+function writeEcosystemConfig(ec) {
+  const p = getEcosystemPath();
+  fs.writeFileSync(p, `module.exports = ${JSON.stringify(ec, null, 2)};\n`);
+  return p;
+}
+
+function execPm2(args) {
+  const { execSync } = require('child_process');
+  return execSync(`pm2 ${args}`, { encoding: 'utf8', timeout: 15000 });
+}
+
+function isPm2Available() {
+  try { const { execSync } = require('child_process'); execSync('pm2 --version', { encoding: 'utf8', timeout: 5000 }); return true; }
+  catch { return false; }
+}
+
+function getProcessName(creds) {
+  return `xyz-agent-${creds.agentName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+}
+
+// ── Daemon Subcommands ─────────────────────────────────
+
+async function daemonStatus(creds) {
+  const name = getProcessName(creds);
+  console.log(chalk.bold.cyan(`  Daemon Status: ${name}\n`));
+  if (!isPm2Available()) { console.log(chalk.red('  pm2 not installed.\n')); return; }
+  try {
+    const output = execPm2(`jlist`);
+    const procs = JSON.parse(output);
+    const proc = procs.find(p => p.name === name);
+    if (proc) {
+      const st = proc.pm2_env.status;
+      console.log(chalk.white(`  Status:   ${st === 'online' ? chalk.green('online') : chalk.red(st)}`));
+      console.log(chalk.white(`  Restarts: ${proc.pm2_env.restart_time}`));
+      console.log(chalk.white(`  Uptime:   ${proc.pm2_env.pm_uptime ? Math.round((Date.now() - proc.pm2_env.pm_uptime) / 60000) + 'm' : 'N/A'}`));
+      console.log(chalk.white(`  Memory:   ${Math.round((proc.monit?.memory || 0) / 1024 / 1024)}MB`));
+    } else {
+      console.log(chalk.yellow('  Process not found.'));
     }
+  } catch { console.log(chalk.yellow('  Daemon not running.\n')); }
+  console.log('');
+}
+
+async function daemonLogs(creds) {
+  const logDir = path.join(path.dirname(config.path), 'logs');
+  const outLog = path.join(logDir, 'agent-out.log');
+  console.log(chalk.bold.cyan(`  Daemon Logs\n`));
+  if (fs.existsSync(outLog)) {
+    const lines = fs.readFileSync(outLog, 'utf8').split('\n').slice(-30);
+    lines.forEach(l => console.log(chalk.dim(`  ${l}`)));
+  } else {
+    console.log(chalk.dim('  No log file found.'));
+  }
+  console.log('');
+}
+
+async function daemonStop(creds) {
+  const name = getProcessName(creds);
+  if (!isPm2Available()) { console.log(chalk.red('  pm2 not installed.\n')); return; }
+  const spinner = ora(`Stopping ${name}...`).start();
+  try { execPm2(`delete ${name}`); spinner.succeed(`Stopped: ${name}`); }
+  catch { spinner.fail('Not found or already stopped.'); }
+  console.log('');
+}
+
+async function daemonStart(creds) {
+  if (!isPm2Available()) {
+    console.log(chalk.yellow('  pm2 not installed. Run: npm install -g pm2\n'));
     return;
   }
+  const ec = generateEcosystemConfig(creds);
+  const ecoPath = writeEcosystemConfig(ec);
+  const name = getProcessName(creds);
+  try { execPm2(`delete ${name} 2>/dev/null`); } catch { /* ignore */ }
+  const spinner = ora('Starting daemon...').start();
+  try {
+    execPm2(`start ${ecoPath}`);
+    spinner.succeed(`Daemon started: ${name}`);
+    console.log(chalk.dim('  xyz-agent start --daemon status  |  logs  |  stop\n'));
+  } catch (e) {
+    spinner.fail(`pm2 failed: ${e.message}`);
+  }
+}
+
+// ── Dashboard Mode (Interactive Terminal UI) ───────────
 
-  // Foreground mode
-  const mode = isHeadlessMode() ? 'HEADLESS' : 'INTERACTIVE';
+async function dashboardStart(creds) {
+  const { Dashboard } = require('../services/dashboard');
+  const { HeartbeatService } = require('../services/heartbeat');
+  const { MessagingService } = require('../services/messaging');
+  const { computeRiskScore, discoverAndRegisterServices } = require('../services/risk');
+
+  const ee = new EventEmitter();
+  const dashboard = new Dashboard();
+  const heartbeat = new HeartbeatService(ee);
+  const messaging = new MessagingService(ee);
   const localMcpUrl = config.get('localMcpUrl') || '';
-  console.log(chalk.dim(`  Agent:    ${creds.agentName} (${creds.agentId.slice(0, 12)}...)`));
-  console.log(chalk.dim(`  Platform: ${creds.platformUrl}`));
-  console.log(chalk.dim(`  Local MCP:${localMcpUrl || ' Not configured'}`));
-  console.log(chalk.dim(`  Mode:     ${mode}`));
-  console.log(chalk.dim(`  Press Ctrl+C to stop.\n`));
 
-  const spinner = ora('Waiting for incoming tasks...').start();
+  // Wire events
+  ee.on('log', (msg) => dashboard.addLog(msg));
+  ee.on('heartbeat', (data) => dashboard.updateHeartbeat(data));
+  ee.on('unread-count', (count) => dashboard.updateUnreadCount(count));
+  ee.on('new-message', (msg) => dashboard.showNewMessage(msg));
+  ee.on('tasks', async (tasks) => {
+    for (const task of tasks) {
+      await processTask(task, creds, ee);
+    }
+  });
+
+  // Start dashboard
+  dashboard.start(creds.agentName, creds.platformUrl, localMcpUrl);
 
-  // Poll loop
-  let running = true;
-  process.on('SIGINT', () => {
-    running = false;
-    spinner.stop();
+  // Handle user commands (priority tasks)
+  dashboard.ee.on('user-command', async (cmd) => {
+    heartbeat.pause();
+    dashboard.addLog(`Processing user command: ${cmd.type}${cmd.command ? ' — ' + cmd.command : ''}`);
+
+    if (cmd.type === 'sync') {
+      await heartbeat._marketplaceSync(creds);
+    } else if (cmd.type === 'post') {
+      await heartbeat._forumParticipation(creds);
+    } else if (cmd.type === 'inbox') {
+      // Fetch and display inbox in dashboard
+      try {
+        const params = new URLSearchParams({
+          agent_id: creds.agentId,
+          api_key: creds.apiKey,
+          limit: '10',
+          unread_only: 'true',
+        });
+        const res = await fetch(`${creds.platformUrl}/api/cli/messages/inbox?${params}`, { timeout: 10000 });
+        if (res.ok) {
+          const data = await res.json();
+          const msgs = data.messages || [];
+          if (msgs.length === 0) {
+            dashboard.addLog('Inbox: No unread messages');
+          } else {
+            dashboard.addLog(`Inbox: ${msgs.length} unread message(s)`);
+            msgs.forEach(m => {
+              const from = m.from_agent_name || m.from_agent_id.slice(0, 12);
+              dashboard.addLog(`  From: ${from} | ${m.message.slice(0, 60)}${m.message.length > 60 ? '...' : ''}`);
+            });
+          }
+        }
+      } catch (e) {
+        dashboard.addLog(`Inbox error: ${e.message}`);
+      }
+    } else if (cmd.type === 'send-msg') {
+      // Send a message from the dashboard
+      try {
+        const result = await messaging.sendMessage(cmd.toAgentId, cmd.message);
+        dashboard.addLog(`{green-fg}Message sent{/green-fg} to ${result.to_agent_name || cmd.toAgentId.slice(0, 12)}`);
+      } catch (e) {
+        dashboard.addLog(`{red-fg}Send failed:{/red-fg} ${e.message}`);
+      }
+    } else if (cmd.type === 'task') {
+      dashboard.addLog(`Agent thought: User asked me to "${cmd.command}". Executing...`);
+      // Check for pending tasks as the user requested
+      const tasks = await pollForTasks(creds);
+      if (tasks.length > 0) {
+        for (const task of tasks) {
+          await processTask(task, creds, ee);
+        }
+      } else {
+        dashboard.addLog('No pending tasks. Manual task noted for next cycle.');
+      }
+    }
+
+    heartbeat.resume();
+  });
+
+  dashboard.ee.on('quit', () => {
+    heartbeat.stop();
+    messaging.stop();
+    dashboard.destroy();
     console.log(chalk.dim('\n  Agent stopped.\n'));
     process.exit(0);
   });
 
-  while (running) {
-    await new Promise(r => setTimeout(r, 5000));
+  // Background: compute risk score
+  dashboard.addLog('Computing risk score...');
+  const risk = await computeRiskScore();
+  if (risk) dashboard.addLog(`Risk score: ${risk.risk_score}/${risk.max_score}`);
+
+  // Background: discover and register MCP services
+  if (localMcpUrl) {
+    dashboard.addLog('Discovering MCP tools...');
+    const discovery = await discoverAndRegisterServices();
+    if (discovery) {
+      dashboard.addLog(`MCP: ${discovery.tools_count} tools found${discovery.registered ? ' (auto-registered)' : ''}`);
+      dashboard.updateConnectivity(true, true);
+    } else {
+      dashboard.updateConnectivity(true, false);
+    }
+  } else {
+    dashboard.updateConnectivity(true, null);
+  }
+
+  // Start heartbeat
+  heartbeat.start();
+
+  // Start messaging polling
+  messaging.start();
 
+  // Also poll for tasks in between heartbeats
+  setInterval(async () => {
+    if (heartbeat.paused) return;
     const tasks = await pollForTasks(creds);
     if (tasks.length > 0) {
-      spinner.stop();
-
       for (const task of tasks) {
-        console.log(chalk.cyan(`\n  Incoming task: ${task.id}`));
-        console.log(chalk.dim(`    From: ${task.requester_agent_id}`));
-        console.log(chalk.dim(`    Tool: ${task.tool_name}`));
-        console.log(chalk.dim(`    Fee:  ${task.fee_usdc} USDC`));
-
-        // Permission gatekeeper (Phase 5)
-        const allowed = await checkPermission(task.requester_agent_id, task.tool_name);
-
-        if (allowed) {
-          console.log(chalk.green(`    Executing ${task.tool_name}...`));
-          // Execute on local MCP server if configured
-          const mcpUrl = config.get('localMcpUrl');
-          let output = { status: 'executed', tool: task.tool_name };
-          if (mcpUrl) {
-            const result = await executeLocalTool(mcpUrl, task.tool_name, task.input_data);
-            if (result.error) {
-              console.log(chalk.yellow(`    Local execution warning: ${result.error}`));
-              output = { status: 'executed_with_warning', error: result.error, tool: task.tool_name };
-            } else {
-              output = result;
-              console.log(chalk.green(`    Local MCP tool executed successfully.`));
-            }
-          }
-          try {
-            await fetch(`${creds.platformUrl}/api/services/tasks/${task.id}/complete`, {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify({
-                agent_id: creds.agentId,
-                api_key: creds.apiKey,
-                output_data: output,
-              }),
-            });
-            console.log(chalk.green(`    Task ${task.id} completed.`));
-          } catch (e) {
-            console.log(chalk.red(`    Task completion failed: ${e.message}`));
-          }
-        } else {
-          console.log(chalk.red(`    Permission denied for ${task.tool_name}.`));
-        }
+        await processTask(task, creds, ee);
       }
+    }
+  }, 15000);
+}
 
-      spinner.start('Waiting for incoming tasks...');
+// ── Headless Mode (no dashboard) ───────────────────────
+
+async function headlessStart(creds) {
+  const { HeartbeatService } = require('../services/heartbeat');
+  const { computeRiskScore } = require('../services/risk');
+  const ee = new EventEmitter();
+  const heartbeat = new HeartbeatService(ee);
+
+  ee.on('log', (msg) => console.log(chalk.dim(`  [${new Date().toLocaleTimeString()}] ${msg}`)));
+
+  console.log(chalk.dim(`  Agent:     ${creds.agentName} (${creds.agentId.slice(0, 12)}...)`));
+  console.log(chalk.dim(`  Platform:  ${creds.platformUrl}`));
+  console.log(chalk.dim(`  MCP:       ${config.get('localMcpUrl') || 'Not configured'}`));
+  console.log(chalk.dim(`  Mode:      HEADLESS`));
+  console.log(chalk.dim(`  Press Ctrl+C to stop.\n`));
+
+  // Risk score
+  const risk = await computeRiskScore();
+  if (risk) console.log(chalk.dim(`  Risk score: ${risk.risk_score}/${risk.max_score}`));
+
+  // Start heartbeat
+  heartbeat.start();
+
+  // Task polling
+  let tasksProcessed = 0;
+  const pollInterval = setInterval(async () => {
+    if (heartbeat.paused) return;
+    const tasks = await pollForTasks(creds);
+    for (const task of tasks) {
+      const ok = await processTask(task, creds, ee);
+      if (ok) tasksProcessed++;
     }
+  }, 10000);
+
+  process.on('SIGINT', () => {
+    clearInterval(pollInterval);
+    heartbeat.stop();
+    console.log(chalk.dim(`\n  Agent stopped. Tasks: ${tasksProcessed}\n`));
+    process.exit(0);
+  });
+}
+
+// ── Main Command ───────────────────────────────────────
+
+async function startCommand(opts) {
+  console.log('');
+  console.log(chalk.bold.cyan('  xyz.credit Agent Runtime'));
+  console.log(chalk.dim('  Autonomous agent with heartbeat, marketplace sync & forum\n'));
+
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  Not authenticated. Run `xyz-agent auth` first.\n'));
+    return;
+  }
+
+  const creds = getCredentials();
+
+  // Daemon mode
+  if (opts.daemon) {
+    const sub = typeof opts.daemon === 'string' ? opts.daemon : null;
+    if (sub === 'status') return daemonStatus(creds);
+    if (sub === 'logs') return daemonLogs(creds);
+    if (sub === 'stop') return daemonStop(creds);
+    return daemonStart(creds);
   }
+
+  // Headless mode
+  if (opts.headless || isHeadlessMode() || process.env.XYZ_HEADLESS === 'true') {
+    return headlessStart(creds);
+  }
+
+  // Dashboard mode (default)
+  return dashboardStart(creds);
 }
 
 module.exports = { startCommand };