navada-edge-cli 3.0.2 → 3.2.0

package/Dockerfile

@@ -1,3 +1,25 @@
 FROM node:22-slim
-RUN npm install -g navada-edge-cli@2.0.0
-ENTRYPOINT ["navada"]
+
+LABEL maintainer="Leslie Akpareva <leeakpareva@hotmail.com>"
+LABEL org.opencontainers.image.title="navada-edge-cli"
+LABEL org.opencontainers.image.description="NAVADA Edge CLI — interactive terminal agent"
+
+# Install Python for python tools
+RUN apt-get update && apt-get install -y --no-install-recommends python3 python3-pip && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy package files and install
+COPY package.json package-lock.json ./
+RUN npm ci --production
+
+# Copy source
+COPY bin/ bin/
+COPY lib/ lib/
+COPY LICENSE README.md ./
+
+# Config directory
+RUN mkdir -p /root/.navada
+
+ENTRYPOINT ["node", "bin/navada.js"]

package/README.md

@@ -10,34 +10,50 @@ npm install -g navada-edge-cli
 
 **NAVADA Edge CLI** is a production-grade terminal tool that gives developers and infrastructure teams an AI agent with full system access, connected to a distributed computing network.
 
+### Install
+
+```bash
+npm install -g navada-edge-cli
+navada
+```
+
+Or run with Docker:
+
+```bash
+docker run -it navada-edge-cli:3.0.2
+```
+
 **The problem:** Managing distributed infrastructure across multiple cloud providers, on-prem servers, and services requires jumping between terminals, dashboards, and APIs. AI assistants answer questions but can't execute.
 
-**The solution:** One CLI that talks naturally, executes commands locally and remotely, and unifies access to your entire infrastructure through a conversational AI agent with 13 built-in tools.
+**The solution:** One CLI that talks naturally, executes commands locally and remotely, and unifies access to your entire infrastructure through a conversational AI agent with tool use, streaming, and smart model routing.
 
 **Key differentiators:**
+- **Free tier included** — Grok AI with 30 RPM, no API key needed, just install and go
+- **Multi-provider AI** — Anthropic (Claude Sonnet 4), OpenAI (GPT-4o/mini), Grok, Qwen Coder — all with streaming
+- **Smart routing** — auto-picks the best model: code queries to Qwen, complex to Claude, general to Grok
 - **Conversational AI agent** — type naturally, the agent uses tools to execute (not just answer)
-- **Full computer access** — shell, files, processes on your local machine
+- **Full computer access** — shell, files, processes, Python execution on your local machine
 - **Distributed network** — 4 physical nodes connected via Tailscale VPN, managed from one terminal
 - **Two sub-agents** — Lucas CTO (infrastructure) and Claude CoS (communications + automation)
 - **Cloud-native** — Cloudflare (R2, Flux AI, Stream, DNS), Azure (n8n), private Docker registry
-- **5 AI models** — Claude Sonnet 4, GPT-4o, Qwen Coder (FREE), YOLO v8, Flux (FREE)
-- **45+ slash commands** — direct access when you need precision
+- **58 slash commands** — direct access when you need precision
+- **3 learning modes** — `/learn python`, `/learn csharp`, `/learn node` — interactive tutor mode
+- **Split-panel TUI** — session info, token usage, rate limits, provider status
 - **4 themes** — dark, crow (achromatic), matrix, light
-- **Mobile access** — HTTP server with web UI, accessible from phone
+- **Docker-first** — runs as a container with `restart: always`, ships with Dockerfile
 - **Cross-platform** — Windows, macOS, Linux
-- **Docker ready** — run as a container with `docker run -it navada-edge-cli`
-- **Zero config to start** — install, login with any API key, start talking
+- **Zero config to start** — install and start talking, free tier works immediately
 
 **Who it's for:** DevOps engineers, infrastructure teams, AI developers, and anyone who manages distributed systems and wants an AI copilot in their terminal.
 
-**Pricing:** The CLI is free and open source (MIT). AI features require your own API key (Anthropic, OpenAI, or HuggingFace — Qwen is free). Network features require access to a NAVADA Edge Network instance.
+**Pricing:** The CLI is free and open source (MIT). Free tier (Grok) works out of the box. Add your own API key for full agent mode (Anthropic, OpenAI, or HuggingFace).
 
 ```
 ╭─────────────────────────────────────────────────────────╮
 │   ███╗   ██╗ █████╗ ██╗   ██╗ █████╗ ██████╗  █████╗    │
 │   ██╔██╗ ██║███████║██║   ██║███████║██║  ██║███████║   │
 │   ██║ ╚████║██║  ██║ ╚████╔╝ ██║  ██║██████╔╝██║  ██║   │
-│            E D G E   N E T W O R K   v2.1.1             │
+│            E D G E   N E T W O R K   v3.0.2             │
 ╰─────────────────────────────────────────────────────────╯
 ```
 

package/docker-compose.yml

@@ -1,10 +1,16 @@
 services:
   cli:
     build: .
-    image: navada-edge-cli:2.0.0
+    image: navada-edge-cli:3.2.0
     container_name: navada-edge-cli
-    env_file: .env
+    restart: always
     stdin_open: true
     tty: true
-    ports:
-      - "${SERVE_PORT:-7800}:7800"
+    volumes:
+      - cli-config:/root/.navada
+    environment:
+      - NODE_ENV=production
+      - TERM=xterm-256color
+
+volumes:
+  cli-config:

