npm-noxyai 1.0.16 → 1.0.19

package/index-noxyai.js

@@ -3,22 +3,82 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const readline = require('readline');
+const crypto = require('crypto');
 
 const BASE_URL = 'https://www.noxyai.com'; 
 const CONFIG_FILE = path.join(os.homedir(), '.noxyai.json');
+const SESSION_FILE = path.join(os.homedir(), '.noxyai_session.json');
+const CACHE_DIR = path.join(os.homedir(), '.noxyai_cache');
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+// Ensure cache directory exists
+if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
 
 const args = process.argv.slice(2);
 const command = args[0];
 
+// Rate limiting store (in-memory, resets on CLI restart)
+const rateLimitStore = new Map();
+
 function loadConfig() {
   if (fs.existsSync(CONFIG_FILE)) {
-    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch(e){}
+    try { 
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      // Decrypt token if it was encrypted
+      if (config.token && config.token.startsWith('enc:')) {
+        config.token = decryptToken(config.token.substring(4));
+      }
+      return config;
+    } catch(e) { 
+      console.error('Config corruption detected, resetting...');
+      return { token: null, model: 'auto', agentMode: false, autoApprove: false, safeMode: true };
+    }
+  }
+  return { token: null, model: 'auto', agentMode: false, autoApprove: false, safeMode: true };
+}
+
+function saveConfig(config) { 
+  // Encrypt token for security
+  const configToSave = { ...config };
+  if (configToSave.token && !configToSave.token.startsWith('enc:')) {
+    configToSave.token = 'enc:' + encryptToken(configToSave.token);
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(configToSave, null, 2)); 
+}
+
+// Simple token encryption using machine-specific key
+function getMachineKey() {
+  const networkInterfaces = os.networkInterfaces();
+  const mac = Object.values(networkInterfaces)
+    .flat()
+    .find(i => !i.internal && i.mac !== '00:00:00:00:00:00')?.mac || os.hostname();
+  return crypto.createHash('sha256').update(mac + os.userInfo().username).digest('hex');
+}
+
+function encryptToken(token) {
+  const key = getMachineKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+  let encrypted = cipher.update(token, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return iv.toString('hex') + ':' + encrypted;
+}
+
+function decryptToken(encryptedData) {
+  try {
+    const key = getMachineKey();
+    const [ivHex, encrypted] = encryptedData.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  } catch (e) {
+    return null;
   }
-  return { token: null, model: 'auto', agentMode: false };
 }
-function saveConfig(config) { fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2)); }
 
 function printLogo() {
   console.log('\x1b[36m' + `
@@ -46,232 +106,696 @@ function stopSpinner() {
   process.stdout.write('\r\x1b[K\x1b[?25h');
 }
 
+// Enhanced login with device flow
 async function login() {
   printLogo();
-  console.log('Initializing secure login...\n');
+  console.log('\x1b[33m🔐 Initializing secure device login...\x1b[0m\n');
   try {
-    const initRes = await fetch(BASE_URL + '/api/cli/init', { method: 'POST' });
-    const { deviceCode, verificationUrl, interval } = await initRes.json();
-    console.log(`URL: ${verificationUrl}\n`);
+    const initRes = await fetch(BASE_URL + '/api/cli/init', { 
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' }
+    });
+    
+    if (!initRes.ok) throw new Error(`Server error: ${initRes.status}`);
+    
+    const { deviceCode, verificationUrl, userCode, expiresIn, interval } = await initRes.json();
+    
+    console.log(`\x1b[32m📱 Verification Code:\x1b[0m \x1b[33m${userCode}\x1b[0m`);
+    console.log(`\x1b[34m🌐 Login URL:\x1b[0m ${verificationUrl}`);
+    console.log(`\n\x1b[90mThis code expires in ${Math.floor(expiresIn / 60)} minutes.\x1b[0m\n`);
     
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question('Press ENTER to automatically open the browser...', () => {
+    // Try to copy code to clipboard
+    try {
+      const platform = os.platform();
+      if (platform === 'darwin') execSync(`echo "${userCode}" | pbcopy`);
+      else if (platform === 'win32') execSync(`echo ${userCode} | clip`);
+      else if (platform === 'linux' && execSync('which xclip').toString()) 
+        execSync(`echo "${userCode}" | xclip -selection clipboard`);
+      console.log('\x1b[32m✓ Code copied to clipboard!\x1b[0m');
+    } catch (e) {}
+    
+    rl.question('\x1b[36mPress ENTER to open browser or type "q" to cancel:\x1b[0m ', (answer) => {
+      if (answer.toLowerCase() === 'q') {
+        console.log('\x1b[31mLogin cancelled.\x1b[0m');
+        process.exit(0);
+      }
+      
       const platform = os.platform();
       if (platform === 'android') spawn('termux-open-url', [verificationUrl], { stdio: 'ignore' });
+      else if (platform === 'darwin') spawn('open', [verificationUrl], { stdio: 'ignore' });
+      else if (platform === 'win32') spawn('start', [verificationUrl], { shell: true, stdio: 'ignore' });
       else spawn('xdg-open', [verificationUrl], { stdio: 'ignore' });
-      rl.close();
+      
       startSpinner('Waiting for authentication...');
     });
 
+    const startTime = Date.now();
+    const maxTime = expiresIn * 1000;
     const pollInterval = setInterval(async () => {
-      const pollRes = await fetch(BASE_URL + '/api/cli/poll', { method: 'POST', body: JSON.stringify({ deviceCode }) });
-      const data = await pollRes.json();
-      if (data.status === 'success') {
-        clearInterval(pollInterval); stopSpinner();
-        const config = loadConfig(); config.token = data.token; saveConfig(config);
-        console.clear(); printLogo();
-        console.log('✅ Login successful! Type "noxyai" to start.\n'); process.exit(0);
-      } else if (data.error) {
-        clearInterval(pollInterval); stopSpinner();
-        console.error('\n❌ Login failed: ' + data.error); process.exit(1);
+      if (Date.now() - startTime > maxTime) {
+        clearInterval(pollInterval); 
+        stopSpinner();
+        console.log('\x1b[31m❌ Login timeout. Please try again.\x1b[0m');
+        process.exit(1);
+      }
+      
+      try {
+        const pollRes = await fetch(BASE_URL + '/api/cli/poll', { 
+          method: 'POST', 
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ deviceCode }) 
+        });
+        
+        const data = await pollRes.json();
+        
+        if (data.status === 'success') {
+          clearInterval(pollInterval); 
+          stopSpinner();
+          const config = loadConfig(); 
+          config.token = data.token; 
+          config.userEmail = data.email;
+          config.userId = data.userId;
+          saveConfig(config);
+          console.clear(); 
+          printLogo();
+          console.log(`\x1b[32m✅ Successfully logged in as ${data.email}!\x1b[0m\n`);
+          console.log(`\x1b[90mType 'noxyai' to start the interactive shell.\x1b[0m\n`);
+          process.exit(0);
+        } else if (data.status === 'pending') {
+          // Still waiting
+        } else if (data.error) {
+          clearInterval(pollInterval); 
+          stopSpinner();
+          console.error(`\n\x1b[31m❌ Login failed: ${data.error}\x1b[0m`); 
+          process.exit(1);
+        }
+      } catch (error) {
+        // Network errors shouldn't break the polling
       }
-    }, interval * 1000);
-  } catch (error) { console.error('Failed to connect.', error.message); }
+    }, (interval || 5) * 1000);
+  } catch (error) { 
+    stopSpinner();
+    console.error('\x1b[31m❌ Failed to connect:', error.message, '\x1b[0m'); 
+    process.exit(1);
+  }
 }
 
-function runTerminalCommand(cmd) {
+const askConfirm = (query) => new Promise(resolve => rl.question(query, resolve));
+
+function runTerminalCommand(cmd, options = {}) {
   return new Promise((resolve, reject) => {
-    console.log(`\n\x1b[33m⚡ Running:\x1b[0m ${cmd}\n`);
-    const isServer = cmd.includes('dev') || cmd.includes('serve') || cmd.includes('host') || cmd.includes('start');
-    const child = spawn(cmd, { shell: true, stdio: 'inherit' });
-    if (isServer) {
+    const { silent = false, background = false } = options;
+    
+    if (!silent) {
+      console.log(`\n\x1b[33m⚡ Executing:\x1b[0m \x1b[36m${cmd}\x1b[0m\n`);
+    }
+    
+    const isServer = cmd.includes('dev') || cmd.includes('serve') || 
+                     cmd.includes('host') || cmd.includes('start') || 
+                     cmd.includes('watch');
+    
+    const child = spawn(cmd, { 
+      shell: true, 
+      stdio: silent ? 'pipe' : 'inherit',
+      detached: background
+    });
+    
+    if (background) {
+      child.unref();
+      resolve({ pid: child.pid, background: true });
+      return;
+    }
+    
+    if (isServer && !silent) {
       console.log(`\x1b[36m[i] Server detected. Running in foreground. Press Ctrl+C to stop.\x1b[0m`);
-      setTimeout(() => resolve(), 2500); 
+      setTimeout(() => resolve({ server: true }), 2500); 
+    }
+    
+    let stdout = '', stderr = '';
+    if (silent) {
+      child.stdout?.on('data', (data) => stdout += data.toString());
+      child.stderr?.on('data', (data) => stderr += data.toString());
     }
-    child.on('close', (code) => { if (!isServer) { if (code !== 0) reject(`Exit code ${code}`); else resolve(); } });
-    child.on('error', (error) => reject(error.message));
+    
+    child.on('close', (code) => { 
+      if (!isServer || silent) { 
+        if (code !== 0) reject(new Error(stderr || `Exit code ${code}`)); 
+        else resolve({ code, stdout, stderr }); 
+      } 
+    });
+    
+    child.on('error', (error) => reject(error));
   });
 }
 
+// Enhanced context gathering
 function getLocalContext() {
   try {
-    const files = fs.readdirSync(process.cwd()).filter(f => !f.startsWith('node_modules') && !f.startsWith('.git')).slice(0, 30);
-    return `\n[SYSTEM CONTEXT: You are in ${process.cwd()}. Files here: ${files.join(', ')}]\n`;
-  } catch (e) { return ""; }
+    const cwd = process.cwd();
+    const files = fs.readdirSync(cwd)
+      .filter(f => !f.startsWith('.') && f !== 'node_modules' && f !== '__pycache__')
+      .slice(0, 50);
+    
+    const packageJson = files.includes('package.json') 
+      ? JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'))
+      : null;
+    
+    const gitBranch = (() => {
+      try {
+        return execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+      } catch (e) { return null; }
+    })();
+    
+    return `\n[SYSTEM CONTEXT]
+Directory: ${cwd}
+Files: ${files.join(', ')}
+${packageJson ? `Project: ${packageJson.name || 'unnamed'} v${packageJson.version || '0.0.0'}` : ''}
+${gitBranch ? `Git Branch: ${gitBranch}` : ''}
+OS: ${os.platform()} ${os.release()}
+Shell: ${process.env.SHELL || 'unknown'}
+[/SYSTEM CONTEXT]\n`;
+  } catch (e) { 
+    return `\n[SYSTEM CONTEXT] Directory: ${process.cwd()}\n[/SYSTEM CONTEXT]\n`; 
+  }
+}
+
+// Cache management for search results
+function getCachedSearch(query) {
+  const cacheFile = path.join(CACHE_DIR, `search_${crypto.createHash('md5').update(query).digest('hex')}.json`);
+  if (fs.existsSync(cacheFile)) {
+    const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+    if (Date.now() - cache.timestamp < 3600000) { // 1 hour cache
+      return cache.results;
+    }
+  }
+  return null;
+}
+
+function cacheSearchResults(query, results) {
+  const cacheFile = path.join(CACHE_DIR, `search_${crypto.createHash('md5').update(query).digest('hex')}.json`);
+  fs.writeFileSync(cacheFile, JSON.stringify({
+    timestamp: Date.now(),
+    query,
+    results
+  }));
 }
 
 async function chat(prompt, depth = 0) {
   const config = loadConfig();
-  if (!config.token) { console.error('❌ Unauthorized: Run "noxyai login"'); return; }
-  if (depth > 5) { console.error('\n❌ Reached max reasoning depth. Stopping to prevent loop.'); return; }
+  if (!config.token) { 
+    console.error('\x1b[31m❌ Unauthorized: Run "noxyai login" first\x1b[0m'); 
+    return; 
+  }
+  
+  if (depth > 8) { 
+    console.error('\n\x1b[31m❌ Maximum recursion depth reached. Breaking loop.\x1b[0m'); 
+    return; 
+  }
 
-  const enhancedPrompt = (depth === 0 && config.agentMode) ? getLocalContext() + prompt : prompt;
-  startSpinner(depth === 0 ? 'NoxyAI is thinking...' : 'NoxyAI is analyzing results...');
+  const enhancedPrompt = (depth === 0 && config.agentMode) 
+    ? getLocalContext() + prompt 
+    : prompt;
+    
+  startSpinner(depth === 0 ? 'NoxyAI is thinking...' : 'NoxyAI is processing feedback...');
 
   try {
     const res = await fetch(BASE_URL + '/api/io', {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + config.token },
-      body: JSON.stringify({ prompt: enhancedPrompt, model: config.model, agentMode: config.agentMode })
+      headers: { 
+        'Content-Type': 'application/json', 
+        'Authorization': 'Bearer ' + config.token,
+        'X-Client-Version': '1.0.0',
+        'X-Client-Platform': os.platform()
+      },
+      body: JSON.stringify({ 
+        prompt: enhancedPrompt, 
+        model: config.model, 
+        agentMode: config.agentMode,
+        context: {
+          cwd: process.cwd(),
+          platform: os.platform(),
+          shell: process.env.SHELL
+        }
+      })
     });
 
     stopSpinner();
-    if (!res.ok) return console.error('\n❌ API Error: ' + await res.text());
+    
+    if (!res.ok) {
+      const errorText = await res.text();
+      if (res.status === 401) {
+        console.error('\x1b[31m❌ Session expired. Please login again.\x1b[0m');
+        config.token = null;
+        saveConfig(config);
+        return;
+      }
+      if (res.status === 402) {
+        console.error('\x1b[31m❌ Insufficient credits. Visit: https://noxyai.com/pricing\x1b[0m');
+        return;
+      }
+      return console.error(`\x1b[31m❌ API Error (${res.status}):\x1b[0m ${errorText}`);
+    }
+    
     console.log(`\n🤖 \x1b[36mNoxyAI (${config.model}):\x1b[0m\n`);
 
     const reader = res.body.getReader();
     const decoder = new TextDecoder('utf-8');
     let fullResponse = "";
+    
+    // UI State for Boxed Reasoning
+    let isFirstReasoning = true;
+    let reasoningClosed = false;
+    let actionsPerformed = [];
+    let totalCost = 0;
+    let totalTokens = 0;
 
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
+      
       const lines = decoder.decode(value, { stream: true }).split('\n');
+      
       for (const line of lines) {
         if (line.startsWith('data: ')) {
           const data = line.slice(6).trim();
           if (data === '[DONE]') break;
+          
           try {
             const parsed = JSON.parse(data);
+            
+            // Boxed Reasoning UI
             if (parsed.isReasoning) {
-              process.stdout.write('\x1b[31m' + parsed.text + '\x1b[0m');
+              if (isFirstReasoning) {
+                process.stdout.write('\n\x1b[35m┌── 🧠 Deep Reasoning ─────────────────────\x1b[0m\n\x1b[31m│ \x1b[0m');
+                isFirstReasoning = false;
+              }
+              const text = parsed.text.replace(/\n/g, '\n\x1b[31m│ \x1b[0m');
+              process.stdout.write('\x1b[31m' + text + '\x1b[0m');
             } else if (parsed.text) {
+              if (!isFirstReasoning && !reasoningClosed) {
+                process.stdout.write('\n\x1b[35m└───────────────────────────────────────────\x1b[0m\n\n');
+                reasoningClosed = true;
+              }
               fullResponse += parsed.text;
               process.stdout.write(parsed.text);
             } else if (parsed.cost) {
-              // 🚨 EXPLICIT TOKEN BILLING READOUT
-              console.log(`\n\n\x1b[33m💳 Tokens Used: ${parsed.tokens} | Credits Deducted: ${parsed.cost}\x1b[0m`);
+              totalCost = parsed.cost;
+              totalTokens = parsed.tokens;
+              actionsPerformed = parsed.actions_performed || 0;
+              
+              console.log(`\n\n\x1b[90m${'─'.repeat(40)}\x1b[0m`);
+              console.log(`\x1b[33m📊 Session Stats:\x1b[0m`);
+              console.log(`  • Tokens: ${totalTokens}`);
+              console.log(`  • Credits: ${totalCost}`);
+              if (actionsPerformed > 0) {
+                console.log(`  • Actions: ${actionsPerformed}`);
+              }
+              console.log(`\x1b[90m${'─'.repeat(40)}\x1b[0m\n`);
+            } else if (parsed.actions) {
+              // Real-time action updates
+              parsed.actions.forEach(action => {
+                const icon = { search: '🔍', read: '📖', execute: '⚡', file: '📝', notify: '🔔' }[action.type] || '•';
+                console.log(`\x1b[36m${icon} Agent Action:\x1b[0m ${action.type}`);
+              });
             }
-          } catch (e) {}
+          } catch (e) {
+            // Ignore parsing errors
+          }
         }
       }
     }
     
-    if (!config.agentMode) { console.log(); return; }
+    if (!isFirstReasoning && !reasoningClosed) {
+      process.stdout.write('\n\x1b[35m└───────────────────────────────────────────\x1b[0m\n\n');
+    }
+
+    if (!config.agentMode) { 
+      console.log(); 
+      return; 
+    }
 
-    console.log('\n\x1b[32m[Agent] Processing actions...\x1b[0m');
+    console.log('\x1b[32m[Agent] Executing actions...\x1b[0m');
     let agentFeedback = "";
 
-    const readRegex = /<read>([\s\S]*?)<\/read>/g; let match;
+    // Tool: Notifications
+    const notifyRegex = /<notify>([\s\S]*?)<\/notify>/g; 
+    let match;
+    while ((match = notifyRegex.exec(fullResponse)) !== null) {
+      const msg = match[1].trim();
+      console.log(`\x1b[32m🔔 Notification:\x1b[0m ${msg}`);
+      
+      const platform = os.platform();
+      if (platform === 'android') {
+        spawn('termux-notification', ['-t', 'NoxyAI', '-c', msg], { stdio: 'ignore' });
+      } else if (platform === 'darwin') {
+        spawn('osascript', ['-e', `display notification "${msg.replace(/"/g, '\\"')}" with title "NoxyAI"`]);
+      } else if (platform === 'win32') {
+        spawn('powershell', ['-Command', `New-BurntToastNotification -Text "NoxyAI", "${msg}"`], { stdio: 'ignore' });
+      } else if (platform === 'linux') {
+        spawn('notify-send', ['NoxyAI', msg], { stdio: 'ignore' });
+      }
+    }
+
+    // Tool: Read Files
+    const readRegex = /<read>([\s\S]*?)<\/read>/g;
     while ((match = readRegex.exec(fullResponse)) !== null) {
       const filePath = match[1].trim();
+      
+      // Security check
+      if (filePath.includes('..') || filePath.includes('/etc/') || filePath.includes('.env')) {
+        console.log(`\x1b[31m⚠️ Security: Access denied to ${filePath}\x1b[0m`);
+        agentFeedback += `\n[SECURITY BLOCK: Cannot access ${filePath}]\n`;
+        continue;
+      }
+      
       try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        console.log(`\x1b[34m📖 Read file:\x1b[0m ${filePath}`);
-        agentFeedback += `\n[FILE: ${filePath}]\n\`\`\`\n${content}\n\`\`\`\n`;
-      } catch (err) { agentFeedback += `\n[ERROR reading ${filePath}: ${err.message}]\n`; }
+        const resolvedPath = path.resolve(filePath);
+        const content = fs.readFileSync(resolvedPath, 'utf8');
+        const truncated = content.length > 5000 ? content.substring(0, 5000) + '\n... [truncated]' : content;
+        console.log(`\x1b[34m📖 Read:\x1b[0m ${filePath} (${content.length} chars)`);
+        agentFeedback += `\n[FILE: ${filePath}]\n\`\`\`\n${truncated}\n\`\`\`\n`;
+      } catch (err) { 
+        console.log(`\x1b[31m❌ Read failed:\x1b[0m ${filePath} - ${err.message}`);
+        agentFeedback += `\n[ERROR reading ${filePath}: ${err.message}]\n`; 
+      }
     }
 
+    // Tool: Web Search (Enhanced with Google)
     const searchRegex = /<search>([\s\S]*?)<\/search>/g;
     while ((match = searchRegex.exec(fullResponse)) !== null) {
       const query = match[1].trim();
-      console.log(`\x1b[35m🔍 Searching Web:\x1b[0m ${query}`);
+      console.log(`\x1b[35m🔍 Searching:\x1b[0m ${query}`);
+      
+      // Check cache first
+      const cached = getCachedSearch(query);
+      if (cached) {
+        console.log(`\x1b[90m  ↳ Using cached results (${cached.length} items)\x1b[0m`);
+        let snippets = cached.map((r, i) => 
+          `${i + 1}. **${r.title}**\n   ${r.snippet}\n   🔗 ${r.link}`
+        ).join('\n\n');
+        agentFeedback += `\n[SEARCH RESULTS (cached): "${query}"]\n${snippets}\n`;
+        continue;
+      }
+      
       try {
         const searchRes = await fetch(BASE_URL + '/api/search', {
           method: 'POST',
-          headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + config.token },
-          body: JSON.stringify({ query })
+          headers: { 
+            'Content-Type': 'application/json', 
+            'Authorization': 'Bearer ' + config.token 
+          },
+          body: JSON.stringify({ query, num: 5 })
         });
         
-        // 🚨 SAFE JSON PARSING TO PREVENT HTML CRASHES
-        const responseText = await searchRes.text();
-        let searchData;
-        try {
-          searchData = JSON.parse(responseText);
-        } catch (parseError) {
-          throw new Error("Search backend returned an invalid response (Likely a 500 error or missing Vercel environment variables).");
+        const searchData = await searchRes.json();
+        
+        if (!searchRes.ok) {
+          throw new Error(searchData.error || `HTTP ${searchRes.status}`);
         }
-
-        if (!searchRes.ok) throw new Error(searchData.error || "Search failed");
-
-        let snippets = "No results found.";
-        if (searchData.items) {
-          console.log(`\x1b[32m📚 Sources Extracted:\x1b[0m`);
-          snippets = searchData.items.map(i => {
-            console.log(`  - ${i.title}\n    \x1b[31m${i.link}\x1b[0m`);
-            return `- Title: ${i.title}\n  Snippet: ${i.snippet}\n  URL: ${i.link}`;
-          }).join('\n\n');
+        
+        if (searchData.results && searchData.results.length > 0) {
+          cacheSearchResults(query, searchData.results);
+          
+          console.log(`\x1b[32m📚 Found ${searchData.results.length} results:\x1b[0m`);
+          let snippets = "";
+          searchData.results.forEach((item, i) => {
+            console.log(`  \x1b[36m${i + 1}.\x1b[0m ${item.title}`);
+            console.log(`     \x1b[90m${item.link}\x1b[0m`);
+            snippets += `${i + 1}. **${item.title}**\n   ${item.snippet}\n   🔗 ${item.link}\n\n`;
+          });
+          agentFeedback += `\n[SEARCH RESULTS: "${query}"]\n${snippets}\n`;
+        } else {
+          console.log(`\x1b[33m⚠️ No results found\x1b[0m`);
+          agentFeedback += `\n[SEARCH: No results for "${query}"]\n`;
         }
-        agentFeedback += `\n[SEARCH RESULTS FOR "${query}"]\n${snippets}\n`;
       } catch (err) { 
-        console.log(`\x1b[31m❌ Search Failed:\x1b[0m ${err.message}`);
-        agentFeedback += `\n[SEARCH FAILED: ${err.message}. Tell the user the search tool is currently unavailable.]\n`; 
+        console.log(`\x1b[31m❌ Search failed:\x1b[0m ${err.message}`);
+        agentFeedback += `\n[SEARCH ERROR: ${err.message}]\n`; 
       }
     }
 
+    // Tool: Write Files
     const fileRegex = /<file path="([^"]+)">([\s\S]*?)<\/file>/g;
     while ((match = fileRegex.exec(fullResponse)) !== null) {
       const filePath = match[1], content = match[2];
-      const dir = path.dirname(filePath);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(filePath, content.trim());
-      console.log(`\x1b[32m✔ Wrote file:\x1b[0m ${filePath}`);
+      
+      // Security checks
+      if (filePath.includes('..') || filePath.includes('/etc/') || 
+          filePath.includes('.env') || filePath.includes('.ssh/')) {
+        console.log(`\x1b[31m⚠️ Security: Write blocked for ${filePath}\x1b[0m`);
+        agentFeedback += `\n[SECURITY BLOCK: Cannot write to ${filePath}]\n`;
+        continue;
+      }
+      
+      try {
+        const resolvedPath = path.resolve(filePath);
+        const dir = path.dirname(resolvedPath);
+        
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        
+        // Backup existing file
+        if (fs.existsSync(resolvedPath)) {
+          const backup = resolvedPath + '.bak';
+          fs.copyFileSync(resolvedPath, backup);
+          console.log(`\x1b[90m  ↳ Backup created: ${path.basename(backup)}\x1b[0m`);
+        }
+        
+        fs.writeFileSync(resolvedPath, content.trim());
+        console.log(`\x1b[32m✔ Created:\x1b[0m ${filePath} (${content.length} chars)`);
+        agentFeedback += `\n[FILE CREATED: ${filePath}]\n`;
+      } catch (err) {
+        console.log(`\x1b[31m❌ Write failed:\x1b[0m ${filePath} - ${err.message}`);
+        agentFeedback += `\n[ERROR writing ${filePath}: ${err.message}]\n`;
+      }
     }
 
+    // Tool: Execute Commands (Safe Mode)
     const execRegex = /<execute>([\s\S]*?)<\/execute>/g;
     const commands = [];
-    while ((match = execRegex.exec(fullResponse)) !== null) commands.push(match[1].trim());
+    while ((match = execRegex.exec(fullResponse)) !== null) {
+      commands.push(match[1].trim());
+    }
+    
     for (const cmd of commands) {
-      try { await runTerminalCommand(cmd); } 
-      catch (err) { console.log(`\x1b[31m❌ Command Failed:\x1b[0m ${err}`); agentFeedback += `\n[COMMAND ERROR running "${cmd}": ${err}]\n`; }
+      // Security: Block dangerous commands
+      const dangerous = ['rm -rf /', 'sudo rm', 'dd if=', 'mkfs', ':(){', 'chmod 777 /', '> /dev/sda'];
+      if (dangerous.some(d => cmd.toLowerCase().includes(d))) {
+        console.log(`\x1b[31m🛑 BLOCKED:\x1b[0m Dangerous command prevented`);
+        agentFeedback += `\n[SECURITY BLOCK: Command rejected - ${cmd}]\n`;
+        continue;
+      }
+      
+      if (config.safeMode && !config.autoApprove) {
+        const answer = await askConfirm(
+          `\n\x1b[33m⚠️  Execute:\x1b[0m \x1b[36m${cmd}\x1b[0m\n` +
+          `\x1b[90m[Y]es / [N]o / [A]lways for session / [B]ackground:\x1b[0m `
+        );
+        
+        const lower = answer.toLowerCase();
+        if (lower === 'n') {
+          console.log('\x1b[31m✗ Skipped\x1b[0m');
+          agentFeedback += `\n[USER SKIPPED: ${cmd}]\n`;
+          continue;
+        } else if (lower === 'a') {
+          config.autoApprove = true;
+          saveConfig(config);
+          console.log('\x1b[32m✓ Auto-approve enabled for this session\x1b[0m');
+        } else if (lower === 'b') {
+          console.log('\x1b[36m⚡ Running in background...\x1b[0m');
+          try {
+            const result = await runTerminalCommand(cmd, { background: true });
+            console.log(`\x1b[32m✓ Started (PID: ${result.pid})\x1b[0m`);
+            agentFeedback += `\n[COMMAND STARTED (background): ${cmd}]\n`;
+          } catch (err) {
+            console.log(`\x1b[31m❌ Failed:\x1b[0m ${err.message}`);
+            agentFeedback += `\n[ERROR: ${err.message}]\n`;
+          }
+          continue;
+        }
+      }
+      
+      try {
+        await runTerminalCommand(cmd);
+        agentFeedback += `\n[COMMAND SUCCEEDED: ${cmd}]\n`;
+      } catch (err) {
+        console.log(`\x1b[31m❌ Failed:\x1b[0m ${err.message}`);
+        agentFeedback += `\n[COMMAND ERROR: ${cmd} - ${err.message}]\n`;
+      }
     }
 
+    // Reset auto-approve after session
+    if (config.autoApprove) {
+      config.autoApprove = false;
+      saveConfig(config);
+    }
+
+    // Recursive feedback loop
     if (agentFeedback) {
-      console.log(`\x1b[33m🔄 Sending data back to Agent...\x1b[0m`);
-      await chat(`Action results:\n${agentFeedback}\nNext step? Output <file> or <execute> if ready, or <read>/<search>.`, depth + 1);
+      console.log(`\n\x1b[33m🔄 Processing results with Agent...\x1b[0m`);
+      await chat(
+        `Action results:\n${agentFeedback}\n\n` +
+        `Based on these results, what should be the next step? ` +
+        `Respond with appropriate XML tags (<read>, <search>, <file>, <execute>, <notify>) ` +
+        `or "TASK_COMPLETE" if finished.`,
+        depth + 1
+      );
       return;
     }
 
-    console.log('\n\x1b[32m════════════════════════════════════════\x1b[0m');
-    console.log(`\x1b[32m✨ Task Completed!\x1b[0m`);
-    console.log('\x1b[32m════════════════════════════════════════\x1b[0m\n');
+    console.log('\n\x1b[32m' + '═'.repeat(40) + '\x1b[0m');
+    console.log(`\x1b[32m✨ Task completed successfully!\x1b[0m`);
+    console.log('\x1b[32m' + '═'.repeat(40) + '\x1b[0m\n');
 
-  } catch (error) { stopSpinner(); console.error('\n❌ Connection error: ' + error.message); }
+  } catch (error) { 
+    stopSpinner(); 
+    console.error('\n\x1b[31m❌ Connection error:\x1b[0m ' + error.message); 
+  }
 }
 
 function startInteractiveMode() {
   const config = loadConfig();
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   printLogo();
-  console.log(`\x1b[33mWelcome to NoxyAI Interactive Mode!\x1b[0m`);
-  console.log(`Model: \x1b[32m${config.model}\x1b[0m | Agent Mode: ${config.agentMode ? '\x1b[32mON\x1b[0m' : '\x1b[31mOFF\x1b[0m'}`);
-  console.log(`Commands: \x1b[36m/model\x1b[0m, \x1b[36m/agent\x1b[0m, \x1b[36m/clear\x1b[0m, \x1b[36m/exit\x1b[0m\n`);
+  
+  if (!config.token) {
+    console.log('\x1b[33mWelcome to NoxyAI!\x1b[0m');
+    console.log('\x1b[36mTo get started, run:\x1b[0m \x1b[32mnoxyai login\x1b[0m\n');
+    process.exit(0);
+  }
+  
+  console.log(`\x1b[33mWelcome back${config.userEmail ? ', ' + config.userEmail : ''}!\x1b[0m`);
+  console.log(`\n\x1b[90m${'─'.repeat(40)}\x1b[0m`);
+  console.log(`Model: \x1b[32m${config.model}\x1b[0m`);
+  console.log(`Agent Mode: ${config.agentMode ? '\x1b[32m● ON\x1b[0m' : '\x1b[31m○ OFF\x1b[0m'}`);
+  console.log(`Safe Mode: ${config.safeMode ? '\x1b[32m● ON\x1b[0m' : '\x1b[33m○ OFF\x1b[0m'}`);
+  console.log(`\x1b[90m${'─'.repeat(40)}\x1b[0m`);
+  console.log(`\nCommands: \x1b[36m/model\x1b[0m \x1b[36m/agent\x1b[0m \x1b[36m/safe\x1b[0m \x1b[36m/clear\x1b[0m \x1b[36m/status\x1b[0m \x1b[36m/exit\x1b[0m`);
+  console.log(`Type your question or task below.\n`);
   
   function ask() {
-    rl.question('\x1b[36mNoxyAI > \x1b[0m', async (input) => {
+    rl.question('\x1b[36m⟫\x1b[0m ', async (input) => {
       const trimmed = input.trim();
       const lower = trimmed.toLowerCase();
 
-      if (lower === 'exit' || lower === '/exit') process.exit(0);
-      else if (lower === '/clear') { console.clear(); printLogo(); ask(); } 
-      else if (lower === '/agent') {
-        const c = loadConfig(); c.agentMode = !c.agentMode; saveConfig(c);
-        console.log(`\n\x1b[33mAgent Mode is now ${c.agentMode ? '\x1b[32mON (File/Web access enabled)' : '\x1b[31mOFF (Standard Chat)'}\x1b[0m\n`);
+      if (lower === 'exit' || lower === '/exit' || lower === '/quit') {
+        console.log('\n\x1b[36mGoodbye! 👋\x1b[0m\n');
+        process.exit(0);
+      } else if (lower === '/clear') { 
+        console.clear(); 
+        printLogo(); 
+        ask(); 
+      } else if (lower === '/agent') {
+        const c = loadConfig(); 
+        c.agentMode = !c.agentMode; 
+        saveConfig(c);
+        console.log(`\n\x1b[33mAgent Mode: ${c.agentMode ? '\x1b[32m● ON (File/Web/Execute access)' : '\x1b[31m○ OFF (Chat only)'}\x1b[0m\n`);
         ask();
-      }
-      else if (lower === '/model') {
-        console.log('\n\x1b[33mSelect an AI Model:\x1b[0m');
-        console.log('  \x1b[36m1)\x1b[0m Auto (Llama 3.3 70B)');
-        console.log('  \x1b[36m2)\x1b[0m Qwen3 Next 80B (Deep Reasoning)');
-        console.log('  \x1b[36m3)\x1b[0m Mistral Mamba Codestral 7B');
-        rl.question('\nEnter number (1-3): ', (choice) => {
+      } else if (lower === '/safe') {
+        const c = loadConfig(); 
+        c.safeMode = !c.safeMode; 
+        saveConfig(c);
+        console.log(`\n\x1b[33mSafe Mode: ${c.safeMode ? '\x1b[32m● ON (Command confirmation required)' : '\x1b[33m○ OFF (Auto-execute enabled - use with caution!)'}\x1b[0m\n`);
+        ask();
+      } else if (lower === '/status') {
+        const c = loadConfig();
+        console.log(`\n\x1b[90m${'─'.repeat(40)}\x1b[0m`);
+        console.log(`\x1b[36mSession Status:\x1b[0m`);
+        console.log(`  • User: ${c.userEmail || 'Unknown'}`);
+        console.log(`  • Model: ${c.model}`);
+        console.log(`  • Agent Mode: ${c.agentMode ? 'ON' : 'OFF'}`);
+        console.log(`  • Safe Mode: ${c.safeMode ? 'ON' : 'OFF'}`);
+        console.log(`  • CWD: ${process.cwd()}`);
+        console.log(`\x1b[90m${'─'.repeat(40)}\x1b[0m\n`);
+        ask();
+      } else if (lower === '/model') {
+        console.log('\n\x1b[33mSelect AI Model:\x1b[0m');
+        console.log('  \x1b[36m1)\x1b[0m Auto (Llama 3.3 70B) - Fast & Capable');
+        console.log('  \x1b[36m2)\x1b[0m Qwen3 Next 80B - Deep Reasoning');
+        console.log('  \x1b[36m3)\x1b[0m Mistral Mamba Codestral 7B - Code Optimized');
+        
+        rl.question('\n\x1b[36mChoice (1-3):\x1b[0m ', (choice) => {
           let selected = 'auto';
-          if (choice === '2') selected = 'Qwen3';
-          if (choice === '3') selected = 'Mamba';
-          const c = loadConfig(); c.model = selected; saveConfig(c);
-          console.log(`\n\x1b[32m✔ Model changed to: ${selected}\x1b[0m\n`); ask();
+          let modelName = 'Auto (Llama 3.3 70B)';
+          if (choice === '2') { selected = 'Qwen3'; modelName = 'Qwen3 Next 80B'; }
+          if (choice === '3') { selected = 'Mamba'; modelName = 'Mistral Mamba Codestral 7B'; }
+          
+          const c = loadConfig(); 
+          c.model = selected; 
+          saveConfig(c);
+          console.log(`\n\x1b[32m✓ Model changed to: ${modelName}\x1b[0m\n`); 
+          ask();
         });
         return;
-      } 
-      else if (trimmed) { await chat(trimmed); ask(); } 
-      else ask();
+      } else if (trimmed) { 
+        await chat(trimmed); 
+        ask(); 
+      } else { 
+        ask(); 
+      }
     });
   }
+  
   ask();
 }
 
-if (command === 'login') login();
-else if (command === 'logout') { const c = loadConfig(); c.token = null; saveConfig(c); console.log('Logged out.'); }
-else if (command === 'help' || command === '--help') { printLogo(); console.log(`  \x1b[32mnoxyai\x1b[0m     Start Interactive Mode\n`); }
-else if (!command) startInteractiveMode();
-else { console.error(`❌ Unknown command.`); process.exit(1); }
+// CLI Command Router
+if (command === 'login') {
+  login();
+} else if (command === 'logout') { 
+  const c = loadConfig(); 
+  c.token = null; 
+  c.userEmail = null;
+  saveConfig(c); 
+  console.log('\x1b[32m✓ Successfully logged out.\x1b[0m\n'); 
+  process.exit(0); 
+} else if (command === 'help' || command === '--help' || command === '-h') { 
+  printLogo();
+  console.log(`
+\x1b[33mNoxyAI - Your Autonomous Terminal Agent\x1b[0m
+
+\x1b[36mUsage:\x1b[0m
+  noxyai               Start interactive mode
+  noxyai login         Authenticate with your NoxyAI account
+  noxyai logout        Remove local authentication
+  noxyai help          Show this help message
+
+\x1b[36mInteractive Commands:\x1b[0m
+  /model              Switch AI model
+  /agent              Toggle agent mode (file/web/execute access)
+  /safe               Toggle safe mode (command confirmation)
+  /status             Show current session status
+  /clear              Clear the screen
+  /exit               Exit the program
+
+\x1b[36mExamples:\x1b[0m
+  $ noxyai login
+  $ noxyai
+  > Create a React component for a login form
+  > Search for Python asyncio best practices
+  > Optimize this Dockerfile
+
+\x1b[90mDocumentation: https://noxyai.com/docs\x1b[0m
+  `);
+  process.exit(0); 
+} else if (command === 'version' || command === '--version' || command === '-v') {
+  console.log('NoxyAI CLI v1.0.0');
+  process.exit(0);
+} else if (!command) {
+  startInteractiveMode();
+} else if (command.startsWith('-')) {
+  console.error(`\x1b[31m❌ Unknown option: ${command}\x1b[0m`);
+  console.error(`\x1b[90mRun 'noxyai help' for usage information.\x1b[0m\n`);
+  process.exit(1);
+} else {
+  // Direct query mode: noxyai "your question here"
+  const query = args.join(' ');
+  const config = loadConfig();
+  
+  if (!config.token) {
+    console.error('\x1b[31m❌ Not logged in. Run "noxyai login" first.\x1b[0m\n');
+    process.exit(1);
+  }
+  
+  chat(query).then(() => process.exit(0));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-noxyai",
-  "version": "1.0.16",
+  "version": "1.0.19",
   "description": "CLI for NoxyAI",
   "main": "index-noxyai.js",
   "bin": {