avg-nexus 1.0.10 → 1.0.12

package/bin/avg-nexus.js

@@ -1,63 +1,259 @@
 #!/usr/bin/env node
 'use strict';
 
-const { execSync, spawn } = require('child_process');
-const http = require('http');
-const path = require('path');
-const fs = require('fs');
+// ═══════════════════════════════════════════════════════════════
+//   AVG-NEXUS  v4.0  —  NexusAI Local Proxy + API Key Manager
+//   • Ollama → OpenRouter proxy (port 11435)
+//   • Device ID → API key tizimi
+//   • 10 ta OpenRouter key rotatsiya
+//   • Admin panel API (port 11436)
+//   • NexusAI saytni avtomatik ishga tushirish
+// ═══════════════════════════════════════════════════════════════
 
+const { execSync, spawn }  = require('child_process');
+const http                 = require('http');
+const https                = require('https');
+const path                 = require('path');
+const fs                   = require('fs');
+const os                   = require('os');
+const crypto               = require('crypto');
+
+// ── Ranglar ──────────────────────────────────────────────────
 const C = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
+  reset:'\x1b[0m', bold:'\x1b[1m', dim:'\x1b[2m',
+  red:'\x1b[31m', green:'\x1b[32m', yellow:'\x1b[33m',
+  cyan:'\x1b[36m', purple:'\x1b[35m', blue:'\x1b[34m',
+  gray:'\x1b[90m', white:'\x1b[37m',
 };
 