package/lib/agent.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -17,15 +17,51 @@ const config = require('./config');
 const IDENTITY = {
   name: 'NAVADA Edge',
   role: 'AI Infrastructure Agent',
-  personality: `You are NAVADA Edge — an AI agent that operates inside the user's terminal.
+  personality: `You are NAVADA Edge — an AI agent built by Lee Akpareva (Principal AI Consultant, MBA, MA) 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.
+You have FULL ACCESS to the user's computer — you CAN and SHOULD use your tools to execute tasks:
+  - shell: run ANY bash, PowerShell, or system command on the user's machine
+  - read_file / write_file / list_files: full filesystem access — create, read, modify any file
+  - python_exec / python_pip / python_script: run Python code directly
+  - sandbox_run: run code with syntax-highlighted output
+  - system_info: check CPU, RAM, disk, OS
+You also connect to the NAVADA Edge Network (4 nodes via Tailscale VPN):
+  - lucas_exec / lucas_ssh / lucas_docker: execute commands on remote nodes (EC2, HP, Oracle)
+  - mcp_call: access 18 MCP tools on the ASUS server
+  - docker_registry: manage the private Docker registry
+  - send_email / generate_image: communications and AI image generation
+  - founder_info: information about Lee Akpareva, the creator of NAVADA
+When users ask you to DO something — DO IT. Use write_file to create files. Use shell to run commands. Never say "I can't" when you have a tool for it.
 Keep responses short. Code blocks when needed. No fluff.`,
+  founder: {
+    name: 'Leslie (Lee) Akpareva',
+    title: 'Principal AI Consultant & Founder, NAVADA Edge Network',
+    qualifications: 'MBA (Business Administration), MA (International Relations), EF8 Alumni',
+    experience: '17+ years in enterprise IT, insurance, and AI infrastructure',
+    current_role: 'AI Project Lead at Generali UK (insurance)',
+    expertise: [
+      'AI/ML infrastructure and deployment',
+      'Distributed systems and edge computing',
+      'Docker containerisation and orchestration',
+      'Cloud architecture (AWS, Azure, Oracle, Cloudflare)',
+      'MCP (Model Context Protocol) server development',
+      'Full-stack development (Node.js, Python, React, Next.js)',
+      'Enterprise IT transformation and automation',
+    ],
+    projects: [
+      'NAVADA Edge Network — distributed AI home server (4 nodes, 25+ containers)',
+      'NAVADA Edge SDK + CLI — npm packages for network access',
+      'WorldMonitor — OSINT intelligence dashboard',
+      'Lucas CTO — autonomous infrastructure agent',
+      'OpenCode — open source coding assistant',
+      'NAVADA Robotics — robotics and hardware',
+      'Raven Terminal — security terminal',
+    ],
+    contact: {
+      github: 'github.com/leeakpareva',
+      website: 'navada-lab.space',
+    },
+  },
 };
 
 function getSystemPrompt() {
@@ -50,8 +86,30 @@ const sessionState = {
   messages: 0,
   startTime: Date.now(),
   learningMode: null,  // 'python' | 'csharp' | 'node' | null
+  history: [],         // conversation history for context continuity
 };
 
+// Conversation history management
+function addToHistory(role, content) {
+  sessionState.history.push({ role, content });
+  // Keep last 40 turns to avoid token overflow
+  if (sessionState.history.length > 40) {
+    sessionState.history = sessionState.history.slice(-40);
+  }
+  sessionState.messages++;
+}
+
+function getConversationHistory() {
+  return sessionState.history;
+}
+
+function clearHistory() {
+  sessionState.history = [];
+  sessionState.messages = 0;
+  sessionState.tokens = { input: 0, output: 0, total: 0 };
+  sessionState.cost = 0;
+}
+
 // ---------------------------------------------------------------------------
 // Rate limit tracking (in-memory, per session)
 // ---------------------------------------------------------------------------
@@ -154,7 +212,8 @@ const localTools = {
     execute: (code) => {
       try {
         const py = process.platform === 'win32' ? 'python' : 'python3';
-        const output = execSync(`${py} -c "${code.replace(/"/g, '\\"')}"`, {
+        // Safe: use execFileSync with -c flag — no shell interpolation
+        const output = execFileSync(py, ['-c', code], {
           timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
         });
         return output.trim();
