navada-edge-cli 1.1.0 → 2.0.0

package/Dockerfile

@@ -0,0 +1,3 @@
+FROM node:22-slim
+RUN npm install -g navada-edge-cli@2.0.0
+ENTRYPOINT ["navada"]

package/docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  cli:
+    build: .
+    image: navada-edge-cli:2.0.0
+    container_name: navada-edge-cli
+    env_file: .env
+    stdin_open: true
+    tty: true
+    ports:
+      - "${SERVE_PORT:-7800}:7800"

package/lib/cli.js

@@ -3,41 +3,55 @@
 const readline = require('readline');
 const navada = require('navada-edge-sdk');
 const ui = require('./ui');
-const auth = require('./auth');
-const { execute, commands } = require('./commands');
+const config = require('./config');
+const history = require('./history');
+const { completer } = require('./completer');
+const { execute, getCompletions } = require('./registry');
+const { loadAll } = require('./commands/index');
 
 function applyConfig() {
-  const config = auth.getConfig();
+  const cfg = config.getAll();
   const overrides = {};
-  if (config.apiKey) { overrides.mcpApiKey = config.apiKey; overrides.dashboardApiKey = config.apiKey; }
-  if (config.asus) overrides.asus = config.asus;
-  if (config.hp) overrides.hp = config.hp;
-  if (config.ec2) overrides.ec2 = config.ec2;
-  if (config.oracle) overrides.oracle = config.oracle;
-  if (config.mcp) overrides.mcp = config.mcp;
-  if (config.dashboard) overrides.dashboard = config.dashboard;
-  if (config.registry) overrides.registry = config.registry;
-  if (config.lucas) overrides.lucas = config.lucas;
+  const map = {
+    apiKey: ['mcpApiKey', 'dashboardApiKey'],
+    asus: ['asus'], hp: ['hp'], ec2: ['ec2'], oracle: ['oracle'],
+    mcp: ['mcp'], dashboard: ['dashboard'], registry: ['registry'],
+    lucas: ['lucas'], portainer: ['portainer'],
+    cfAccountId: ['cfAccountId'], cfApiToken: ['cfApiToken'],
+    cfR2Bucket: ['cfR2Bucket'], cfDomain: ['cfDomain'],
+    cfZoneId: ['cfZoneId'], cfStreamSubdomain: ['cfStreamSubdomain'],
+    azureN8nUrl: ['azureN8nUrl'], azureN8nRg: ['azureN8nRg'], azureN8nApp: ['azureN8nApp'],
+    yoloUrl: ['yoloUrl'], hfToken: ['hfToken'], openaiKey: ['openaiKey'],
+    pgHost: ['pgHost'], pgPort: ['pgPort'], pgDb: ['pgDb'], pgUser: ['pgUser'], pgPass: ['pgPass'],
+    opencodePassword: ['opencodePassword'],
+  };
+
+  for (const [cfgKey, sdkKeys] of Object.entries(map)) {
+    if (cfg[cfgKey]) {
+      for (const sk of sdkKeys) overrides[sk] = cfg[cfgKey];
+    }
+  }
+
   if (Object.keys(overrides).length > 0) navada.init(overrides);
 }
 
 function showWelcome() {
   console.clear();
-  console.log(ui.LOGO);
+  console.log(ui.banner());
   console.log(ui.dim('Type /help for commands. Tab to autocomplete. Ctrl+C to exit.'));
   console.log('');
 }
 
 function startRepl() {
+  const historyItems = history.load();
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: ui.prompt(),
-    completer: (line) => {
-      const cmds = Object.keys(commands).map(c => '/' + c);
-      const hits = cmds.filter(c => c.startsWith(line));
-      return [hits.length ? hits : cmds, line];
-    },
+    completer,
+    history: historyItems,
+    historySize: 1000,
   });
 
   rl.prompt();