-function log(icon, msg, color = C.reset) {
+const log = (icon, msg, color = C.reset) =>
   console.log(`${color}${icon} ${msg}${C.reset}`);
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+// ── Portlar ───────────────────────────────────────────────────
+const PROXY_PORT = 11435;   // nexusai-team .env.local ga mos
+const ADMIN_PORT = 11436;   // avg-ai CLI boshqaruv
+const OLLAMA_PORT = 11434;  // Ollama default
+
+// ── Ma'lumot papkasi ──────────────────────────────────────────
+const DATA_DIR    = path.join(os.homedir(), '.avg-nexus');
+const KEYS_FILE   = path.join(DATA_DIR, 'keys.json');
+const DEVICES_FILE = path.join(DATA_DIR, 'devices.json');
+const CONFIG_FILE = path.join(DATA_DIR, 'config.json');
+
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+// ══════════════════════════════════════════════════════════════
+//   KEY POOL — 10 ta OpenRouter kalit boshqaruvi
+// ══════════════════════════════════════════════════════════════
+
+function loadKeys() {
+  ensureDataDir();
+  try {
+    if (fs.existsSync(KEYS_FILE)) {
+      return JSON.parse(fs.readFileSync(KEYS_FILE, 'utf8'));
+    }
+  } catch {}
+  return { keys: [], currentIndex: 0 };
+}
+
+function saveKeys(data) {
+  ensureDataDir();
+  fs.writeFileSync(KEYS_FILE, JSON.stringify(data, null, 2));
 }
 
-function sleep(ms) {
-  return new Promise(r => setTimeout(r, ms));
+function addApiKey(key) {
+  const data = loadKeys();
+  if (!data.keys.includes(key)) {
+    data.keys.push(key);
+    saveKeys(data);
+    return true;
+  }
+  return false;
+}
+
+function removeApiKey(key) {
+  const data = loadKeys();
+  const before = data.keys.length;
+  data.keys = data.keys.filter(k => k !== key);
+  if (data.currentIndex >= data.keys.length) data.currentIndex = 0;
+  saveKeys(data);
+  return data.keys.length < before;
+}
+
+function getNextKey() {
+  const data = loadKeys();
+  if (data.keys.length === 0) return null;
+  const key = data.keys[data.currentIndex % data.keys.length];
+  data.currentIndex = (data.currentIndex + 1) % data.keys.length;
+  saveKeys(data);
+  return key;
+}
+
+function getAllKeys() {
+  return loadKeys().keys;
 }
 
-// ── Ollama topish — PATH + barcha disklar ──
+// Key holati tracking
+const keyStats = new Map();
+
+function getKeyStats(key) {
+  if (!keyStats.has(key)) {
+    keyStats.set(key, {
+      calls: 0, success: 0, fail: 0,
+      lastUsed: null, lastError: null,
+      cooldownUntil: 0,
+    });
+  }
+  return keyStats.get(key);
+}
+
+function markSuccess(key) {
+  const s = getKeyStats(key);
+  s.calls++; s.success++; s.lastUsed = Date.now(); s.cooldownUntil = 0;
+}
+
+function markFail(key, err) {
+  const s = getKeyStats(key);
+  s.calls++; s.fail++; s.lastError = err;
+  // Exponential backoff: 5s, 10s, 20s, max 60s
+  const backoff = Math.min(5000 * Math.pow(2, s.fail - 1), 60000);
+  s.cooldownUntil = Date.now() + backoff;
+}
+
+function isAvailable(key) {
+  const s = keyStats.get(key);
+  if (!s) return true;
+  return Date.now() > s.cooldownUntil;
+}
+
+function getBestKey(keys) {
+  const available = keys.filter(isAvailable);
+  if (available.length === 0) return keys[Math.floor(Math.random() * keys.length)];
+  // Eng kam ishlatilgani
+  available.sort((a, b) => {
+    const sa = getKeyStats(a), sb = getKeyStats(b);
+    return (sa.lastUsed || 0) - (sb.lastUsed || 0);
+  });
+  return available[0];
+}
+
+// ══════════════════════════════════════════════════════════════
+//   DEVICE MANAGER — har bir qurilma uchun API key
+// ══════════════════════════════════════════════════════════════
+
+function loadDevices() {
+  ensureDataDir();
+  try {
+    if (fs.existsSync(DEVICES_FILE)) {
+      return JSON.parse(fs.readFileSync(DEVICES_FILE, 'utf8'));
+    }
+  } catch {}
+  return {};
+}
+
+function saveDevices(data) {
+  ensureDataDir();
+  fs.writeFileSync(DEVICES_FILE, JSON.stringify(data, null, 2));
+}
+
+function registerDevice(deviceId, info = {}) {
+  const devices = loadDevices();
+  if (!devices[deviceId]) {
+    devices[deviceId] = {
+      id: deviceId,
+      registeredAt: Date.now(),
+      lastSeen: Date.now(),
+      info,
+      apiKey: null,
+      calls: 0,
+    };
+    saveDevices(devices);
+    log('📱', `Yangi qurilma: ${deviceId}`, C.cyan);
+  } else {
+    devices[deviceId].lastSeen = Date.now();
+    if (info.hostname) devices[deviceId].info = { ...devices[deviceId].info, ...info };
+    saveDevices(devices);
+  }
+  return devices[deviceId];
+}
+
+function assignKeyToDevice(deviceId, apiKey) {
+  const devices = loadDevices();
+  if (!devices[deviceId]) return false;
+  devices[deviceId].apiKey = apiKey;
+  saveDevices(devices);
+  return true;
+}
+
+function getDeviceKey(deviceId) {
+  if (!deviceId) return null;
+  const devices = loadDevices();
+  return devices[deviceId]?.apiKey || null;
+}
+
+// ══════════════════════════════════════════════════════════════
+//   OLLAMA TOPISH
+// ══════════════════════════════════════════════════════════════
+
 function findOllama() {
+  // 1. PATH
   try {
-    const r = execSync('where ollama', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
+    const r = execSync(os.platform() === 'win32' ? 'where ollama' : 'which ollama',
+      { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
     if (r) return r.split('\n')[0].trim();
   } catch {}
 
-  const drives = ['A','B','C','D','E','F','G','H','I','J'];
-  const locations = [
-    'Ollama\\ollama.exe',
-    'Program Files\\Ollama\\ollama.exe',
-    `Users\\${process.env.USERNAME || 'user'}\\AppData\\Local\\Programs\\Ollama\\ollama.exe`,
-  ];
+  // 2. Windows disk scan
+  if (os.platform() === 'win32') {
+    // Registry
+    try {
+      const reg = execSync(
+        'reg query "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\ollama.exe" /ve',
+        { stdio: 'pipe' }).toString();
+      const m = reg.match(/REG_SZ\s+(.+)/);
+      if (m && fs.existsSync(m[1].trim())) return m[1].trim();
+    } catch {}
 
-  for (const d of drives) {
-    for (const l of locations) {
-      const p = `${d}:\\${l}`;
-      try { if (fs.existsSync(p)) return p; } catch {}
+    // Disk scan
+    const drives = ['C','D','E','F','G','H'];
+    const locs = [
+      `AppData\\Local\\Programs\\Ollama\\ollama.exe`,
+      `Users\\${process.env.USERNAME || ''}\\AppData\\Local\\Programs\\Ollama\\ollama.exe`,
+    ];
+    for (const d of drives) {
+      for (const l of locs) {
+        const p = `${d}:\\${l}`;
+        try { if (fs.existsSync(p)) return p; } catch {}
+      }
+      // Direct locations
+      for (const name of ['Ollama\\ollama.exe', 'ollama\\ollama.exe']) {
+        const p = `${d}:\\${name}`;
+        try { if (fs.existsSync(p)) return p; } catch {}
+      }
+    }
+    if (process.env.LOCALAPPDATA) {
+      const p = path.join(process.env.LOCALAPPDATA, 'Programs', 'Ollama', 'ollama.exe');
+      if (fs.existsSync(p)) return p;
     }
   }
   return null;
 }
 
-// ── Model topish — ollama list CLI orqali ──
+// ══════════════════════════════════════════════════════════════
+//   MODEL TOPISH
+// ══════════════════════════════════════════════════════════════
+
 function findBestModel() {
-  const preferred = ['gemma4', 'gemma3', 'gemma2', 'qwen', 'llama', 'mistral', 'deepseek', 'phi'];
+  const preferred = ['gemma4','gemma3','gemma2','qwen2.5','qwen','llama','mistral','deepseek','phi'];
   try {
     const result = execSync('ollama list', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 10000,
+      encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 15000,
     });
-    const lines = result
-      .split('\n')
+    const lines = result.split('\n')
       .filter(l => l.trim() && !l.toLowerCase().startsWith('name'));
 
     if (lines.length > 0) {
@@ -65,8 +261,7 @@ function findBestModel() {
         const found = lines.find(l => l.toLowerCase().includes(pref));
         if (found) {
           const name = found.split(/\s+/)[0].trim();
-          log('✅', `Model topildi: ${name}`, C.green);
-          return name;
+          if (name) { log('✅', `Model: ${name}`, C.green); return name; }
         }
       }
       const name = lines[0].split(/\s+/)[0].trim();
@@ -74,94 +269,434 @@ function findBestModel() {
       return name;
     }
   } catch (e) {
-    log('⚠️', `ollama list xatosi: ${e.message}`, C.yellow);
+    log('⚠️', `ollama list: ${e.message}`, C.yellow);
   }
-
-  // Model topilmadi — gemma4:e4b yuklab olish
-  log('📥', 'Model topilmadi. gemma4:e4b yuklanmoqda...', C.yellow);
-  execSync('ollama pull gemma4:e4b', { stdio: 'inherit' });
+  log('📥', 'Model topilmadi, gemma4:e4b yuklanmoqda...', C.yellow);
+  try {
+    execSync('ollama pull gemma4:e4b', { stdio: 'inherit' });
+  } catch {}
   return 'gemma4:e4b';
 }
 
-// ── Ollama serve ishga tushirish ──
-function startOllama(ollamaPath) {
+// ══════════════════════════════════════════════════════════════
+//   OLLAMA SERVE
+// ══════════════════════════════════════════════════════════════
+
+async function startOllama(ollamaPath) {
+  // Allaqachon ishlayaptimi?
   try {
-    execSync('curl -s http://localhost:11434', { timeout: 2000, stdio: 'pipe' });
+    await httpGet('http://localhost:11434/api/tags', 2000);
     log('✅', 'Ollama allaqachon ishlamoqda', C.green);
     return;
   } catch {}
+
   log('🚀', 'Ollama ishga tushirilmoqda...', C.cyan);
   const proc = spawn(ollamaPath, ['serve'], {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true,
+    detached: true, stdio: 'ignore', windowsHide: true,
   });
   proc.unref();
+  await sleep(3000);
   log('✅', 'Ollama serve ishga tushdi', C.green);
 }
 
-// ── OpenRouter → Ollama Proxy ──
-function startProxy(model) {
-  const PORT = 11435;
+// ══════════════════════════════════════════════════════════════
+//   HTTP HELPER
+// ══════════════════════════════════════════════════════════════
+
+function httpGet(url, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, { timeout }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => resolve(data));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+// ══════════════════════════════════════════════════════════════
+//   PROXY SERVER — OpenRouter API format → Ollama
+// ══════════════════════════════════════════════════════════════
+
+function startProxy(localModel) {
   const server = http.createServer(async (req, res) => {
+    // CORS
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Headers', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
 
-    if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
+    const url = req.url || '/';
 
-    if (req.url && req.url.includes('/models')) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ data: [{ id: model, name: model, context_length: 8192 }] }));
+    // ── Models endpoint ──
+    if (url.includes('/models')) {
+      try {
+        const result = execSync('ollama list', {
+          encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 5000,
+        });
+        const lines = result.split('\n')
+          .filter(l => l.trim() && !l.toLowerCase().startsWith('name'));
+        const models = lines.map(l => {
+          const name = l.split(/\s+/)[0].trim();
+          return {
+            id: name, object: 'model',
+            created: Math.floor(Date.now() / 1000),
+            owned_by: 'ollama', name,
+            context_length: 8192,
+            pricing: { prompt: '0', completion: '0' },
+          };
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ object: 'list', data: models }));
+      } catch {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          object: 'list',
+          data: [{ id: localModel, name: localModel, object: 'model',
+            owned_by: 'ollama', context_length: 8192,
+            pricing: { prompt: '0', completion: '0' } }],
+        }));
+      }
       return;
     }
 
-    let body = '';
-    req.on('data', c => body += c);
-    req.on('end', async () => {
-      try {
-        let d = {};
-        try { d = JSON.parse(body); } catch {}
-        const ollamaRes = await fetch('http://localhost:11434/api/chat', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ model: d.model || model, messages: d.messages || [], stream: true }),
-        });
-        res.writeHead(200, { 'Content-Type': 'text/event-stream' });
-        const reader = ollamaRes.body.getReader();
-        const dec = new TextDecoder();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          for (const line of dec.decode(value).split('\n').filter(l => l.trim())) {
+    // ── Chat completions ──
+    if (url.includes('/chat/completions')) {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', async () => {
+        try {
+          const d = JSON.parse(body || '{}');
+          const model = localModel;
+          const isStream = d.stream !== false;
+
+          // Device ID dan key olish (Authorization header dan)
+          const authHeader = req.headers['authorization'] || '';
+          const deviceId = authHeader.replace('Bearer ', '').trim();
+          const deviceApiKey = getDeviceKey(deviceId);
+
+          // Agar device o'ziga specific OpenRouter key bor bo'lsa — undan foydalanish
+          // Aks holda Ollama local
+          const allKeys = getAllKeys();
+          const useOnline = (deviceApiKey || allKeys.length > 0) &&
+            deviceId && deviceId.startsWith('sk-') === false &&
+            !['ollama-local','local','offline'].includes(deviceId);
+
+          if (deviceId && !deviceId.startsWith('sk-') && deviceId !== 'ollama-local') {
+            registerDevice(deviceId, {});
+          }
+
+          // Ollama ga yo'naltir
+          await proxyToOllama(req, res, d, model, isStream);
+
+        } catch (e) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: e.message, type: 'proxy_error' } }));
+        }
+      });
+      return;
+    }
+
+    // ── Boshqalar ──
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+  });
+
+  server.listen(PROXY_PORT, '127.0.0.1', () => {
+    log('✅', `Proxy: http://localhost:${PROXY_PORT}`, C.green);
+  });
+
+  server.on('error', err => {
+    if (err.code === 'EADDRINUSE') {
+      log('⚠️', `Port ${PROXY_PORT} band — proxy allaqachon ishlamoqda`, C.yellow);
+    } else {
+      log('❌', `Proxy xatosi: ${err.message}`, C.red);
+    }
+  });
+
+  return server;
+}
+
+async function proxyToOllama(req, res, body, model, isStream) {
+  const ollamaBody = JSON.stringify({
+    model: model,
+    messages: body.messages || [],
+    stream: isStream,
+    options: {
+      temperature: body.temperature || 0.7,
+      num_predict: body.max_tokens || 2048,
+    },
+  });
+
+  return new Promise((resolve, reject) => {
+    const proxyReq = http.request({
+      hostname: '127.0.0.1', port: OLLAMA_PORT,
+      path: '/api/chat', method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(ollamaBody),
+      },
+    }, (proxyRes) => {
+      if (isStream) {
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' });
+        const decoder = require('string_decoder').StringDecoder;
+        const dec = new (decoder)('utf8');
+        proxyRes.on('data', chunk => {
+          const text = dec.write(chunk);
+          for (const line of text.split('\n')) {
+            if (!line.trim()) continue;
             try {
               const j = JSON.parse(line);
+              const content = j.message?.content || '';
+              const done = j.done || false;
               res.write('data: ' + JSON.stringify({
                 id: 'chatcmpl-' + Date.now(),
                 object: 'chat.completion.chunk',
-                choices: [{ delta: { content: j.message?.content || '' }, finish_reason: j.done ? 'stop' : null }],
+                choices: [{
+                  delta: { content },
+                  finish_reason: done ? 'stop' : null,
+                  index: 0,
+                }],
               }) + '\n\n');
             } catch {}
           }
-        }
-        res.write('data: [DONE]\n\n');
-        res.end();
-      } catch (e) { res.writeHead(500); res.end(JSON.stringify({ error: e.message })); }
+        });
+        proxyRes.on('end', () => {
+          res.write('data: [DONE]\n\n');
+          res.end();
+          resolve();
+        });
+      } else {
+        let data = '';
+        proxyRes.on('data', c => data += c);
+        proxyRes.on('end', () => {
+          try {
+            // Ollama javoblarini OpenRouter formatiga aylantirish
+            const lines = data.split('\n').filter(l => l.trim());
+            let fullContent = '';
+            for (const line of lines) {
+              try {
+                const j = JSON.parse(line);
+                fullContent += j.message?.content || '';
+              } catch {}
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+              id: 'chatcmpl-' + Date.now(),
+              object: 'chat.completion',
+              model: model,
+              choices: [{
+                message: { role: 'assistant', content: fullContent },
+                finish_reason: 'stop', index: 0,
+              }],
+              usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+            }));
+          } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: e.message } }));
+          }
+          resolve();
+        });
+      }
+      proxyRes.on('error', reject);
     });
