navada-edge-cli 2.0.0 → 2.1.1

package/lib/agent.js

@@ -0,0 +1,328 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const navada = require('navada-edge-sdk');
+const ui = require('./ui');
+const config = require('./config');
+
+// ---------------------------------------------------------------------------
+// NAVADA Edge Agent — personality + tools + routing
+// ---------------------------------------------------------------------------
+
+const IDENTITY = {
+  name: 'NAVADA Edge',
+  role: 'AI Infrastructure Agent',
+  personality: `You are NAVADA Edge — an AI agent that operates inside the user's terminal.
+You are professional, technical, concise, and helpful. You speak with authority about distributed systems, Docker, AI, and cloud infrastructure.
+You have full access to the user's computer: you can read/write files, run shell commands, manage processes, and connect to the NAVADA Edge Network.
+You can invoke two sub-agents:
+  - Lucas CTO: runs bash, SSH, Docker commands on remote NAVADA Edge nodes
+  - Claude CoS: sends emails, generates images, manages the network
+When users ask you to do something, DO it — don't just describe how. Use your tools.
+When you don't have a tool for something, say so clearly and suggest an alternative.
+Keep responses short. Code blocks when needed. No fluff.`,
+};
+
+// ---------------------------------------------------------------------------
+// Local tools — run on the USER's machine
+// ---------------------------------------------------------------------------
+const localTools = {
+  shell: {
+    description: 'Execute a shell command on this machine',
+    execute: (cmd) => {
+      try {
+        const output = execSync(cmd, { timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return output.trim();
+      } catch (e) {
+        return `Error: ${e.stderr?.trim() || e.message}`;
+      }
+    },
+  },
+
+  readFile: {
+    description: 'Read a file from this machine',
+    execute: (filePath) => {
+      try {
+        return fs.readFileSync(path.resolve(filePath), 'utf-8');
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  writeFile: {
+    description: 'Write content to a file on this machine',
+    execute: (filePath, content) => {
+      try {
+        const resolved = path.resolve(filePath);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(resolved, content);
+        return `Written: ${resolved}`;
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  listFiles: {
+    description: 'List files in a directory on this machine',
+    execute: (dir) => {
+      try {
+        const items = fs.readdirSync(path.resolve(dir || '.'), { withFileTypes: true });
+        return items.map(i => `${i.isDirectory() ? 'd' : 'f'} ${i.name}`).join('\n');
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  systemInfo: {
+    description: 'Get system information',
+    execute: () => {
+      return JSON.stringify({
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        cpus: os.cpus().length,
+        totalMem: `${(os.totalmem() / 1024 / 1024 / 1024).toFixed(1)} GB`,
+        freeMem: `${(os.freemem() / 1024 / 1024 / 1024).toFixed(1)} GB`,
+        uptime: `${(os.uptime() / 3600).toFixed(1)} hours`,
+        user: os.userInfo().username,
+        home: os.homedir(),
+        cwd: process.cwd(),
+        nodeVersion: process.version,
+      }, null, 2);
+    },
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Anthropic Claude API — conversational agent
+// ---------------------------------------------------------------------------
+async function chat(userMessage, conversationHistory = []) {
+  // Smart key detection — check all possible locations
+  const anthropicKey = config.get('anthropicKey')
+    || config.getApiKey()  // /setup saves here
+    || process.env.ANTHROPIC_API_KEY
+    || '';
+
+  // Auto-detect: if the key starts with sk-ant, it's Anthropic
+  const apiKey = config.getApiKey();
+  const effectiveKey = anthropicKey
+    || (apiKey && apiKey.startsWith('sk-ant') ? apiKey : '')
+    || '';
+
+  if (!effectiveKey) {
+    return fallbackChat(userMessage);
+  }
+
+  const tools = [
+    {
+      name: 'shell',
+      description: 'Execute a shell command on the user\'s local machine. Use for: file operations, git, npm, docker, system commands.',
+      input_schema: { type: 'object', properties: { command: { type: 'string', description: 'The shell command to run' } }, required: ['command'] },
+    },
+    {
+      name: 'read_file',
+      description: 'Read the contents of a file on the user\'s local machine.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path to read' } }, required: ['path'] },
+    },
+    {
+      name: 'write_file',
+      description: 'Write content to a file on the user\'s local machine.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, content: { type: 'string', description: 'Content to write' } }, required: ['path', 'content'] },
+    },
+    {
+      name: 'list_files',
+      description: 'List files and directories.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } },
+    },
+    {
+      name: 'system_info',
+      description: 'Get local system information (CPU, RAM, disk, OS, hostname).',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'network_status',
+      description: 'Ping all NAVADA Edge Network nodes and cloud services.',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'lucas_exec',
+      description: 'Run a bash command on EC2 via Lucas CTO agent.',
+      input_schema: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] },
+    },
+    {
+      name: 'lucas_ssh',
+      description: 'SSH to a NAVADA Edge node (hp, ec2, oracle) and run a command via Lucas CTO.',
+      input_schema: { type: 'object', properties: { node: { type: 'string' }, command: { type: 'string' } }, required: ['node', 'command'] },
+    },
+    {
+      name: 'lucas_docker',
+      description: 'Run a command inside a Docker container on EC2 via Lucas CTO.',
+      input_schema: { type: 'object', properties: { container: { type: 'string' }, command: { type: 'string' } }, required: ['container', 'command'] },
+    },
+    {
+      name: 'mcp_call',
+      description: 'Call a tool on the NAVADA Edge MCP server (18 tools: docker, ssh, files, database, monitoring).',
+      input_schema: { type: 'object', properties: { tool: { type: 'string' }, args: { type: 'object' } }, required: ['tool'] },
+    },
+    {
+      name: 'docker_registry',
+      description: 'List images or tags in the NAVADA private Docker registry.',
+      input_schema: { type: 'object', properties: { image: { type: 'string', description: 'Image name for tags (optional — omit to list all)' } } },
+    },
+    {
+      name: 'send_email',
+      description: 'Send an email via the NAVADA Edge MCP email tool.',
+      input_schema: { type: 'object', properties: { to: { type: 'string' }, subject: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'subject', 'body'] },
+    },
+    {
+      name: 'generate_image',
+      description: 'Generate an image using Cloudflare Flux (FREE) or DALL-E.',
+      input_schema: { type: 'object', properties: { prompt: { type: 'string' }, provider: { type: 'string', description: 'flux (default, free) or dalle' } }, required: ['prompt'] },
+    },
+  ];
+
+  const messages = [
+    ...conversationHistory,
+    { role: 'user', content: userMessage },
+  ];
+
+  // Call Anthropic API
+  let response = await callAnthropic(effectiveKey, messages, tools);
+
+  // Handle tool use loop
+  let iterations = 0;
+  while (response.stop_reason === 'tool_use' && iterations < 10) {
+    iterations++;
+    const toolBlocks = response.content.filter(b => b.type === 'tool_use');
+    const results = [];
+
+    for (const block of toolBlocks) {
+      // Print what the agent is doing
+      console.log(ui.dim(`  [${block.name}] ${JSON.stringify(block.input).slice(0, 80)}`));
+      const result = await executeTool(block.name, block.input);
+      results.push({ type: 'tool_result', tool_use_id: block.id, content: typeof result === 'string' ? result : JSON.stringify(result) });
+    }
+
+    // Print any text blocks
+    for (const block of response.content) {
+      if (block.type === 'text' && block.text) console.log(`  ${block.text}`);
+    }
+
+    // Continue conversation with tool results
+    messages.push({ role: 'assistant', content: response.content });
+    messages.push({ role: 'user', content: results });
+    response = await callAnthropic(anthropicKey, messages, tools);
+  }
+
+  // Extract final text
+  const textBlocks = response.content?.filter(b => b.type === 'text') || [];
+  return textBlocks.map(b => b.text).join('\n');
+}
+
+async function callAnthropic(key, messages, tools) {
+  const r = await navada.request('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    body: {
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 4096,
+      system: IDENTITY.personality,
+      messages,
+      tools,
+    },
+    headers: {
+      'x-api-key': key,
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+    },
+    timeout: 60000,
+  });
+
+  if (r.status !== 200) {
+    throw new Error(`Anthropic API error ${r.status}: ${JSON.stringify(r.data).slice(0, 200)}`);
+  }
+
+  return r.data;
+}
+
+async function executeTool(name, input) {
+  try {
+    switch (name) {
+      case 'shell': return localTools.shell.execute(input.command);
+      case 'read_file': return localTools.readFile.execute(input.path);
+      case 'write_file': return localTools.writeFile.execute(input.path, input.content);
+      case 'list_files': return localTools.listFiles.execute(input.path);
+      case 'system_info': return localTools.systemInfo.execute();
+      case 'network_status': return JSON.stringify(await navada.network.ping());
+      case 'lucas_exec': return JSON.stringify(await navada.lucas.exec(input.command));
+      case 'lucas_ssh': return JSON.stringify(await navada.lucas.ssh(input.node, input.command));
+      case 'lucas_docker': return JSON.stringify(await navada.lucas.docker(input.container, input.command));
+      case 'mcp_call': return JSON.stringify(await navada.mcp.call(input.tool, input.args || {}));
+      case 'docker_registry':
+        if (input.image) return JSON.stringify(await navada.registry.tags(input.image));
+        return JSON.stringify(await navada.registry.catalog());
+      case 'send_email': return JSON.stringify(await navada.mcp.call('send-email', input));
+      case 'generate_image':
+        if (input.provider === 'dalle') return JSON.stringify(await navada.ai.openai.image(input.prompt));
+        const { size } = await navada.cloudflare.flux.generate(input.prompt, { savePath: `navada-${Date.now()}.png` });
+        return `Image generated: ${size} bytes`;
+      default: return `Unknown tool: ${name}`;
+    }
+  } catch (e) {
+    return `Tool error: ${e.message}`;
+  }
+}
+
+async function fallbackChat(msg) {
+  // Try MCP → Qwen → OpenAI → helpful error
+  if (navada.config.mcp) {
+    try {
+      const r = await navada.mcp.call('chat', { message: msg });
+      return typeof r === 'object' ? JSON.stringify(r) : r;
+    } catch {}
+  }
+  if (navada.config.hfToken) {
+    try {
+      const r = await navada.ai.huggingface.qwen(msg);
+      return typeof r === 'object' ? JSON.stringify(r) : r;
+    } catch {}
+  }
+  if (navada.config.openaiKey) {
+    try { return await navada.ai.openai.chat(msg); } catch {}
+  }
+  return `I need an API key to chat. Quick fix:
+
+  /login sk-ant-your-anthropic-key    (recommended — enables full agent with tool use)
+  /login sk-your-openai-key           (GPT-4o)
+  /init hfToken hf_your_token         (Qwen Coder — FREE)
+  /setup                              (guided wizard)
+
+/commands still work without a key — try /help`;
+}
+
+// ---------------------------------------------------------------------------
+// Telemetry — track installs + usage
+// ---------------------------------------------------------------------------
+async function reportTelemetry(event, data = {}) {
+  if (!navada.config.dashboard) return;
+  try {
+    await navada.request(navada.config.dashboard + '/api/agent-heartbeat', {
+      method: 'POST',
+      body: {
+        agent: 'navada-edge-cli',
+        event,
+        version: require('../package.json').version,
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+        apiKey: config.getApiKey()?.slice(0, 8) || 'none',
+        ts: new Date().toISOString(),
+        ...data,
+      },
+      timeout: 5000,
+    });
+  } catch {}
+}
+
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat };

package/lib/cli.js

@@ -8,6 +8,7 @@ const history = require('./history');
 const { completer } = require('./completer');
 const { execute, getCompletions } = require('./registry');
 const { loadAll } = require('./commands/index');
+const { reportTelemetry } = require('./agent');
 
 function applyConfig() {
   const cfg = config.getAll();
@@ -84,14 +85,21 @@ async function run(argv) {
   applyConfig();
 
   if (argv.length === 0) {
-    // Check first run
-    if (config.isFirstRun()) {
-      const { runSetup } = require('./commands/setup');
-      await runSetup();
-      return;
-    }
-    // Interactive mode
+    // Report telemetry
+    if (config.isFirstRun()) reportTelemetry('install');
+    else reportTelemetry('session_start');
+
+    // Interactive mode — always start. User can /setup if needed.
     showWelcome();
+
+    // Hint if no key configured
+    const hasKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
+    if (!hasKey) {
+      console.log(ui.warn('No API key set. Type /login <key> or /setup to configure.'));
+      console.log(ui.dim('You can still use /commands. Natural chat requires an API key.'));
+      console.log('');
+    }
+
     startRepl();
   } else if (argv[0] === '--version' || argv[0] === '-v') {
     const pkg = require('../package.json');

package/lib/commands/ai.js

@@ -3,48 +3,39 @@
 const navada = require('navada-edge-sdk');
 const ui = require('../ui');
 const config = require('../config');
+const { chat: agentChat, reportTelemetry } = require('../agent');
 
 module.exports = function(reg) {
 
-  reg('chat', 'Chat with AI (uses configured model)', async (args) => {
+  // Conversation history for multi-turn
+  const conversationHistory = [];
+
+  reg('chat', 'Chat with NAVADA Edge AI agent', async (args) => {
     const msg = args.join(' ');
-    if (!msg) { console.log(ui.dim('Usage: /chat What is the ISA allowance for 2026?')); return; }
+    if (!msg) { console.log(ui.dim('Just type naturally — no /command needed.')); return; }
     const ora = require('ora');
-    const model = config.getModel();
+    const spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
 
-    if (model === 'qwen' || (!navada.config.openaiKey && navada.config.hfToken)) {
-      // Use Qwen (FREE)
-      const spinner = ora({ text: '  Qwen thinking...', color: 'white' }).start();
-      const result = await navada.ai.huggingface.qwen(msg);
-      spinner.stop();
-      console.log(ui.header('QWEN CODER'));
-      console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
-    } else if (navada.config.openaiKey) {
-      // Use OpenAI
-      const spinner = ora({ text: '  Thinking...', color: 'white' }).start();
-      const response = await navada.ai.openai.chat(msg);
+    try {
+      const response = await agentChat(msg, conversationHistory);
       spinner.stop();
-      console.log(ui.header('AI RESPONSE'));
+
+      // Update conversation history
+      conversationHistory.push({ role: 'user', content: msg });
+      conversationHistory.push({ role: 'assistant', content: response });
+
+      // Keep history manageable (last 20 turns)
+      while (conversationHistory.length > 40) conversationHistory.splice(0, 2);
+
+      console.log(ui.header('NAVADA'));
       console.log(`  ${response}`);
-    } else {
-      // Route through MCP if available
-      if (navada.config.mcp) {
-        const spinner = ora({ text: '  Asking NAVADA...', color: 'white' }).start();
-        try {
-          const result = await navada.mcp.call('chat', { message: msg });
-          spinner.stop();
-          console.log(ui.header('NAVADA'));
-          console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
-        } catch {
-          spinner.stop();
-          console.log(ui.warn('No AI provider configured. Set OPENAI_API_KEY, HF_TOKEN, or connect to MCP.'));
-          console.log(ui.dim('Run /setup to configure, or /model to choose a provider.'));
-        }
-      } else {
-        console.log(ui.warn('No AI provider configured.'));
-        console.log(ui.dim('Options: set OPENAI_API_KEY, HF_TOKEN, or connect to MCP server.'));
-        console.log(ui.dim('Run /setup to configure, or /model to choose a provider.'));
-      }
+
+      // Track usage
+      reportTelemetry('chat', { messageLength: msg.length });
+    } catch (e) {
+      spinner.stop();
+      console.log(ui.error(e.message));
+      console.log(ui.dim('Check: /config to see which providers are set, or /setup to configure.'));
     }
   }, { category: 'AI', aliases: ['ask'] });
 
@@ -56,7 +47,7 @@ module.exports = function(reg) {
     const result = await navada.ai.huggingface.qwen(prompt);
     spinner.stop();
     console.log(ui.header('QWEN CODER'));
-    console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
+    console.log(`  ${typeof result === 'object' ? ui.jsonColorize(result) : result}`);
   }, { category: 'AI' });
 
   reg('yolo', 'YOLO object detection', async (args) => {
@@ -88,12 +79,12 @@ module.exports = function(reg) {
     const ora = require('ora');
 
     if (useDalle && navada.config.openaiKey) {
-      const spinner = ora({ text: `  DALL-E generating...`, color: 'white' }).start();
+      const spinner = ora({ text: '  DALL-E generating...', color: 'white' }).start();
       const result = await navada.ai.openai.image(prompt);
       spinner.stop();
       console.log(ui.success(`Generated: ${result.url || result.revised_prompt || 'done'}`));
     } else {
-      const spinner = ora({ text: `  Flux generating (FREE)...`, color: 'white' }).start();
+      const spinner = ora({ text: '  Flux generating (FREE)...', color: 'white' }).start();
       const savePath = `navada-image-${Date.now()}.png`;
       const { size } = await navada.cloudflare.flux.generate(prompt, { savePath });
       spinner.stop();
@@ -103,7 +94,7 @@ module.exports = function(reg) {
 
   reg('model', 'Show/set default AI model', (args) => {
     if (args[0]) {
-      const valid = ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'];
+      const valid = ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'];
       if (!valid.includes(args[0])) { console.log(ui.error(`Invalid model. Options: ${valid.join(', ')}`)); return; }
       config.setModel(args[0]);
       console.log(ui.success(`Model set to: ${args[0]}`));
@@ -113,15 +104,14 @@ module.exports = function(reg) {
       console.log(ui.label('Current', current));
       console.log('');
       console.log(ui.dim('Available:'));
-      console.log(ui.label('auto', 'Route to best available provider'));
+      console.log(ui.label('auto', 'Claude (Anthropic) with tool use — default'));
+      console.log(ui.label('claude', 'Claude Sonnet 4 via Anthropic API'));
       console.log(ui.label('gpt-4o', 'OpenAI GPT-4o (requires OPENAI_API_KEY)'));
-      console.log(ui.label('gpt-4o-mini', 'OpenAI GPT-4o-mini (requires OPENAI_API_KEY)'));
       console.log(ui.label('qwen', 'Qwen Coder 32B (FREE via HuggingFace)'));
-      console.log(ui.label('flux', 'Cloudflare Flux (FREE image gen)'));
       console.log('');
-      console.log(ui.dim('Set with: /model qwen'));
+      console.log(ui.dim('Set with: /model claude'));
     }
-  }, { category: 'AI', subs: ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'] });
+  }, { category: 'AI', subs: ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'] });
 
   reg('research', 'RAG search via MCP', async (args) => {
     const query = args.join(' ');

package/lib/commands/setup.js

@@ -9,128 +9,97 @@ function ask(rl, question) {
   return new Promise(resolve => rl.question(question, resolve));
 }
 
-async function runSetup() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+async function runSetup(fromRepl = false) {
+  // Create a fresh readline — don't conflict with the REPL
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
 
-  console.log(ui.banner());
-  console.log(ui.box('WELCOME', ' First-time setup. Let\'s connect you to the NAVADA Edge Network.'));
   console.log('');
-
-  // 1. API Key
-  const apiKey = await ask(rl, '  Enter your NAVADA Edge API key (or press Enter for FREE tier): ');
-  if (apiKey.trim()) {
-    config.setApiKey(apiKey.trim());
-    navada.init({ mcpApiKey: apiKey.trim(), dashboardApiKey: apiKey.trim() });
-    console.log(ui.success('API key saved'));
-  } else {
-    console.log(ui.dim('Continuing with FREE tier'));
-  }
+  console.log(ui.box('SETUP', ' Configure your NAVADA Edge CLI.'));
   console.log('');
 
-  // 2. Auto-detect network
-  console.log(ui.dim('Scanning for NAVADA Edge nodes...'));
-  // Ask for primary node IP to scan from
-  const scanIp = await ask(rl, '  Enter your primary node IP to scan (or press Enter to skip): ');
-  const defaultIps = {};
-  if (scanIp.trim()) {
-    defaultIps.asus = scanIp.trim();
-  }
+  // 1. API Key — the only required thing
+  console.log(ui.dim('  Your API key powers the AI agent. Accepts:'));
+  console.log(ui.dim('  - Anthropic key (sk-ant-...)'));
+  console.log(ui.dim('  - NAVADA Edge API key (nv_edge_...)'));
+  console.log(ui.dim('  - OpenAI key (sk-...)'));
+  console.log(ui.dim('  - Or press Enter to skip (limited mode)'));
+  console.log('');
 
-  let detected = {};
-  for (const [node, ip] of Object.entries(defaultIps)) {
-    try {
-      const port = node === 'oracle' ? 9000 : 3200;
-      await navada.request(`http://${ip}:${port}/`, { timeout: 3000 });
-      detected[node] = ip;
-      console.log(ui.online(node.toUpperCase(), true, ip));
-    } catch {
-      console.log(ui.online(node.toUpperCase(), false, 'not found'));
+  const apiKey = await ask(rl, '  API key: ');
+  if (apiKey.trim()) {
+    const key = apiKey.trim();
+    config.setApiKey(key);
+    // Auto-detect key type and save to right field
+    if (key.startsWith('sk-ant')) {
+      config.set('anthropicKey', key);
+      console.log(ui.success('Anthropic key saved — full agent mode enabled'));
+    } else if (key.startsWith('nv_edge')) {
+      console.log(ui.success('NAVADA Edge key saved — MCP access enabled'));
+    } else if (key.startsWith('sk-')) {
+      config.set('openaiKey', key);
+      navada.init({ openaiKey: key });
+      console.log(ui.success('OpenAI key saved'));
+    } else {
+      console.log(ui.success('Key saved'));
     }
+  } else {
+    console.log(ui.dim('Skipped — you can set this later with /login <key>'));
   }
   console.log('');
 
-  // 3. Confirm or enter manually
-  if (Object.keys(detected).length > 0) {
-    const useDetected = await ask(rl, '  Use detected nodes? (Y/n): ');
-    if (useDetected.toLowerCase() !== 'n') {
-      for (const [node, ip] of Object.entries(detected)) {
-        config.set(node, ip);
-      }
-      // Auto-derive service URLs from ASUS
-      if (detected.asus) {
-        config.set('mcp', `http://${detected.asus}:8811`);
-        config.set('dashboard', `http://${detected.asus}:7900`);
-        config.set('registry', `http://${detected.asus}:5000`);
-        navada.init({
-          asus: detected.asus, hp: detected.hp || '', ec2: detected.ec2 || '', oracle: detected.oracle || '',
-          mcp: `http://${detected.asus}:8811`, dashboard: `http://${detected.asus}:7900`, registry: `http://${detected.asus}:5000`,
-        });
-      }
-      if (detected.ec2) {
-        config.set('lucas', `http://${detected.ec2}:8820`);
-        navada.init({ lucas: `http://${detected.ec2}:8820` });
-      }
-      console.log(ui.success('Nodes configured'));
-    }
-  } else {
-    console.log(ui.dim('No nodes auto-detected. Enter manually:'));
+  // 2. Node IPs — optional
+  const configureNodes = await ask(rl, '  Configure network nodes? (y/N): ');
+  if (configureNodes.trim().toLowerCase() === 'y') {
+    console.log('');
+    console.log(ui.dim('  Enter Tailscale IPs for your NAVADA Edge nodes.'));
+    console.log(ui.dim('  Press Enter to skip any node.'));
+    console.log('');
+
     const asusIp = await ask(rl, '  ASUS IP (Production Engine): ');
     if (asusIp.trim()) {
       config.set('asus', asusIp.trim());
       config.set('mcp', `http://${asusIp.trim()}:8811`);
       config.set('dashboard', `http://${asusIp.trim()}:7900`);
       config.set('registry', `http://${asusIp.trim()}:5000`);
-      navada.init({ asus: asusIp.trim(), mcp: `http://${asusIp.trim()}:8811`, dashboard: `http://${asusIp.trim()}:7900`, registry: `http://${asusIp.trim()}:5000` });
+      navada.init({
+        asus: asusIp.trim(),
+        mcp: `http://${asusIp.trim()}:8811`,
+        dashboard: `http://${asusIp.trim()}:7900`,
+        registry: `http://${asusIp.trim()}:5000`,
+      });
     }
-    const hpIp = await ask(rl, '  HP IP (Database, press Enter to skip): ');
+    const hpIp = await ask(rl, '  HP IP (Database): ');
     if (hpIp.trim()) config.set('hp', hpIp.trim());
-    const ec2Ip = await ask(rl, '  EC2 IP (Monitoring, press Enter to skip): ');
+    const ec2Ip = await ask(rl, '  EC2 IP (Monitoring): ');
     if (ec2Ip.trim()) {
       config.set('ec2', ec2Ip.trim());
       config.set('lucas', `http://${ec2Ip.trim()}:8820`);
     }
-    const oracleIp = await ask(rl, '  Oracle IP (Docker Infra, press Enter to skip): ');
+    const oracleIp = await ask(rl, '  Oracle IP (Infrastructure): ');
     if (oracleIp.trim()) config.set('oracle', oracleIp.trim());
+    console.log(ui.success('Nodes configured'));
   }
   console.log('');
 
-  // 4. Choose theme
-  const theme = await ask(rl, '  Choose theme (dark/crow/matrix/light) [dark]: ');
+  // 3. Theme
+  const theme = await ask(rl, '  Theme (dark/crow/matrix/light) [dark]: ');
   config.setTheme(theme.trim() || 'dark');
-  console.log(ui.success(`Theme: ${config.getTheme()}`));
-  console.log('');
-
-  // 5. Test connections
-  console.log(ui.dim('Testing connections...'));
-  const tests = [
-    { name: 'MCP', url: navada.config.mcp ? navada.config.mcp + '/health' : '' },
-    { name: 'Dashboard', url: navada.config.dashboard || '' },
-    { name: 'Registry', url: navada.config.registry ? navada.config.registry + '/v2/_catalog' : '' },
-  ];
-  let pass = 0;
-  for (const t of tests) {
-    if (!t.url) { console.log(ui.online(t.name, false, 'not configured')); continue; }
-    try {
-      const r = await navada.request(t.url, { timeout: 5000 });
-      console.log(ui.online(t.name, r.status < 500));
-      pass++;
-    } catch {
-      console.log(ui.online(t.name, false, 'unreachable'));
-    }
-  }
   console.log('');
 
-  // 6. Summary
-  console.log(ui.box('SETUP COMPLETE', ` ${pass}/${tests.length} services connected\n Theme: ${config.getTheme()}\n Tier: ${config.getTier()}\n Config: ${config.CONFIG_FILE}`));
+  // 4. Done
+  console.log(ui.box('READY', ` Config saved: ${config.CONFIG_FILE}\n Type naturally to chat, or /help for commands.`));
   console.log('');
-  console.log(ui.dim('Run `navada` to start, or `navada doctor` to test all connections.'));
 
   rl.close();
 }
 
 module.exports = function(reg) {
-  reg('setup', 'Run onboarding wizard', async () => {
-    await runSetup();
+  reg('setup', 'Run setup wizard', async () => {
+    await runSetup(true);
   }, { category: 'SYSTEM' });
 };
 

package/lib/commands/system.js

@@ -65,11 +65,32 @@ module.exports = function(reg) {
   }, { category: 'SYSTEM' });
 
   // --- /login ---
-  reg('login', 'Set API key', (args) => {
-    if (!args[0]) { console.log(ui.dim('Usage: /login <api-key>')); return; }
-    config.setApiKey(args[0]);
-    navada.init({ mcpApiKey: args[0], dashboardApiKey: args[0] });
-    console.log(ui.success(`API key saved to ${config.CONFIG_FILE}`));
+  reg('login', 'Set API key (Anthropic, OpenAI, NAVADA Edge, or HuggingFace)', (args) => {
+    if (!args[0]) {
+      console.log(ui.dim('Usage: /login <api-key>'));
+      console.log(ui.dim('Accepts: sk-ant-... (Anthropic) | sk-... (OpenAI) | nv_edge_... (NAVADA) | hf_... (HuggingFace)'));
+      return;
+    }
+    const key = args[0].trim();
+    config.setApiKey(key);
+
+    if (key.startsWith('sk-ant')) {
+      config.set('anthropicKey', key);
+      console.log(ui.success('Anthropic key saved — full agent mode with tool use enabled'));
+    } else if (key.startsWith('hf_')) {
+      config.set('hfToken', key);
+      navada.init({ hfToken: key });
+      console.log(ui.success('HuggingFace key saved — Qwen Coder (FREE) enabled'));
+    } else if (key.startsWith('nv_edge')) {
+      navada.init({ mcpApiKey: key, dashboardApiKey: key });
+      console.log(ui.success('NAVADA Edge key saved — MCP + Dashboard access enabled'));
+    } else if (key.startsWith('sk-')) {
+      config.set('openaiKey', key);
+      navada.init({ openaiKey: key });
+      console.log(ui.success('OpenAI key saved — GPT-4o enabled'));
+    } else {
+      console.log(ui.success('Key saved'));
+    }
   }, { category: 'SYSTEM' });
 
   // --- /init ---
@@ -217,13 +238,67 @@ module.exports = function(reg) {
   }, { category: 'SYSTEM' });
 
   // --- /email ---
-  reg('email', 'Send email via MCP', async (args) => {
-    if (args.length < 3) { console.log(ui.dim('Usage: /email <to> <subject> <body>')); return; }
+  reg('email', 'Send email (SMTP or MCP)', async (args) => {
+    if (args[0] === 'setup') {
+      // Configure SMTP
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q) => new Promise(r => rl.question(q, r));
+
+      console.log(ui.header('EMAIL SETUP'));
+      console.log(ui.dim('  Providers: Hotmail (smtp-mail.outlook.com), Gmail (smtp.gmail.com), Zoho (smtp.zoho.eu)'));
+      console.log('');
+      const host = await ask('  SMTP host: ');
+      const port = await ask('  SMTP port [587]: ');
+      const user = await ask('  Email/username: ');
+      const pass = await ask('  Password/app password: ');
+      const from = await ask('  From address: ');
+      rl.close();
+
+      config.setSmtp({ host: host.trim(), port: parseInt(port.trim() || '587'), user: user.trim(), pass: pass.trim(), from: from.trim() || user.trim() });
+      console.log(ui.success('SMTP configured'));
+      return;
+    }
+
+    if (args.length < 3) {
+      console.log(ui.dim('Usage: /email <to> <subject> <body>'));
+      console.log(ui.dim('Setup: /email setup'));
+      return;
+    }
+
     const [to, subject, ...bodyParts] = args;
     const body = bodyParts.join(' ');
-    const result = await navada.mcp.call('send-email', { to, subject, body });
-    console.log(ui.success(`Email sent to ${to}`));
-  }, { category: 'SYSTEM' });
+    const smtp = config.getSmtp();
+
+    // Try local SMTP first
+    if (smtp.host && smtp.user && smtp.pass) {
+      try {
+        const nodemailer = require('nodemailer');
+        const transport = nodemailer.createTransport({
+          host: smtp.host, port: smtp.port, secure: smtp.port === 465,
+          auth: { user: smtp.user, pass: smtp.pass },
+        });
+        await transport.sendMail({ from: smtp.from || smtp.user, to, subject, text: body });
+        console.log(ui.success(`Email sent to ${to} via ${smtp.host}`));
+        return;
+      } catch (e) {
+        console.log(ui.warn(`SMTP failed: ${e.message}. Trying MCP...`));
+      }
+    }
+
+    // Fall back to MCP
+    if (navada.config.mcp) {
+      try {
+        await navada.mcp.call('send-email', { to, subject, body });
+        console.log(ui.success(`Email sent to ${to} via MCP`));
+        return;
+      } catch (e) {
+        console.log(ui.error(`MCP email failed: ${e.message}`));
+      }
+    }
+
+    console.log(ui.error('No email provider configured. Run /email setup to configure SMTP.'));
+  }, { category: 'SYSTEM', subs: ['setup'] });
 
   // --- /activity ---
   reg('activity', 'Recent activity log', async () => {

package/lib/config.js

@@ -44,7 +44,19 @@ function getServePort() { return parseInt(load().servePort || process.env.NAVADA
 function getTier() { return load().tier || 'FREE'; }
 function setTier(tier) { const c = load(); c.tier = tier; save(c); }
 
-function get(key) { return process.env[`NAVADA_${key.toUpperCase()}`] || load()[key] || ''; }
+// SMTP email config
+function getSmtp() {
+  return load().smtp || {
+    host: process.env.SMTP_HOST || '',
+    port: parseInt(process.env.SMTP_PORT || '587'),
+    user: process.env.SMTP_USER || '',
+    pass: process.env.SMTP_PASS || '',
+    from: process.env.SMTP_FROM || '',
+  };
+}
+function setSmtp(smtp) { const c = load(); c.smtp = smtp; save(c); }
+
+function get(key) { return process.env[`NAVADA_${key.toUpperCase()}`] || process.env[key.toUpperCase()] || process.env[key] || load()[key] || ''; }
 function set(key, value) { const c = load(); c[key] = value; save(c); }
 
 function getAll() { return { ...load(), apiKey: getApiKey() }; }
@@ -59,4 +71,5 @@ module.exports = {
   getServePort,
   getTier, setTier,
   get, set, getAll,
+  getSmtp, setSmtp,
 };

package/lib/registry.js

@@ -23,30 +23,45 @@ function register(name, description, handler, opts = {}) {
 }
 
 async function execute(input) {
-  const parts = input.trim().replace(/^\//, '').split(/\s+/);
-  let name = parts[0]?.toLowerCase();
-  const args = parts.slice(1);
+  const trimmed = input.trim();
+  if (!trimmed) return;
 
-  if (!name) return;
+  // If input starts with /, treat as a command
+  if (trimmed.startsWith('/')) {
+    const parts = trimmed.slice(1).split(/\s+/);
+    let name = parts[0]?.toLowerCase();
+    const args = parts.slice(1);
 
-  // Check user-defined aliases
-  const aliases = config.getAliases();
-  if (aliases[name]) {
-    const expanded = aliases[name].split(/\s+/);
-    name = expanded[0];
-    args.unshift(...expanded.slice(1));
-  }
+    if (!name) return;
 
-  const cmd = commands[name];
-  if (!cmd) {
-    const ui = require('./ui');
-    console.log(ui.error(`Unknown command: /${parts[0]}`));
-    console.log(ui.dim('Type /help for available commands'));
+    // Check user-defined aliases
+    const aliases = config.getAliases();
+    if (aliases[name]) {
+      const expanded = aliases[name].split(/\s+/);
+      name = expanded[0];
+      args.unshift(...expanded.slice(1));
+    }
+
+    const cmd = commands[name];
+    if (!cmd) {
+      const ui = require('./ui');
+      console.log(ui.error(`Unknown command: /${parts[0]}`));
+      console.log(ui.dim('Type /help for available commands'));
+      return;
+    }
+
+    try {
+      await cmd.handler(args);
+    } catch (e) {
+      const ui = require('./ui');
+      console.log(ui.error(e.message));
+    }
     return;
   }
 
+  // No slash — treat as natural language → route to AI agent
   try {
-    await cmd.handler(args);
+    await commands['chat'].handler(trimmed.split(/\s+/));
   } catch (e) {
     const ui = require('./ui');
     console.log(ui.error(e.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navada-edge-cli",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Interactive CLI for the NAVADA Edge Network — explore nodes, agents, Cloudflare, AI, Docker, and MCP from your terminal",
   "main": "lib/cli.js",
   "bin": {
@@ -36,7 +36,8 @@
     "ora": "^5.4.1"
   },
   "optionalDependencies": {
-    "qrcode-terminal": "^0.12.0"
+    "qrcode-terminal": "^0.12.0",
+    "nodemailer": "^6.9.0"
   },
   "publishConfig": {
     "access": "public"