@@ -168,8 +227,12 @@ const localTools = {
     description: 'Install a Python package',
     execute: (pkg) => {
       try {
+        // Validate package name — alphanumeric, hyphens, underscores, dots, brackets, version specifiers
+        if (!/^[a-zA-Z0-9._\-\[\],>=<! ]+$/.test(pkg)) {
+          return 'Error: Invalid package name';
+        }
         const py = process.platform === 'win32' ? 'python' : 'python3';
-        const output = execSync(`${py} -m pip install ${pkg}`, {
+        const output = execFileSync(py, ['-m', 'pip', 'install', ...pkg.split(/\s+/)], {
           timeout: 60000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
         });
         return output.trim().split('\n').slice(-3).join('\n');
@@ -183,10 +246,12 @@ const localTools = {
     description: 'Run a Python script file',
     execute: (scriptPath) => {
       try {
+        const resolved = path.resolve(scriptPath);
+        if (!fs.existsSync(resolved)) return `Error: File not found: ${resolved}`;
         const py = process.platform === 'win32' ? 'python' : 'python3';
-        const output = execSync(`${py} "${path.resolve(scriptPath)}"`, {
+        const output = execFileSync(py, [resolved], {
           timeout: 60000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
-          cwd: path.dirname(path.resolve(scriptPath)),
+          cwd: path.dirname(resolved),
         });
         return output.trim();
       } catch (e) {
@@ -194,6 +259,11 @@ const localTools = {
       }
     },
   },
+
+  founderInfo: {
+    description: 'Get information about the NAVADA Edge founder',
+    execute: () => JSON.stringify(IDENTITY.founder, null, 2),
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -201,7 +271,6 @@ const localTools = {
 // ---------------------------------------------------------------------------
 const FREE_TIER_ENDPOINTS = [
   'https://api.navada-edge-server.uk/api/v1/chat',    // Cloudflare tunnel (public, works for all)
-  'http://100.88.118.128:7900/api/v1/chat',           // Direct Tailscale (VPN users only)
 ];
 
 async function callFreeTier(messages, stream = false) {
@@ -592,11 +661,13 @@ function detectIntent(message) {
 async function chat(userMessage, conversationHistory = []) {
   const anthropicKey = config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY || '';
   const openaiKey = config.get('openaiKey') || process.env.OPENAI_API_KEY || '';
+  const nvidiaKey = config.get('nvidiaKey') || process.env.NVIDIA_API_KEY || '';
   const apiKey = config.getApiKey() || '';
 
   // Determine which provider to use
   const effectiveAnthropicKey = anthropicKey || (apiKey.startsWith('sk-ant') ? apiKey : '');
   const effectiveOpenAIKey = openaiKey || (apiKey.startsWith('sk-') && !apiKey.startsWith('sk-ant') ? apiKey : '');
+  const effectiveNvidiaKey = nvidiaKey || (apiKey.startsWith('nvapi-') ? apiKey : '');
 
   const modelPref = config.getModel();
   const intent = detectIntent(userMessage);
@@ -604,10 +675,11 @@ async function chat(userMessage, conversationHistory = []) {
   // Track active provider for UI
   if (effectiveAnthropicKey) sessionState.provider = 'Anthropic';
   else if (effectiveOpenAIKey) sessionState.provider = 'OpenAI';
+  else if (effectiveNvidiaKey) sessionState.provider = 'NVIDIA';
   else sessionState.provider = 'Grok (free)';
 
   // No personal key — use free tier
-  if (!effectiveAnthropicKey && !effectiveOpenAIKey) {
+  if (!effectiveAnthropicKey && !effectiveOpenAIKey && !effectiveNvidiaKey) {
     if (intent === 'code' && navada.config.hfToken) {
       try {
         const r = await navada.ai.huggingface.qwen(userMessage);
@@ -617,6 +689,21 @@ async function chat(userMessage, conversationHistory = []) {
     return grokChat(userMessage, conversationHistory);
   }
 
+  // NVIDIA key — route to NVIDIA
+  if (effectiveNvidiaKey && (!effectiveAnthropicKey || modelPref?.startsWith('nvidia') || modelPref?.startsWith('llama') || modelPref?.startsWith('deepseek') || modelPref?.startsWith('mistral') || modelPref?.startsWith('gemma') || modelPref?.startsWith('nemotron'))) {
+    const { streamNvidia } = require('./commands/nvidia');
+    const nvidiaModel = config.get('nvidiaModel') || 'llama-3.3-70b';
+    sessionState.provider = 'NVIDIA';
+    sessionState.model = nvidiaModel;
+    const messages = [
+      ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
+      { role: 'user', content: userMessage },
+    ];
+    process.stdout.write(ui.dim('  NAVADA > '));
+    const result = await streamNvidia(effectiveNvidiaKey, messages, nvidiaModel);
+    return result.content;
+  }
+
   // OpenAI key — route to OpenAI
   if (effectiveOpenAIKey && (!effectiveAnthropicKey || modelPref === 'gpt-4o' || modelPref === 'gpt-4o-mini')) {
     return openAIChat(effectiveOpenAIKey, userMessage, conversationHistory);
@@ -711,6 +798,16 @@ async function chat(userMessage, conversationHistory = []) {
       description: 'Run a Python script file.',
       input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Path to .py file' } }, required: ['path'] },
     },
+    {
+      name: 'sandbox_run',
+      description: 'Run code in an isolated sandbox with syntax highlighting. Supports javascript, python, typescript. Returns colored output.',
+      input_schema: { type: 'object', properties: { code: { type: 'string', description: 'Code to execute' }, language: { type: 'string', description: 'javascript, python, or typescript' } }, required: ['code'] },
+    },
+    {
+      name: 'founder_info',
+      description: 'Get information about Lee Akpareva, founder of NAVADA Edge Network. Use when asked about the creator, founder, Lee, or who made NAVADA.',
+      input_schema: { type: 'object', properties: {} },
+    },
   ];
 
   const messages = [
@@ -782,6 +879,14 @@ async function executeTool(name, input) {
       case 'python_exec': return localTools.pythonExec.execute(input.code);
       case 'python_pip': return localTools.pythonPip.execute(input.package);
       case 'python_script': return localTools.pythonScript.execute(input.path);
+      case 'sandbox_run': {
+        const { runCode, displayCode, displayOutput } = require('./commands/sandbox');
+        displayCode(input.code, input.language);
+        const result = runCode(input.code, input.language);
+        displayOutput(result);
+        return result.error ? `Error (exit ${result.exitCode}): ${result.error}` : result.output;
+      }
+      case 'founder_info': return localTools.founderInfo.execute();
       default: return `Unknown tool: ${name}`;
     }
   } catch (e) {
@@ -853,7 +958,6 @@ function getUpdateInfo() { return _updateInfo; }
 async function reportTelemetry(event, data = {}) {
   // Try dashboard first, then public tunnel
   const endpoints = [
-    'http://100.88.118.128:7900',
     'https://api.navada-edge-server.uk',
   ];
 
@@ -880,4 +984,4 @@ async function reportTelemetry(event, data = {}) {
   }
 }
 
-module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker, sessionState };
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker, sessionState, addToHistory, getConversationHistory, clearHistory };

package/lib/cli.js

@@ -10,6 +10,15 @@ const { execute, getCompletions } = require('./registry');
 const { loadAll } = require('./commands/index');
 const { reportTelemetry, checkForUpdate, getUpdateInfo, rateTracker } = require('./agent');
 
+// Global error safety — prevent unhandled crashes
+process.on('unhandledRejection', (err) => {
+  console.log(ui.error(`Unhandled error: ${err?.message || err}`));
+});
+process.on('uncaughtException', (err) => {
+  console.log(ui.error(`Fatal: ${err?.message || err}`));
+  process.exit(1);
+});
+
 function applyConfig() {
   const cfg = config.getAll();
   const overrides = {};

package/lib/commands/ai.js

@@ -3,13 +3,10 @@
 const navada = require('navada-edge-sdk');
 const ui = require('../ui');
 const config = require('../config');
-const { chat: agentChat, reportTelemetry, rateTracker } = require('../agent');
+const { chat: agentChat, reportTelemetry, rateTracker, addToHistory, getConversationHistory, clearHistory } = require('../agent');
 
 module.exports = function(reg) {
 
-  // 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('Just type naturally — no /command needed.')); return; }
@@ -17,24 +14,22 @@ module.exports = function(reg) {
     const hasKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
 
     // Show a brief "thinking" indicator, then clear it when streaming starts
+    let spinner;
     if (!hasKey) {
       process.stdout.write(ui.dim('  NAVADA > '));
     } else {
       const ora = require('ora');
-      var spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
+      spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
     }
 
     try {
-      const response = await agentChat(msg, conversationHistory);
+      const response = await agentChat(msg, getConversationHistory());
 
       if (spinner) spinner.stop();
 
       // 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);
+      addToHistory('user', msg);
+      addToHistory('assistant', response);
 
       // Only print if not already streamed
       if (!response._streamed) {
@@ -51,6 +46,14 @@ module.exports = function(reg) {
     }
   }, { category: 'AI', aliases: ['ask'] });
 
+  reg('clear', 'Clear conversation history and reset session', () => {
+    clearHistory();
+    console.clear();
+    const banner = require('../ui').banner;
+    console.log(banner());
+    console.log(ui.success('Conversation cleared — fresh session'));
+  }, { category: 'AI' });
+
   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; }
@@ -106,24 +109,36 @@ module.exports = function(reg) {
 
   reg('model', 'Show/set default AI model', (args) => {
     if (args[0]) {
-      const valid = ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'];
+      const valid = ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'nvidia', 'llama-3.3-70b', 'llama-3.1-8b', 'mistral-large', 'gemma-2-27b', 'codellama-70b', 'deepseek-r1', 'phi-3-medium', 'nemotron-70b'];
       if (!valid.includes(args[0])) { console.log(ui.error(`Invalid model. Options: ${valid.join(', ')}`)); return; }
       config.setModel(args[0]);
+      // If it's an NVIDIA model name, also set it as the nvidia model
+      const nvidiaModels = ['llama-3.3-70b', 'llama-3.1-8b', 'mistral-large', 'gemma-2-27b', 'codellama-70b', 'deepseek-r1', 'phi-3-medium', 'nemotron-70b'];
+      if (nvidiaModels.includes(args[0])) config.set('nvidiaModel', 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', '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('qwen', 'Qwen Coder 32B (FREE via HuggingFace)'));
+      console.log(ui.dim('Core providers:'));
+      console.log(ui.label('auto', 'Smart routing — picks best provider per query'));
+      console.log(ui.label('claude', 'Claude Sonnet 4 (Anthropic) — full agent + tools'));
+      console.log(ui.label('gpt-4o', 'GPT-4o (OpenAI) — tool use + streaming'));
+      console.log(ui.label('qwen', 'Qwen Coder 32B (HuggingFace — FREE)'));
+      console.log('');
+      console.log(ui.dim('NVIDIA models (FREE via build.nvidia.com):'));
+      console.log(ui.label('llama-3.3-70b', 'Meta Llama 3.3 70B'));
+      console.log(ui.label('deepseek-r1', 'DeepSeek R1'));
+      console.log(ui.label('mistral-large', 'Mistral Large 2'));
+      console.log(ui.label('codellama-70b', 'Code Llama 70B'));
+      console.log(ui.label('gemma-2-27b', 'Google Gemma 2 27B'));
+      console.log(ui.label('nemotron-70b', 'NVIDIA Nemotron 70B'));
       console.log('');
-      console.log(ui.dim('Set with: /model claude'));
+      console.log(ui.dim('Set: /model deepseek-r1'));
+      console.log(ui.dim('NVIDIA key: /login nvapi-your-key (free at build.nvidia.com)'));
     }
-  }, { category: 'AI', subs: ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'] });
+  }, { category: 'AI', subs: ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'nvidia', 'llama-3.3-70b', 'deepseek-r1', 'mistral-large', 'codellama-70b', 'gemma-2-27b', 'nemotron-70b'] });
 
   reg('research', 'RAG search via MCP', async (args) => {
     const query = args.join(' ');

package/lib/commands/index.js

@@ -3,26 +3,22 @@
 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'),
-  require('./learn'),
+const moduleNames = [
+  'network', 'mcp', 'lucas', 'docker', 'database', 'cloudflare',
+  'ai', 'azure', 'agents', 'tasks', 'keys', 'setup', 'system',
+  'learn', 'sandbox', 'nvidia',
 ];
 
 function loadAll() {
-  for (const mod of modules) {
-    mod(register);
+  for (const name of moduleNames) {
+    try {
+      const mod = require(`./${name}`);
+      mod(register);
+    } catch (e) {
+      // Don't crash the entire CLI if one module fails to load
+      const ui = require('../ui');
+      console.log(ui.warn(`Failed to load module: ${name} — ${e.message}`));
+    }
   }
 }
 

package/lib/commands/nvidia.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const https = require('https');
+const ui = require('../ui');
+const config = require('../config');
+
+// ---------------------------------------------------------------------------
+// NVIDIA API — free tier models via build.nvidia.com
+// ---------------------------------------------------------------------------
+const NVIDIA_MODELS = {
+  'llama-3.3-70b':  { id: 'meta/llama-3.3-70b-instruct', name: 'Llama 3.3 70B', free: true },
+  'llama-3.1-8b':   { id: 'meta/llama-3.1-8b-instruct', name: 'Llama 3.1 8B', free: true },
+  'mistral-large':  { id: 'mistralai/mistral-large-2-instruct', name: 'Mistral Large 2', free: true },
+  'gemma-2-27b':    { id: 'google/gemma-2-27b-it', name: 'Gemma 2 27B', free: true },
+  'codellama-70b':  { id: 'meta/codellama-70b-instruct', name: 'Code Llama 70B', free: true },
+  'deepseek-r1':    { id: 'deepseek-ai/deepseek-r1', name: 'DeepSeek R1', free: true },
+  'phi-3-medium':   { id: 'microsoft/phi-3-medium-128k-instruct', name: 'Phi 3 Medium 128K', free: true },
+  'nemotron-70b':   { id: 'nvidia/llama-3.1-nemotron-70b-instruct', name: 'Nemotron 70B', free: true },
+};
+
+const DEFAULT_NVIDIA_MODEL = 'llama-3.3-70b';
+
+// ---------------------------------------------------------------------------
+// NVIDIA API chat (streaming)
+// ---------------------------------------------------------------------------
+function streamNvidia(apiKey, messages, modelKey = DEFAULT_NVIDIA_MODEL) {
+  const modelInfo = NVIDIA_MODELS[modelKey] || NVIDIA_MODELS[DEFAULT_NVIDIA_MODEL];
+
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model: modelInfo.id,
+      messages: [
+        { role: 'system', content: 'You are NAVADA, an AI infrastructure agent. Keep responses concise and technical. Use code blocks with language tags when showing code.' },
+        ...messages,
+      ],
+      max_tokens: 4096,
+      stream: true,
+      temperature: 0.7,
+    });
+
+    const req = https.request('https://integrate.api.nvidia.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 120000,
+    }, (res) => {
+      if (res.statusCode !== 200) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          if (res.statusCode === 401) reject(new Error('Invalid NVIDIA API key. Get one free at https://build.nvidia.com'));
+          else if (res.statusCode === 429) reject(new Error('NVIDIA rate limit reached. Wait a moment and try again.'));
+          else reject(new Error(`NVIDIA API error ${res.statusCode}: ${data.slice(0, 200)}`));
+        });
+        return;
+      }
+
+      let buffer = '';
+      let fullContent = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') continue;
+          try {
+            const event = JSON.parse(data);
+            const delta = event.choices?.[0]?.delta?.content || '';
+            if (delta) {
+              process.stdout.write(delta);
+              fullContent += delta;
+            }
+          } catch {}
+        }
+      });
+
+      res.on('end', () => {
+        if (fullContent) process.stdout.write('\n');
+        resolve({ content: fullContent, model: modelInfo.name, streamed: true });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('NVIDIA API timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// Non-streaming fallback
+async function chatNvidia(apiKey, messages, modelKey = DEFAULT_NVIDIA_MODEL) {
+  const modelInfo = NVIDIA_MODELS[modelKey] || NVIDIA_MODELS[DEFAULT_NVIDIA_MODEL];
+
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model: modelInfo.id,
+      messages: [
+        { role: 'system', content: 'You are NAVADA, an AI infrastructure agent. Keep responses concise and technical. Use code blocks with language tags when showing code.' },
+        ...messages,
+      ],
+      max_tokens: 4096,
+      temperature: 0.7,
+    });
+
+    const req = https.request('https://integrate.api.nvidia.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 120000,
+    }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`NVIDIA API error ${res.statusCode}: ${data.slice(0, 200)}`));
+          return;
+        }
+        try {
+          const parsed = JSON.parse(data);
+          resolve({ content: parsed.choices?.[0]?.message?.content || '', model: modelInfo.name });
+        } catch (e) { reject(e); }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+module.exports = function(reg) {
+
+  reg('nvidia', 'NVIDIA AI models (free tier via build.nvidia.com)', async (args) => {
+    const sub = args[0];
+
+    if (!sub || sub === 'help') {
+      console.log(ui.header('NVIDIA AI'));
+      console.log(ui.dim('Free AI models via NVIDIA build.nvidia.com'));
+      console.log('');
+      console.log(ui.cmd('nvidia login <key>', 'Set your NVIDIA API key'));
+      console.log(ui.cmd('nvidia models', 'List available models'));
+      console.log(ui.cmd('nvidia model <name>', 'Set default NVIDIA model'));
+      console.log(ui.cmd('nvidia chat <msg>', 'Chat with NVIDIA model'));
+      console.log(ui.cmd('nvidia status', 'Check API connection'));
+      console.log('');
+      console.log(ui.dim('Get a free key: https://build.nvidia.com'));
+      console.log(ui.dim('Then: /nvidia login nvapi-xxxx'));
+      return;
+    }
+
+    if (sub === 'login') {
+      const key = args[1];
+      if (!key) { console.log(ui.error('Usage: /nvidia login nvapi-your-key-here')); return; }
+      if (!key.startsWith('nvapi-')) { console.log(ui.error('NVIDIA keys start with nvapi-')); return; }
+      config.set('nvidiaKey', key);
+      console.log(ui.success('NVIDIA API key saved'));
+      console.log(ui.dim('Test it: /nvidia status'));
+      return;
+    }
+
+    if (sub === 'models') {
+      console.log(ui.header('NVIDIA MODELS'));
+      const currentModel = config.get('nvidiaModel') || DEFAULT_NVIDIA_MODEL;
+      for (const [key, info] of Object.entries(NVIDIA_MODELS)) {
+        const active = key === currentModel ? ' ◄' : '';
+        console.log(ui.label(key.padEnd(18), `${info.name}${info.free ? '  (FREE)' : ''}${active}`));
+      }
+      console.log('');
+      console.log(ui.dim(`Current: ${currentModel}`));
+      console.log(ui.dim('Set: /nvidia model deepseek-r1'));
+      return;
+    }
+
+    if (sub === 'model') {
+      const model = args[1];
+      if (!model) { console.log(ui.error('Usage: /nvidia model llama-3.3-70b')); return; }
+      if (!NVIDIA_MODELS[model]) {
+        console.log(ui.error(`Unknown model: ${model}`));
+        console.log(ui.dim(`Available: ${Object.keys(NVIDIA_MODELS).join(', ')}`));
+        return;
+      }
+      config.set('nvidiaModel', model);
+      console.log(ui.success(`NVIDIA model set to: ${NVIDIA_MODELS[model].name}`));
+      return;
+    }
+
+    if (sub === 'status') {
+      const key = config.get('nvidiaKey');
+      if (!key) { console.log(ui.error('No NVIDIA key set. /nvidia login nvapi-your-key')); return; }
+      console.log(ui.dim('Testing NVIDIA API...'));
+      try {
+        const result = await chatNvidia(key, [{ role: 'user', content: 'Say "NVIDIA connected" in exactly 2 words.' }]);
+        console.log(ui.success(`NVIDIA API connected — ${result.model}`));
+        console.log(ui.dim(`Response: ${result.content}`));
+      } catch (e) {
+        console.log(ui.error(e.message));
+      }
+      return;
+    }
+
+    if (sub === 'chat') {
+      const key = config.get('nvidiaKey');
+      if (!key) { console.log(ui.error('No NVIDIA key set. /nvidia login nvapi-your-key')); return; }
+      const msg = args.slice(1).join(' ');
+      if (!msg) { console.log(ui.dim('Usage: /nvidia chat explain Docker networking')); return; }
+
+      const model = config.get('nvidiaModel') || DEFAULT_NVIDIA_MODEL;
+      process.stdout.write(ui.dim(`  NAVADA [${NVIDIA_MODELS[model].name}] > `));
+      try {
+        await streamNvidia(key, [{ role: 'user', content: msg }], model);
+      } catch (e) {
+        console.log(ui.error(e.message));
+      }
+      return;
+    }
+
+    console.log(ui.dim('Unknown subcommand. Try /nvidia help'));
+
+  }, { category: 'AI', aliases: ['nv'], subs: ['login', 'models', 'model', 'chat', 'status', 'help'] });
+
+};
+
+// Export for agent integration
+module.exports.streamNvidia = streamNvidia;
+module.exports.chatNvidia = chatNvidia;
+module.exports.NVIDIA_MODELS = NVIDIA_MODELS;
+module.exports.DEFAULT_NVIDIA_MODEL = DEFAULT_NVIDIA_MODEL;

package/lib/commands/sandbox.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const ui = require('../ui');
+const config = require('../config');
+
+// ---------------------------------------------------------------------------
+// Syntax highlighter — colorizes code output for the terminal
+// ---------------------------------------------------------------------------
+const LANG_KEYWORDS = {
+  javascript: /\b(const|let|var|function|return|if|else|for|while|class|import|export|from|async|await|new|this|typeof|instanceof|try|catch|throw|switch|case|break|continue|default|yield|delete|in|of|do|void|with)\b/g,
+  python: /\b(def|class|return|if|elif|else|for|while|import|from|as|try|except|finally|raise|with|yield|lambda|pass|break|continue|not|and|or|is|in|True|False|None|self|print|async|await|nonlocal|global|assert|del)\b/g,
+  typescript: /\b(const|let|var|function|return|if|else|for|while|class|import|export|from|async|await|new|this|typeof|instanceof|try|catch|throw|switch|case|break|continue|default|yield|interface|type|enum|implements|extends|abstract|readonly|private|public|protected|static|override|declare|namespace|module|keyof|infer)\b/g,
+  csharp: /\b(using|namespace|class|public|private|protected|static|void|int|string|bool|float|double|var|new|return|if|else|for|foreach|while|try|catch|throw|switch|case|break|continue|async|await|override|virtual|abstract|interface|struct|enum|null|true|false|this|base|readonly|const|ref|out|in|params|yield|delegate|event|lock|checked|unchecked|fixed|sizeof|typeof|is|as|where|select|from|orderby|group|join|let|into)\b/g,
+  go: /\b(func|return|if|else|for|range|switch|case|break|continue|var|const|type|struct|interface|map|chan|select|defer|go|import|package|fallthrough|default|nil|true|false|make|len|cap|append|copy|delete|new|panic|recover|close|iota)\b/g,
+  rust: /\b(fn|let|mut|return|if|else|for|while|loop|match|struct|enum|impl|trait|pub|use|mod|crate|self|super|async|await|move|ref|where|type|const|static|unsafe|extern|dyn|macro_rules|as|in|break|continue|true|false|None|Some|Ok|Err|Box|Vec|String|Option|Result)\b/g,
+};
+
+const STRING_RE = /(["'`])(?:(?!\1|\\).|\\.)*?\1/g;
+const NUMBER_RE = /\b(\d+\.?\d*(?:e[+-]?\d+)?)\b/gi;
+const COMMENT_LINE_RE = /(\/\/.*$|#(?!!).*$)/gm;
+const COMMENT_BLOCK_RE = /(\/\*[\s\S]*?\*\/)/g;
+const FUNC_CALL_RE = /\b([a-zA-Z_]\w*)\s*\(/g;
+const DECORATOR_RE = /(@\w+)/g;
+
+function highlight(code, lang = 'javascript') {
+  const langKey = lang.toLowerCase().replace(/^(js|node)$/, 'javascript').replace(/^(ts)$/, 'typescript').replace(/^(py)$/, 'python').replace(/^(cs)$/, 'csharp').replace(/^(rs)$/, 'rust');
+
+  // Placeholder system to avoid double-coloring
+  const placeholders = [];
+  const ph = (styled) => { placeholders.push(styled); return `\x00PH${placeholders.length - 1}\x00`; };
+
+  let result = code;
+
+  // 1. Comments first (highest priority)
+  result = result.replace(COMMENT_BLOCK_RE, (m) => ph(chalk.gray.italic(m)));
+  result = result.replace(COMMENT_LINE_RE, (m) => ph(chalk.gray.italic(m)));
+
+  // 2. Strings
+  result = result.replace(STRING_RE, (m) => ph(chalk.green(m)));
+
+  // 3. Decorators
+  result = result.replace(DECORATOR_RE, (m) => ph(chalk.yellow(m)));
+
+  // 4. Function calls
+  result = result.replace(FUNC_CALL_RE, (m, name) => ph(chalk.yellow(name)) + '(');
+
+  // 5. Numbers
+  result = result.replace(NUMBER_RE, (m) => ph(chalk.magenta(m)));
+
+  // 6. Keywords
+  const keywordRe = LANG_KEYWORDS[langKey] || LANG_KEYWORDS.javascript;
+  result = result.replace(keywordRe, (m) => ph(chalk.cyan.bold(m)));
+
+  // Restore placeholders
+  result = result.replace(/\x00PH(\d+)\x00/g, (_, i) => placeholders[parseInt(i)]);
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Sandbox — isolated code execution with colored output
+// ---------------------------------------------------------------------------
+const SANDBOX_DIR = path.join(os.tmpdir(), 'navada-sandbox');
+
+function ensureSandbox() {
+  if (!fs.existsSync(SANDBOX_DIR)) fs.mkdirSync(SANDBOX_DIR, { recursive: true });
+}
+
+function detectLang(code, lang) {
+  if (lang) return lang.toLowerCase();
+  if (/\bdef\s+\w+|import\s+\w+|print\s*\(/.test(code)) return 'python';
+  if (/\bfunc\s+\w+|package\s+\w+|fmt\./.test(code)) return 'go';
+  if (/\bfn\s+\w+|let\s+mut\b|use\s+std/.test(code)) return 'rust';
+  if (/\busing\s+System|namespace\s+|Console\./.test(code)) return 'csharp';
+  return 'javascript';
+}
+
+function runCode(code, lang) {
+  ensureSandbox();
+  const detected = detectLang(code, lang);
+
+  let file, cmd;
+  switch (detected) {
+    case 'python':
+    case 'py':
+      file = path.join(SANDBOX_DIR, `run_${Date.now()}.py`);
+      fs.writeFileSync(file, code);
+      cmd = `${process.platform === 'win32' ? 'python' : 'python3'} "${file}"`;
+      break;
+
+    case 'javascript':
+    case 'js':
+    case 'node':
+      file = path.join(SANDBOX_DIR, `run_${Date.now()}.js`);
+      fs.writeFileSync(file, code);
+      cmd = `node "${file}"`;
+      break;
+
+    case 'typescript':
+    case 'ts':
+      file = path.join(SANDBOX_DIR, `run_${Date.now()}.ts`);
+      fs.writeFileSync(file, code);
+      cmd = `npx tsx "${file}" 2>/dev/null || npx ts-node "${file}"`;
+      break;
+
+    default:
+      return { lang: detected, error: `Language "${detected}" not supported for execution. Supported: javascript, python, typescript` };
+  }
+
+  try {
+    const output = execSync(cmd, {
+      timeout: 30000,
+      encoding: 'utf-8',
+      cwd: SANDBOX_DIR,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, NODE_NO_WARNINGS: '1' },
+    });
+    // Clean up
+    try { fs.unlinkSync(file); } catch {}
+    return { lang: detected, output: output.trim(), exitCode: 0 };
+  } catch (e) {
+    try { fs.unlinkSync(file); } catch {}
+    return { lang: detected, output: (e.stdout || '').trim(), error: (e.stderr || e.message || '').trim(), exitCode: e.status || 1 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Display — code + output with colors
+// ---------------------------------------------------------------------------
+function displayCode(code, lang) {
+  const detected = detectLang(code, lang);
+  const lines = code.split('\n');
+  const gutterWidth = String(lines.length).length;
+
+  console.log('');
+  console.log(ui.dim(`─── ${detected.toUpperCase()} ${'─'.repeat(40)}`));
+  console.log('');
+
+  lines.forEach((line, i) => {
+    const num = chalk.gray(String(i + 1).padStart(gutterWidth) + ' │ ');
+    const colored = highlight(line, detected);
+    console.log('  ' + num + colored);
+  });
+
+  console.log('');
+}
+
+function displayOutput(result) {
+  if (result.error && !result.output) {
+    console.log(ui.dim('─── ERROR ' + '─'.repeat(38)));
+    console.log('');
+    result.error.split('\n').forEach(line => {
+      console.log('  ' + chalk.red(line));
+    });
+  } else {
+    console.log(ui.dim('─── OUTPUT ' + '─'.repeat(37)));
+    console.log('');
+    if (result.output) {
+      result.output.split('\n').forEach(line => {
+        console.log('  ' + chalk.white(line));
+      });
+    }
+    if (result.error) {
+      console.log('');
+      console.log(ui.dim('─── STDERR ' + '─'.repeat(37)));
+      result.error.split('\n').forEach(line => {
+        console.log('  ' + chalk.yellow(line));
+      });
+    }
+  }
+  console.log('');
+  const status = result.exitCode === 0 ? chalk.green('✓ exit 0') : chalk.red(`✗ exit ${result.exitCode}`);
+  console.log('  ' + status);
+  console.log('');
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+module.exports = function(reg) {
+
+  reg('sandbox', 'Run code in a sandbox with syntax highlighting', async (args) => {
+    if (!args.length) {
+      console.log(ui.header('CODING SANDBOX'));
+      console.log(ui.dim('Run code with syntax-highlighted output'));
+      console.log('');
+      console.log(ui.cmd('sandbox run <lang>', 'Enter code to run (opens multi-line input)'));
+      console.log(ui.cmd('sandbox exec <file>', 'Run a file in the sandbox'));
+      console.log(ui.cmd('sandbox highlight <file>', 'Syntax-highlight a file (no execution)'));
+      console.log(ui.cmd('sandbox demo', 'Run a demo to test colors'));
+      console.log('');
+      console.log(ui.dim('Languages: javascript, python, typescript'));
+      console.log(ui.dim('Shorthand: /run <code>  — quick-run a one-liner'));
+      return;
+    }
+
+    const sub = args[0];
+
+    if (sub === 'demo') {
+      // Demo all language highlighting
+      const demos = {
+        javascript: `const greet = (name) => {
+  // Welcome message
+  const time = new Date().getHours();
+  if (time < 12) return \`Good morning, \${name}!\`;
+  return \`Hello, \${name}!\`;
+};
+
+console.log(greet("NAVADA"));
+console.log("Version:", 3.02);`,
+
+        python: `def fibonacci(n):
+    """Generate fibonacci sequence"""
+    a, b = 0, 1
+    result = []
+    for _ in range(n):
+        result.append(a)
+        a, b = b, a + b
+    return result
+
+# Print first 10 numbers
+print(fibonacci(10))
+print(f"Sum: {sum(fibonacci(10))}")`,
+      };
+
+      for (const [lang, code] of Object.entries(demos)) {
+        displayCode(code, lang);
+        const result = runCode(code, lang);
+        displayOutput(result);
+      }
+      return;
+    }
+
+    if (sub === 'highlight' && args[1]) {
+      const filePath = path.resolve(args.slice(1).join(' '));
+      if (!fs.existsSync(filePath)) { console.log(ui.error(`File not found: ${filePath}`)); return; }
+      const code = fs.readFileSync(filePath, 'utf-8');
+      const ext = path.extname(filePath).slice(1);
+      displayCode(code, ext);
+      return;
+    }
+
+    if (sub === 'exec' && args[1]) {
+      const filePath = path.resolve(args.slice(1).join(' '));
+      if (!fs.existsSync(filePath)) { console.log(ui.error(`File not found: ${filePath}`)); return; }
+      const code = fs.readFileSync(filePath, 'utf-8');
+      const ext = path.extname(filePath).slice(1);
+      displayCode(code, ext);
+      const result = runCode(code, ext);
+      displayOutput(result);
+      return;
+    }
+
+    if (sub === 'run') {
+      const lang = args[1] || 'javascript';
+      console.log(ui.dim(`Enter ${lang} code (type END on a new line to execute):`));
+      console.log('');
+
+      // Collect multi-line input
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: chalk.gray('  > ') });
+      const lines = [];
+
+      return new Promise((resolve) => {
+        rl.prompt();
+        rl.on('line', (line) => {
+          if (line.trim() === 'END') {
+            rl.close();
+            const code = lines.join('\n');
+            displayCode(code, lang);
+            const result = runCode(code, lang);
+            displayOutput(result);
+            resolve();
+          } else {
+            lines.push(line);
+            rl.prompt();
+          }
+        });
+      });
+    }
+
+    // Quick run — rest of args is code
+    const code = args.join(' ');
+    const lang = detectLang(code);
+    displayCode(code, lang);
+    const result = runCode(code, lang);
+    displayOutput(result);
+
+  }, { category: 'CODE', aliases: ['sb'], subs: ['run', 'exec', 'highlight', 'demo'] });
+
+  // Quick run shortcut
+  reg('run', 'Quick-run code in the sandbox', async (args) => {
+    if (!args.length) { console.log(ui.dim('Usage: /run console.log("hello")  or  /run py print("hello")')); return; }
+
+    // Check for language prefix
+    const langShorts = { js: 'javascript', py: 'python', ts: 'typescript', node: 'javascript' };
+    let lang = null;
+    let code = args.join(' ');
+
+    if (langShorts[args[0]]) {
+      lang = langShorts[args[0]];
+      code = args.slice(1).join(' ');
+    }
+
+    const detected = detectLang(code, lang);
+    displayCode(code, detected);
+    const result = runCode(code, detected);
+    displayOutput(result);
+
+  }, { category: 'CODE' });
+
+};
+
+// Export for agent tool use
+module.exports.highlight = highlight;
+module.exports.runCode = runCode;
+module.exports.displayCode = displayCode;
+module.exports.displayOutput = displayOutput;

package/lib/commands/system.js

@@ -65,10 +65,15 @@ module.exports = function(reg) {
   }, { category: 'SYSTEM' });
 
   // --- /login ---
-  reg('login', 'Set API key (Anthropic, OpenAI, NAVADA Edge, or HuggingFace)', (args) => {
+  reg('login', 'Set API key (Anthropic, OpenAI, NVIDIA, 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)'));
+      console.log(ui.dim('Accepts:'));
+      console.log(ui.dim('  sk-ant-...   Anthropic (full agent + tool use)'));
+      console.log(ui.dim('  sk-...       OpenAI (GPT-4o)'));
+      console.log(ui.dim('  nvapi-...    NVIDIA (Llama, Mistral, DeepSeek — FREE)'));
+      console.log(ui.dim('  nv_edge_...  NAVADA Edge (MCP + Dashboard)'));
+      console.log(ui.dim('  hf_...       HuggingFace (Qwen Coder — FREE)'));
       return;
     }
     const key = args[0].trim();
@@ -77,6 +82,10 @@ module.exports = function(reg) {
     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('nvapi-')) {
+      config.set('nvidiaKey', key);
+      console.log(ui.success('NVIDIA key saved — Llama, Mistral, DeepSeek, Gemma enabled'));
+      console.log(ui.dim('/nvidia models to see all available models'));
     } else if (key.startsWith('hf_')) {
       config.set('hfToken', key);
       navada.init({ hfToken: key });

package/lib/config.js

@@ -15,13 +15,28 @@ function ensureDir() {
 function load() {
   try {
     if (!fs.existsSync(CONFIG_FILE)) return {};
-    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
-  } catch { return {}; }
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  } catch (e) {
+    // Back up corrupted config
+    try {
+      const backupPath = CONFIG_FILE + '.bak';
+      if (fs.existsSync(CONFIG_FILE)) fs.copyFileSync(CONFIG_FILE, backupPath);
+    } catch {}
+    return {};
+  }
 }
 
 function save(config) {
   ensureDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  const data = JSON.stringify(config, null, 2);
+  // Write atomically via temp file
+  const tmpFile = CONFIG_FILE + '.tmp';
+  fs.writeFileSync(tmpFile, data);
+  fs.renameSync(tmpFile, CONFIG_FILE);
+  // Restrict permissions on config file (contains API keys)
+  try { fs.chmodSync(CONFIG_FILE, 0o600); } catch {}
 }
 
 function isFirstRun() { return !fs.existsSync(CONFIG_FILE); }

package/lib/serve.js

@@ -9,8 +9,10 @@ function start(port = 7800) {
   const server = http.createServer(async (req, res) => {
     const url = req.url.split('?')[0];
 
-    // CORS
-    res.setHeader('Access-Control-Allow-Origin', '*');
+    // CORS — restrict to local/Tailscale origins
+    const origin = req.headers.origin || '';
+    const allowedOrigin = (origin.includes('localhost') || origin.includes('127.0.0.1') || origin.includes('100.')) ? origin : '';
+    res.setHeader('Access-Control-Allow-Origin', allowedOrigin || `http://localhost:${port}`);
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
     if (req.method === 'OPTIONS') { res.writeHead(204); return res.end(); }
@@ -24,25 +26,36 @@ function start(port = 7800) {
     // Execute command
     if (url === '/api/cmd' && req.method === 'POST') {
       let body = '';
-      req.on('data', c => body += c);
+      let bodySize = 0;
+      const MAX_BODY = 8192;
+      req.on('data', c => {
+        bodySize += c.length;
+        if (bodySize > MAX_BODY) { req.destroy(); return; }
+        body += c;
+      });
       req.on('end', async () => {
         try {
+          if (bodySize > MAX_BODY) { res.writeHead(413); return res.end(JSON.stringify({ error: 'Request too large' })); }
           const { command } = JSON.parse(body);
-          if (!command) { res.writeHead(400); return res.end(JSON.stringify({ error: 'command required' })); }
+          if (!command || typeof command !== 'string') { res.writeHead(400); return res.end(JSON.stringify({ error: 'command required (string)' })); }
+          if (command.length > 2000) { res.writeHead(400); return res.end(JSON.stringify({ error: 'command too long' })); }
 
           // Capture output
           const orig = console.log;
           const buf = [];
           console.log = (...args) => buf.push(args.join(' '));
-          await execute(command);
-          console.log = orig;
+          try {
+            await execute(command);
+          } finally {
+            console.log = orig;
+          }
 
           const output = buf.join('\n').replace(/\x1b\[[0-9;]*m/g, ''); // strip ANSI
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ command, output }));
         } catch (e) {
           res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: e.message }));
+          res.end(JSON.stringify({ error: 'Internal server error' }));
         }
       });
       return;

package/lib/ui.js

@@ -90,8 +90,9 @@ function sessionPanel(width) {
     kvLine(' Model:   ', model),
     kvLine(' Tier:    ', tier),
     '',
-    sectionLine('Token Usage'),
-    kvLine(' Total:   ', String(state.tokens?.total || 0)),
+    sectionLine('Usage'),
+    kvLine(' Messages:', String(state.messages || 0)),
+    kvLine(' Tokens:  ', String(state.tokens?.total || 0)),
     kvLine(' Cost:    ', `$${(state.cost || 0).toFixed(4)}`),
     '',
     sectionLine('Configuration'),
@@ -114,15 +115,18 @@ function sessionPanel(width) {
   return lines;
 }
 
+let _pythonCache = null;
 function detectPython() {
+  if (_pythonCache !== null) return _pythonCache;
   try {
     const { execSync } = require('child_process');
     const py = process.platform === 'win32' ? 'python' : 'python3';
     const ver = execSync(`${py} --version`, { timeout: 3000, encoding: 'utf-8' }).trim();
-    return style('success', ver.replace('Python ', ''));
+    _pythonCache = style('success', ver.replace('Python ', ''));
   } catch {
-    return style('offline', 'not found');
+    _pythonCache = style('offline', 'not found');
   }
+  return _pythonCache;
 }
 
 function footerBar(width) {
@@ -178,7 +182,9 @@ function prompt() {
   try { state = require('./agent').sessionState; } catch { state = {}; }
   const mode = state?.learningMode;
   const modeTag = mode ? style('accent', `[${mode}]`) + ' ' : '';
-  return modeTag + style('dim', 'navada') + style('accent', '> ');
+  const msgCount = state?.messages || 0;
+  const countTag = msgCount > 0 ? style('dim', `(${msgCount}) `) : '';
+  return modeTag + countTag + style('dim', 'navada') + style('accent', '> ');
 }
 
 function box(title, content) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navada-edge-cli",
-  "version": "3.0.2",
+  "version": "3.2.0",
   "description": "Interactive CLI for the NAVADA Edge Network — explore nodes, agents, Cloudflare, AI, Docker, and MCP from your terminal",
   "main": "lib/cli.js",
   "bin": {
@@ -41,14 +41,14 @@
     "url": "git+https://github.com/Navada25/edge-sdk.git"
   },
   "dependencies": {
-    "navada-edge-sdk": "^1.1.0",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.5",
+    "navada-edge-sdk": "^1.1.0",
     "ora": "^5.4.1"
   },
   "optionalDependencies": {
-    "qrcode-terminal": "^0.12.0",
-    "nodemailer": "^6.9.0"
+    "nodemailer": "^8.0.4",
+    "qrcode-terminal": "^0.12.0"
   },
   "publishConfig": {
     "access": "public"