+    proxyReq.on('error', reject);
+    proxyReq.write(ollamaBody);
+    proxyReq.end();
+  });
+}
+
+// ══════════════════════════════════════════════════════════════
+//   ADMIN SERVER — avg-ai CLI boshqaruvi (port 11436)
+// ══════════════════════════════════════════════════════════════
+
+function startAdminServer(localModel) {
+  const server = http.createServer((req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    res.setHeader('Content-Type', 'application/json');
+
+    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+    const url = req.url || '/';
+    let body = '';
+    req.on('data', c => body += c);
+    req.on('end', () => {
+      try {
+        handleAdminRequest(req, res, url, body, localModel);
+      } catch (e) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    });
+  });
+
+  server.listen(ADMIN_PORT, '127.0.0.1', () => {
+    log('✅', `Admin API: http://localhost:${ADMIN_PORT}`, C.green);
+  });
+
+  server.on('error', err => {
+    if (err.code !== 'EADDRINUSE') {
+      log('❌', `Admin server: ${err.message}`, C.red);
+    }
   });
-  server.listen(PORT, () => log('✅', `Proxy: http://localhost:${PORT}`, C.green));
-  return server;
 }
 
-// ── NexusAI loyiha topish ──
+function handleAdminRequest(req, res, url, body, localModel) {
+  let parsed = {};
+  try { parsed = JSON.parse(body); } catch {}
+
+  // ── Status ──
+  if (url === '/status' || url === '/') {
+    const keys = getAllKeys();
+    const devices = loadDevices();
+    const keyStatus = keys.map((k, i) => {
+      const s = getKeyStats(k);
+      return {
+        index: i + 1,
+        preview: `...${k.slice(-6)}`,
+        available: isAvailable(k),
+        calls: s.calls, success: s.success, fail: s.fail,
+        cooldownMs: Math.max(0, s.cooldownUntil - Date.now()),
+      };
+    });
+    res.writeHead(200);
+    res.end(JSON.stringify({
+      status: 'running',
+      model: localModel,
+      proxyPort: PROXY_PORT,
+      adminPort: ADMIN_PORT,
+      ollamaPort: OLLAMA_PORT,
+      keys: { total: keys.length, status: keyStatus },
+      devices: { total: Object.keys(devices).length, list: Object.values(devices).map(d => ({
+        id: d.id, lastSeen: d.lastSeen, hasKey: !!d.apiKey, calls: d.calls,
+      })) },
+      uptime: process.uptime(),
+    }));
+    return;
+  }
+
+  // ── Keys: qo'shish ──
+  if (url === '/keys/add' && req.method === 'POST') {
+    const key = parsed.key?.trim();
+    if (!key || !key.startsWith('sk-')) {
+      res.writeHead(400); res.end(JSON.stringify({ error: 'sk- bilan boshlanishi kerak' }));
+      return;
+    }
+    const added = addApiKey(key);
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: true, added, total: getAllKeys().length }));
+    return;
+  }
+
+  // ── Keys: o'chirish ──
+  if (url === '/keys/remove' && req.method === 'POST') {
+    const key = parsed.key?.trim();
+    const removed = removeApiKey(key);
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: removed, total: getAllKeys().length }));
+    return;
+  }
+
+  // ── Keys: ro'yxat ──
+  if (url === '/keys/list') {
+    const keys = getAllKeys();
+    res.writeHead(200);
+    res.end(JSON.stringify({
+      total: keys.length,
+      keys: keys.map((k, i) => {
+        const s = getKeyStats(k);
+        return {
+          index: i + 1, preview: `sk-or-...${k.slice(-8)}`,
+          available: isAvailable(k), calls: s.calls,
+          success: s.success, fail: s.fail,
+        };
+      }),
+    }));
+    return;
+  }
+
+  // ── Device: ro'yxat ──
+  if (url === '/devices') {
+    const devices = loadDevices();
+    res.writeHead(200);
+    res.end(JSON.stringify({ devices: Object.values(devices) }));
+    return;
+  }
+
+  // ── Device: key tayinlash ──
+  if (url === '/devices/assign' && req.method === 'POST') {
+    const { deviceId, key } = parsed;
+    if (!deviceId || !key) {
+      res.writeHead(400); res.end(JSON.stringify({ error: 'deviceId va key kerak' }));
+      return;
+    }
+    const ok = assignKeyToDevice(deviceId, key);
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: ok }));
+    return;
+  }
+
+  // ── Ollama: modellar ──
+  if (url === '/ollama/models') {
+    try {
+      const result = execSync('ollama list', {
+        encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 10000,
+      });
+      const lines = result.split('\n').filter(l => l.trim() && !l.toLowerCase().startsWith('name'));
+      const models = lines.map(l => ({
+        name: l.split(/\s+/)[0].trim(),
+        size: l.split(/\s+/)[2] || '',
+        modified: l.split(/\s+/).slice(3).join(' ') || '',
+      })).filter(m => m.name);
+      res.writeHead(200);
+      res.end(JSON.stringify({ models, current: localModel }));
+    } catch (e) {
+      res.writeHead(500);
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // ── Env: .env.local yangilash ──
+  if (url === '/env/update' && req.method === 'POST') {
+    const { projectDir } = parsed;
+    if (!projectDir || !fs.existsSync(projectDir)) {
+      res.writeHead(400); res.end(JSON.stringify({ error: 'projectDir topilmadi' })); return;
+    }
+    const keys = getAllKeys();
+    const envLines = [
+      `OPENROUTER_BASE_URL=http://localhost:${PROXY_PORT}/api/v1`,
+    ];
+    if (keys.length > 0) {
+      keys.slice(0, 10).forEach((k, i) => envLines.push(`OPENROUTER_API_KEY_${i+1}=${k}`));
+    } else {
+      for (let i = 1; i <= 10; i++) envLines.push(`OPENROUTER_API_KEY_${i}=ollama-local`);
+    }
+    const hfKey = process.env.HUGGINGFACE_API_KEY || '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';
+    envLines.push(`HUGGINGFACE_API_KEY=${hfKey}`);
+    fs.writeFileSync(path.join(projectDir, '.env.local'), envLines.join('\n'));
+    res.writeHead(200);
+    res.end(JSON.stringify({ success: true, keysCount: keys.length }));
+    return;
+  }
+
+  res.writeHead(404);
+  res.end(JSON.stringify({ error: 'Not found' }));
+}
+
+// ══════════════════════════════════════════════════════════════
+//   NEXUSAI LOYIHA TOPISH
+// ══════════════════════════════════════════════════════════════
+
 function findProject() {
-  const cfgs = ['next.config.js', 'next.config.ts', 'next.config.mjs'];
+  const cfgs = ['next.config.js','next.config.ts','next.config.mjs'];
   const cwd = process.cwd();
-  for (const c of cfgs) {
-    if (fs.existsSync(path.join(cwd, c))) return cwd;
-  }
+  if (cfgs.some(c => fs.existsSync(path.join(cwd, c)))) return cwd;
+
   const drives = ['E','D','C','F','G'];
-  const names = ['nexusai-team','NexusAi-team','NexusAI-team','nexus-team','nexusai'];
+  const names = ['nexusai-team','NexusAi-team','NexusAI-team','nexus-team','nexusai','NexusAI'];
   for (const d of drives) {
     for (const n of names) {
       const p = `${d}:\\${n}`;
@@ -170,56 +705,118 @@ function findProject() {
       } catch {}
     }
   }
+
+  // Install papkasini ham tekshir
+  const installDir = `C:\\NexusAI`;
+  if (fs.existsSync(installDir) && cfgs.some(c => fs.existsSync(path.join(installDir, c)))) {
+    return installDir;
+  }
+
   return null;
 }
 
-// ── .env.local yozish ──
+// ══════════════════════════════════════════════════════════════
+//   .env.local SOZLASH
+// ══════════════════════════════════════════════════════════════
+
 function setupEnv(dir) {
   const envPath = path.join(dir, '.env.local');
-  const content = [
-    'OPENROUTER_BASE_URL=http://localhost:11435/api/v1',
-    'OPENROUTER_API_KEY_1=ollama-local',
-    'OPENROUTER_API_KEY_2=ollama-local',
-    'OPENROUTER_API_KEY_3=ollama-local',
-  ].join('\n');
-  if (fs.existsSync(envPath)) {
-    const ex = fs.readFileSync(envPath, 'utf8');
-    if (ex.includes('ollama-local')) return;
-    fs.writeFileSync(envPath, content + '\n' + ex);
+  const keys = getAllKeys();
+  const lines = [
+    `OPENROUTER_BASE_URL=http://localhost:${PROXY_PORT}/api/v1`,
+  ];
+
+  if (keys.length > 0) {
+    keys.slice(0, 10).forEach((k, i) => lines.push(`OPENROUTER_API_KEY_${i+1}=${k}`));
   } else {
-    fs.writeFileSync(envPath, content);
+    for (let i = 1; i <= 10; i++) lines.push(`OPENROUTER_API_KEY_${i}=ollama-local`);
+  }
+
+  const hfKey = process.env.HUGGINGFACE_API_KEY || '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';
+  lines.push(`HUGGINGFACE_API_KEY=${hfKey}`);
+
+  // Mavjud .env.local dan boshqa env varlarni saqlab qolish
+  let extra = '';
+  if (fs.existsSync(envPath)) {
+    const existing = fs.readFileSync(envPath, 'utf8').split('\n');
+    const keep = existing.filter(l => {
+      const key = l.split('=')[0].trim();
+      return l.trim() && !l.startsWith('#') &&
+        !key.startsWith('OPENROUTER_') && key !== 'HUGGINGFACE_API_KEY';
+    });
+    extra = keep.join('\n');
   }
-  log('✅', '.env.local sozlandi', C.green);
+
+  const content = lines.join('\n') + (extra ? '\n' + extra : '');
+  fs.writeFileSync(envPath, content);
+  log('✅', `.env.local sozlandi (${keys.length} key)`, C.green);
 }
 
-// ── Next.js ishga tushirish ──
+// ══════════════════════════════════════════════════════════════
+//   NEXT.JS ISHGA TUSHIRISH
+// ══════════════════════════════════════════════════════════════
+
 function startNextJS(dir) {
   return new Promise(resolve => {
     setupEnv(dir);
+
     if (!fs.existsSync(path.join(dir, 'node_modules'))) {
       log('📦', 'npm install...', C.yellow);
-      execSync('npm install', { cwd: dir, stdio: 'inherit' });
+      try {
+        execSync('npm install', { cwd: dir, stdio: 'inherit' });
+      } catch (e) {
+        log('❌', `npm install xatosi: ${e.message}`, C.red);
+      }
     }
+
     log('🌐', 'NexusAI ishga tushmoqda...', C.cyan);
+    const env = {
+      ...process.env,
+      PORT: '3000',
+      OPENROUTER_BASE_URL: `http://localhost:${PROXY_PORT}/api/v1`,
+    };
+
+    // API keylarni ham environment ga qo'shamiz
+    const keys = getAllKeys();
+    keys.slice(0, 10).forEach((k, i) => {
+      env[`OPENROUTER_API_KEY_${i+1}`] = k;
+    });
+    if (keys.length === 0) {
+      for (let i = 1; i <= 10; i++) env[`OPENROUTER_API_KEY_${i}`] = 'ollama-local';
+    }
+
     const dev = spawn('npm', ['run', 'dev'], {
       cwd: dir, shell: true,
       stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, PORT: '3000', OPENROUTER_BASE_URL: 'http://localhost:11435/api/v1', OPENROUTER_API_KEY_1: 'ollama-local' },
+      env,
     });
+
+    let started = false;
     dev.stdout.on('data', d => {
       const t = d.toString();
-      if (t.includes('Ready') || t.includes('ready') || t.includes('localhost:3000')) {
+      process.stdout.write(C.dim + t + C.reset);
+      if (!started && (t.includes('Ready') || t.includes('ready') || t.includes('localhost:3000'))) {
+        started = true;
         log('✅', 'Sayt tayyor: http://localhost:3000', C.green);
         setTimeout(resolve, 500);
       }
     });
-    dev.on('error', e => log('❌', e.message, C.red));
-    setTimeout(resolve, 60000);
+    dev.stderr.on('data', d => {
+      const t = d.toString();
+      if (t.includes('Error') || t.includes('error')) {
+        process.stdout.write(C.red + t + C.reset);
+      }
+    });
+    dev.on('error', e => { log('❌', e.message, C.red); resolve(); });
+    setTimeout(() => { if (!started) resolve(); }, 90000);
   });
 }
 
-// ── MAIN ──
-async function main() {
+// ══════════════════════════════════════════════════════════════
+//   BANNER
+// ══════════════════════════════════════════════════════════════
+
+function showBanner() {
   console.log(`\n${C.bold}${C.cyan}
   ███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗ █████╗ ██╗
   ████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝██╔══██╗██║
@@ -227,39 +824,79 @@ async function main() {
   ██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║██╔══██║██║
   ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║██║  ██║██║
   ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝
-  ${C.reset}${C.dim}  TEAM v3.0 — 15 AI Agents${C.reset}\n`);
+  ${C.reset}${C.yellow}  AVG-NEXUS v4.0  —  NexusAI Local Proxy${C.reset}\n`);
+}
 
+// ══════════════════════════════════════════════════════════════
+//   MAIN
+// ══════════════════════════════════════════════════════════════
+
+async function main() {
+  ensureDataDir();
+  showBanner();
+
+  // 1. Ollama topish
   log('🔍', 'Ollama qidirilmoqda...', C.cyan);
   const ollamaPath = findOllama();
   if (!ollamaPath) {
     log('❌', 'Ollama topilmadi! https://ollama.com/download', C.red);
+    log('💡', 'Ollama o\'rnatib qayta ishga tushiring', C.yellow);
     process.exit(1);
   }
   log('✅', `Ollama: ${ollamaPath}`, C.green);
 
-  startOllama(ollamaPath);
-  await sleep(2000);
+  // 2. Ollama serve
+  await startOllama(ollamaPath);
 
+  // 3. Model topish
   log('🔍', 'AI model qidirilmoqda...', C.cyan);
   const model = findBestModel();
 
+  // 4. Proxy server
+  log('🔀', 'Proxy server ishga tushirilmoqda...', C.cyan);
   startProxy(model);
 
+  // 5. Admin server
+  startAdminServer(model);
+
+  // 6. Keys holati
+  const keys = getAllKeys();
+  if (keys.length > 0) {
+    log('🔑', `${keys.length} ta OpenRouter key topildi`, C.green);
+  } else {
+    log('🦙', 'API key yo\'q — faqat Ollama (offline rejim)', C.yellow);
+    log('💡', 'Key qo\'shish: avg-ai yoqing va /keys add sk-or-... bering', C.dim);
+  }
+
+  // 7. NexusAI loyiha
   log('🔍', 'NexusAI loyiha qidirilmoqda...', C.cyan);
   const dir = findProject();
   if (!dir) {
-    log('❌', 'NexusAI loyiha topilmadi!', C.red);
-    log('💡', 'nexusai-team papkasida turib avg-nexus bering', C.yellow);
-    process.exit(1);
+    log('⚠️', 'NexusAI loyiha topilmadi — faqat proxy ishlaydi', C.yellow);
+    log('💡', 'nexusai-team papkasida turib avg-nexus bering', C.dim);
+    log('', `\n${C.green}${C.bold}✅ Proxy tayyor: http://localhost:${PROXY_PORT}${C.reset}`, '');
+    log('', `${C.green}Admin API: http://localhost:${ADMIN_PORT}${C.reset}\n`, '');
+  } else {
+    log('✅', `Loyiha: ${dir}`, C.green);
+    await startNextJS(dir);
+    log('', `\n${C.bold}${C.green}🎉 NexusAI tayyor! http://localhost:3000${C.reset}`, '');
+    log('', `${C.dim}Proxy: :${PROXY_PORT}  Admin: :${ADMIN_PORT}  Ctrl+C to'xtatish${C.reset}\n`, '');
   }
-  log('✅', `Loyiha: ${dir}`, C.green);
 
-  await startNextJS(dir);
-
-  log('', `\n${C.bold}${C.green}🎉 NexusAI tayyor! http://localhost:3000${C.reset}\n`, '');
-  log('', `${C.dim}To'xtatish: Ctrl+C${C.reset}\n`, '');
+  // Chiqishni ushlab turish
+  process.on('SIGINT', () => {
+    log('👋', 'To\'xtatildi', C.yellow);
+    process.exit(0);
+  });
 
-  process.on('SIGINT', () => { log('👋', 'To\'xtatildi', C.yellow); process.exit(0); });
+  // Har 60 soniyada status
+  setInterval(() => {
+    const keys = getAllKeys();
+    const available = keys.filter(isAvailable).length;
+    if (keys.length > 0) {
+      log('📊', `Keys: ${available}/${keys.length} available | Uptime: ${Math.floor(process.uptime())}s`, C.dim);
+    }
+  }, 60000);
 }
 
-main().catch(e => { log('❌', e.message, C.red); process.exit(1); });
+main().catch(e => { log('❌', e.message, C.red); process.exit(1); });

package/package.json

@@ -1,26 +1,26 @@
-{
-  "name": "avg-nexus",
-  "version": "1.0.10",
-  "description": "Offline/Online proxy for NexusAI Team — runs with local Ollama",
-  "main": "bin/avg-nexus.js",
-  "type": "commonjs",
-  "bin": {
-    "avgnexus": "./bin/avg-nexus.js"
-  },
-  "scripts": {
-    "start": "node bin/avg-nexus.js"
-  },
-  "keywords": [
-    "ollama",
-    "openrouter",
-    "proxy",
-    "nexusai",
-    "offline",
-    "ai"
-  ],
-  "author": "avg1002",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "avg-nexus",
+  "version": "1.0.12",
+  "description": "NexusAI Local Proxy — Ollama + OpenRouter + Device API Manager",
+  "main": "bin/avg-nexus.js",
+  "type": "commonjs",
+  "bin": {
+    "avg-nexus": "bin/avg-nexus.js"
+  },
+  "scripts": {
+    "start": "node bin/avg-nexus.js"
+  },
+  "keywords": [
+    "ollama",
+    "openrouter",
+    "proxy",
+    "nexusai",
+    "offline",
+    "ai"
+  ],
+  "author": "avg1002",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}