@@ -45,6 +59,7 @@ function startRepl() {
   rl.on('line', async (line) => {
     const input = line.trim();
     if (input) {
+      history.append(input);
       await execute(input);
     }
     console.log('');
@@ -58,14 +73,23 @@ function startRepl() {
 }
 
 async function runDirect(args) {
-  const input = args.join(' ');
-  await execute(input);
+  await execute(args.join(' '));
 }
 
-function run(argv) {
+async function run(argv) {
+  // Load all command modules
+  loadAll();
+
+  // Apply saved config
   applyConfig();
 
   if (argv.length === 0) {
+    // Check first run
+    if (config.isFirstRun()) {
+      const { runSetup } = require('./commands/setup');
+      await runSetup();
+      return;
+    }
     // Interactive mode
     showWelcome();
     startRepl();
@@ -73,24 +97,34 @@ function run(argv) {
     const pkg = require('../package.json');
     console.log(`navada-edge-cli v${pkg.version}`);
   } else if (argv[0] === '--help' || argv[0] === '-h') {
-    console.log(ui.LOGO);
+    console.log(ui.banner());
     console.log('  Usage:');
-    console.log('    navada                     Interactive mode');
+    console.log('    navada                     Interactive mode (first run triggers setup)');
+    console.log('    navada setup               Run onboarding wizard');
     console.log('    navada status              Ping all nodes');
+    console.log('    navada doctor              Test all connections');
     console.log('    navada mcp tools           List MCP tools');
     console.log('    navada registry            List Docker images');
-    console.log('    navada chat "question"     Chat with GPT-4o');
+    console.log('    navada agents              Show Lucas + Claude status');
+    console.log('    navada chat "question"     Chat with AI');
     console.log('    navada login <key>         Set API key');
+    console.log('    navada theme crow          Switch theme');
     console.log('    navada --version           Show version');
     console.log('');
     console.log('  Run `navada` with no args for interactive mode.');
     console.log('');
+  } else if (argv[0] === '--serve') {
+    const serve = require('./serve');
+    const port = parseInt(argv[1]) || config.getServePort();
+    serve.start(port);
   } else {
     // Direct command mode
-    runDirect(argv).then(() => process.exit(0)).catch(e => {
+    try {
+      await runDirect(argv);
+    } catch (e) {
       console.log(ui.error(e.message));
       process.exit(1);
-    });
+    }
   }
 }
 

package/lib/commands/agents.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+
+  reg('agents', 'Show NAVADA Edge agents status', async () => {
+    console.log(ui.header('NAVADA EDGE AGENTS'));
+
+    // Lucas CTO
+    if (navada.config.lucas) {
+      try {
+        const r = await navada.request(navada.config.lucas + '/health', { timeout: 5000 });
+        console.log(ui.online('Lucas CTO', r.status < 500, `MCP ${navada.config.lucas}`));
+      } catch {
+        console.log(ui.online('Lucas CTO', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('Lucas CTO', false, 'not configured'));
+    }
+    console.log(ui.dim('  Tools: bash, ssh, docker_exec, deploy, read_file, write_file, list_files, network_status'));
+
+    console.log('');
+
+    // Claude CoS
+    if (navada.config.dashboard) {
+      try {
+        const r = await navada.request(navada.config.dashboard + '/api/agent-heartbeat', { timeout: 5000 });
+        console.log(ui.online('Claude CoS', r.status < 500, `Dashboard ${navada.config.dashboard}`));
+      } catch {
+        console.log(ui.online('Claude CoS', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('Claude CoS', false, 'not configured'));
+    }
+    console.log(ui.dim('  Controls: Telegram, email, SMS, image gen, R2, cost tracking'));
+
+    console.log('');
+    // MCP Server
+    if (navada.config.mcp) {
+      try {
+        const r = await navada.request(navada.config.mcp + '/health', { timeout: 5000 });
+        console.log(ui.online('MCP Server', r.status < 500, `${navada.config.mcp}`));
+        if (r.data?.version) console.log(ui.dim(`  Version: ${r.data.version}`));
+      } catch {
+        console.log(ui.online('MCP Server', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('MCP Server', false, 'not configured'));
+    }
+  }, { category: 'AGENTS' });
+
+  reg('claude', 'Send message to Claude CoS', async (args) => {
+    const msg = args.join(' ');
+    if (!msg) { console.log(ui.dim('Usage: /claude Check HP disk space')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Asking Claude...', color: 'white' }).start();
+    try {
+      // Try via MCP first
+      const result = await navada.mcp.call('chat', { message: msg, agent: 'claude' });
+      spinner.stop();
+      console.log(ui.header('CLAUDE'));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
+    } catch {
+      spinner.stop();
+      console.log(ui.warn('Claude agent not available via MCP. Try /lucas exec for direct commands.'));
+    }
+  }, { category: 'AGENTS' });
+};

package/lib/commands/ai.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+const config = require('../config');
+
+module.exports = function(reg) {
+
+  reg('chat', 'Chat with AI (uses configured model)', async (args) => {
+    const msg = args.join(' ');
+    if (!msg) { console.log(ui.dim('Usage: /chat What is the ISA allowance for 2026?')); return; }
+    const ora = require('ora');
+    const model = config.getModel();
+
+    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);
+      spinner.stop();
+      console.log(ui.header('AI RESPONSE'));
+      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.'));
+      }
+    }
+  }, { category: 'AI', aliases: ['ask'] });
+
+  reg('qwen', 'Qwen Coder 32B (FREE via HuggingFace)', async (args) => {
+    const prompt = args.join(' ');
+    if (!prompt) { console.log(ui.dim('Usage: /qwen Write a function to validate UK postcodes')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Qwen thinking...', color: 'white' }).start();
+    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}`);
+  }, { category: 'AI' });
+
+  reg('yolo', 'YOLO object detection', async (args) => {
+    if (args[0] === 'detect' && args[1]) {
+      const ora = require('ora');
+      const spinner = ora({ text: '  Detecting...', color: 'white' }).start();
+      const result = await navada.ai.yolo.detect(args[1]);
+      spinner.stop();
+      console.log(ui.header(`DETECTIONS (${result.count || 0})`));
+      if (result.detections) {
+        result.detections.forEach(d => console.log(ui.label(d.class, `${(d.confidence * 100).toFixed(1)}%`)));
+      }
+      console.log(ui.dim(`Inference: ${result.inference_ms}ms`));
+    } else if (args[0] === 'model') {
+      const model = await navada.ai.yolo.model();
+      console.log(ui.header('YOLO MODEL'));
+      console.log(ui.jsonColorize(model));
+    } else {
+      const health = await navada.ai.yolo.health();
+      console.log(ui.header('YOLO'));
+      console.log(ui.online('YOLO Service', health.status === 'ok'));
+    }
+  }, { category: 'AI', subs: ['detect', 'model'] });
+
+  reg('image', 'Generate an image', async (args) => {
+    const prompt = args.filter(a => !a.startsWith('--')).join(' ');
+    if (!prompt) { console.log(ui.dim('Usage: /image a futuristic city | /image --dalle NAVADA logo')); return; }
+    const useDalle = args.includes('--dalle');
+    const ora = require('ora');
+
+    if (useDalle && navada.config.openaiKey) {
+      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 savePath = `navada-image-${Date.now()}.png`;
+      const { size } = await navada.cloudflare.flux.generate(prompt, { savePath });
+      spinner.stop();
+      console.log(ui.success(`Generated: ${savePath} (${(size / 1024).toFixed(1)} KB)`));
+    }
+  }, { category: 'AI' });
+
+  reg('model', 'Show/set default AI model', (args) => {
+    if (args[0]) {
+      const valid = ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'];
+      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]}`));
+    } else {
+      console.log(ui.header('AI MODELS'));
+      const current = config.getModel();
+      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('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'));
+    }
+  }, { category: 'AI', subs: ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'] });
+
+  reg('research', 'RAG search via MCP', async (args) => {
+    const query = args.join(' ');
+    if (!query) { console.log(ui.dim('Usage: /research Docker networking best practices')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Searching...', color: 'white' }).start();
+    const result = await navada.mcp.call('rag-search', { query });
+    spinner.stop();
+    console.log(ui.header('RESEARCH'));
+    console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
+  }, { category: 'AI' });
+};

package/lib/commands/azure.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+  reg('n8n', 'Azure n8n health + restart', async (args) => {
+    if (args[0] === 'restart') {
+      const result = navada.azure.n8n.restart();
+      console.log(result.ok ? ui.success(result.message) : ui.error(result.message));
+    } else {
+      const result = await navada.azure.n8n.health();
+      console.log(ui.header('AZURE N8N'));
+      console.log(ui.online('n8n', result.ok, result.status ? `HTTP ${result.status}` : result.error));
+      console.log(ui.label('URL', result.url || 'not set'));
+    }
+  }, { category: 'AZURE', subs: ['restart'] });
+};

package/lib/commands/cloudflare.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+  reg('r2', 'Cloudflare R2 storage', async (args) => {
+    const sub = args[0];
+    if (sub === 'buckets') {
+      const buckets = await navada.cloudflare.r2.buckets();
+      console.log(ui.header('R2 BUCKETS'));
+      if (Array.isArray(buckets)) buckets.forEach(b => console.log(`  ${b.name || b}`));
+      else console.log(ui.jsonColorize(buckets));
+    } else if (sub === 'ls') {
+      const prefix = args[1] || '';
+      const objects = await navada.cloudflare.r2.list(prefix);
+      console.log(ui.header(`R2: ${prefix || '/'}`));
+      if (Array.isArray(objects)) objects.forEach(o => console.log(`  ${o.key || o}`));
+      else console.log(ui.jsonColorize(objects));
+    } else if (sub === 'upload' && args[1] && args[2]) {
+      const ora = require('ora');
+      const spinner = ora({ text: `  Uploading ${args[1]}...`, color: 'white' }).start();
+      const result = await navada.cloudflare.r2.upload(args[1], args[2]);
+      spinner.stop();
+      console.log(ui.success(`Uploaded: ${result.key} (${result.size} bytes)`));
+    } else if (sub === 'delete' && args[1]) {
+      await navada.cloudflare.r2.delete(args[1]);
+      console.log(ui.success(`Deleted: ${args[1]}`));
+    } else if (sub === 'url' && args[1]) {
+      console.log(navada.cloudflare.r2.publicUrl(args[1]));
+    } else {
+      console.log(ui.dim('Usage: /r2 ls [prefix] | buckets | upload <key> <file> | delete <key> | url <key>'));
+    }
+  }, { category: 'CLOUDFLARE', subs: ['ls', 'buckets', 'upload', 'delete', 'url'] });
+
+  reg('dns', 'Cloudflare DNS records', async (args) => {
+    if (args[0] === 'create' && args[1] && args[2] && args[3]) {
+      await navada.cloudflare.dns.create(args[1], args[2], args[3]);
+      console.log(ui.success(`Created: ${args[1]} ${args[2]} -> ${args[3]}`));
+    } else {
+      const records = await navada.cloudflare.dns.list(args[0]);
+      console.log(ui.header('DNS RECORDS'));
+      records.forEach(r => console.log(ui.label(`${r.type} ${r.name}`, r.content?.slice(0, 50) || '')));
+    }
+  }, { category: 'CLOUDFLARE', subs: ['create'] });
+
+  reg('tunnel', 'Cloudflare tunnels', async () => {
+    const tunnels = await navada.cloudflare.tunnel.list();
+    console.log(ui.header(`TUNNELS (${tunnels.length})`));
+    tunnels.forEach(t => console.log(ui.label(t.name || t.id, t.status || '')));
+  }, { category: 'CLOUDFLARE' });
+
+  reg('stream', 'Cloudflare Stream videos', async () => {
+    const videos = await navada.cloudflare.stream.list();
+    console.log(ui.header(`VIDEOS (${videos.length})`));
+    videos.forEach(v => console.log(ui.label(v.meta?.name || 'Untitled', `${v.uid}  ${v.status?.state || ''}`)));
+  }, { category: 'CLOUDFLARE' });
+
+  reg('flux', 'Generate image (FREE Cloudflare AI)', async (args) => {
+    const prompt = args.join(' ');
+    if (!prompt) { console.log(ui.dim('Usage: /flux a futuristic server room')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: `  Generating: "${prompt}"...`, color: 'white' }).start();
+    const savePath = `navada-flux-${Date.now()}.png`;
+    const { size } = await navada.cloudflare.flux.generate(prompt, { savePath });
+    spinner.stop();
+    console.log(ui.success(`Generated: ${savePath} (${(size / 1024).toFixed(1)} KB)`));
+  }, { category: 'CLOUDFLARE' });
+
+  reg('trace', 'Trace request through Cloudflare WAF', async (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /trace https://your-domain.com')); return; }
+    const result = await navada.cloudflare.trace(args[0]);
+    console.log(ui.header('CLOUDFLARE TRACE'));
+    console.log(ui.jsonColorize(result));
+  }, { category: 'CLOUDFLARE' });
+};

package/lib/commands/database.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const Table = require('cli-table3');
+const ui = require('../ui');
+const { tableChars } = require('./helpers');
+
+module.exports = function(reg) {
+  reg('db', 'Query Postgres', async (args) => {
+    const sql = args.join(' ');
+    if (!sql) { console.log(ui.dim('Usage: /db SELECT NOW()')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Querying...', color: 'white' }).start();
+    const rows = await navada.db.query(sql);
+    spinner.stop();
+    if (rows.length === 0) { console.log(ui.dim('No rows returned')); return; }
+    const t = new Table({ head: Object.keys(rows[0]), style: { head: ['white'], border: ['gray'] }, chars: tableChars() });
+    rows.slice(0, 50).forEach(row => t.push(Object.values(row).map(v => String(v ?? ''))));
+    console.log(t.toString());
+    if (rows.length > 50) console.log(ui.dim(`... ${rows.length - 50} more rows`));
+  }, { category: 'DATABASE' });
+};

package/lib/commands/docker.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+  reg('registry', 'Docker registry images', async (args) => {
+    if (args[0] === 'tags' && args[1]) {
+      const tags = await navada.registry.tags(args[1]);
+      console.log(ui.header(`TAGS: ${args[1]}`));
+      tags.forEach(t => console.log(`  ${t}`));
+    } else {
+      const ora = require('ora');
+      const spinner = ora({ text: '  Querying registry...', color: 'white' }).start();
+      const images = await navada.registry.catalog();
+      spinner.stop();
+      console.log(ui.header(`DOCKER REGISTRY (${images.length} images)`));
+      images.forEach(img => console.log(`  ${img}`));
+    }
+  }, { category: 'DOCKER', subs: ['tags'] });
+
+  reg('logs', 'View container logs', async (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /logs <container-name>')); return; }
+    if (!navada.config.dashboard) throw new Error('NAVADA_DASHBOARD not set');
+    const node = args[1] || 'asus';
+    const r = await navada.request(`${navada.config.dashboard}/api/docker/${node}/${args[0]}`);
+    console.log(ui.header(`LOGS: ${args[0]} (${node})`));
+    console.log(typeof r.data === 'string' ? r.data : ui.jsonColorize(r.data));
+  }, { category: 'DOCKER', subs: [] });
+
+  reg('deploy', 'Deploy container to a node', async (args) => {
+    if (!args[0] || !args[1]) { console.log(ui.dim('Usage: /deploy <name> <node>')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: `  Deploying ${args[0]} to ${args[1]}...`, color: 'white' }).start();
+    const result = await navada.lucas.deploy(args[0], args[1]);
+    spinner.stop();
+    console.log(ui.success(`Deployed ${args[0]} to ${args[1]}`));
+    if (result) console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+  }, { category: 'DOCKER' });
+};

package/lib/commands/helpers.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function tableChars() {
+  return {
+    'top': '─', 'top-mid': '┬', 'top-left': '╭', 'top-right': '╮',
+    'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '╰', 'bottom-right': '╯',
+    'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+    'right': '│', 'right-mid': '┤', 'middle': '│',
+  };
+}
+
+module.exports = { tableChars };

package/lib/commands/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { register } = require('../registry');
+
+// Load all command modules — each exports a function(register)
+const modules = [
+  require('./network'),
+  require('./mcp'),
+  require('./lucas'),
+  require('./docker'),
+  require('./database'),
+  require('./cloudflare'),
+  require('./ai'),
+  require('./azure'),
+  require('./agents'),
+  require('./tasks'),
+  require('./keys'),
+  require('./setup'),
+  require('./system'),
+];
+
+function loadAll() {
+  for (const mod of modules) {
+    mod(register);
+  }
+}
+
+module.exports = { loadAll };

package/lib/commands/keys.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+  reg('keys', 'API key management', async (args) => {
+    if (!navada.config.dashboard) throw new Error('NAVADA_DASHBOARD not set');
+    const base = navada.config.dashboard + '/api/keys';
+
+    if (!args[0] || args[0] === 'list') {
+      const r = await navada.request(base);
+      console.log(ui.header('API KEYS'));
+      const keys = Array.isArray(r.data) ? r.data : [];
+      if (keys.length === 0) { console.log(ui.dim('No API keys')); return; }
+      keys.forEach(k => {
+        const masked = k.key ? k.key.slice(0, 8) + '...' + k.key.slice(-4) : k.id || '';
+        console.log(ui.label(masked, `${k.tier || 'unknown'}  ${k.name || ''}`));
+      });
+    } else if (args[0] === 'create') {
+      const name = args.slice(1).join(' ') || 'CLI Key';
+      const r = await navada.request(base, { method: 'POST', body: { name } });
+      console.log(ui.success('Key created'));
+      console.log(ui.jsonColorize(r.data));
+    } else if (args[0] === 'delete' && args[1]) {
+      await navada.request(`${base}/${args[1]}`, { method: 'DELETE' });
+      console.log(ui.success(`Deleted: ${args[1]}`));
+    } else {
+      console.log(ui.dim('Usage: /keys | /keys create [name] | /keys delete <key>'));
+    }
+  }, { category: 'KEYS', subs: ['list', 'create', 'delete'] });
+};

package/lib/commands/lucas.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+  reg('lucas', 'Lucas CTO agent commands', async (args) => {
+    const sub = args[0];
+    if (sub === 'exec' && args[1]) {
+      const cmd = args.slice(1).join(' ');
+      const result = await navada.lucas.exec(cmd);
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'ssh' && args[1] && args[2]) {
+      const result = await navada.lucas.ssh(args[1], args.slice(2).join(' '));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'docker' && args[1] && args[2]) {
+      const result = await navada.lucas.docker(args[1], args.slice(2).join(' '));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'deploy' && args[1] && args[2]) {
+      const ora = require('ora');
+      const spinner = ora({ text: `  Deploying ${args[1]} to ${args[2]}...`, color: 'white' }).start();
+      const result = await navada.lucas.deploy(args[1], args[2]);
+      spinner.stop();
+      console.log(ui.success(`Deployed ${args[1]} to ${args[2]}`));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'status') {
+      const result = await navada.lucas.networkStatus();
+      console.log(ui.header('LUCAS NETWORK STATUS'));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'files' && args[1]) {
+      const result = await navada.lucas.listFiles(args[1]);
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : result);
+    } else if (sub === 'read' && args[1]) {
+      const result = await navada.lucas.readFile(args[1]);
+      console.log(typeof result === 'string' ? result : ui.jsonColorize(result));
+    } else {
+      console.log(ui.dim('Usage: /lucas exec <cmd> | ssh <node> <cmd> | docker <ctr> <cmd> | deploy <name> <node> | status | files <dir> | read <file>'));
+    }
+  }, { category: 'AGENTS', subs: ['exec', 'ssh', 'docker', 'deploy', 'status', 'files', 'read'] });
+};