neuroalpha 0.6.13 → 0.7.0

package/server/llm/local-engine.js

@@ -0,0 +1,843 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Автодиагностика железа ПК, установка и запуск локальной ИИ-модели для «Стратега» (llama.cpp llama-server + Qwen3 GGUF):
+//   • распознаёт дискретные GPU (NVIDIA CUDA, AMD/Intel Vulkan) и единую память Unified Memory на AMD Ryzen AI Max+ 395 / 495 и Apple Silicon;
+//   • хранит движок и веса строго в постоянной папке DATA_DIR/local-llm (переживает любые обновления npx neuroalpha@latest);
+//   • поддерживает докачку многогигабайтных .gguf файлов по HTTP Range, отображение прогресса через WebSocket и чистую остановку дочернего процесса.
+import fs from 'node:fs';
+import os from 'node:os';
+import net from 'node:net';
+import path from 'node:path';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DATA_DIR } from '../config.js';
+import { kvGet, kvSet } from '../db.js';
+import { hub } from '../hub.js';
+
+const execFileAsync = promisify(execFile);
+const GB = 1024 ** 3;
+const MB = 1024 ** 2;
+
+const LOCAL_ROOT = path.join(DATA_DIR, 'local-llm');
+const ENGINE_ROOT = path.join(LOCAL_ROOT, 'engine');
+const MODELS_DIR = path.join(LOCAL_ROOT, 'models');
+
+export const LOCAL_PROVIDER_ID = 'local_llama';
+
+export const LOCAL_MODEL_CATALOG = [
+  {
+    id: 'qwen3-4b',
+    label: 'Qwen3 4B (лёгкая · Q4_K_M)',
+    tier: 'light',
+    repo: 'Qwen/Qwen3-4B-GGUF',
+    file: 'Qwen3-4B-Q4_K_M.gguf',
+    sizeBytes: 2497280256,
+    sizeGb: 2.5,
+    minMemGb: 6,
+    minCpuRamGb: 10,
+    minDiskGb: 4.0,
+    desc: 'Компактная модель для базовых ПК и ноутбуков (от 6 ГБ видеопамяти или от 10–12 ГБ ОЗУ на процессоре).',
+  },
+  {
+    id: 'qwen3-8b',
+    label: 'Qwen3 8B (базовая · Q4_K_M)',
+    tier: 'basic',
+    repo: 'Qwen/Qwen3-8B-GGUF',
+    file: 'Qwen3-8B-Q4_K_M.gguf',
+    sizeBytes: 5027783488,
+    sizeGb: 5.0,
+    minMemGb: 8,
+    minCpuRamGb: 18,
+    minDiskGb: 7.0,
+    desc: 'Уверенный русский язык и вызов инструментов анализа счёта (GPU 8–11 ГБ или от 20 ГБ быстрой ОЗУ).',
+  },
+  {
+    id: 'qwen3-14b',
+    label: 'Qwen3 14B (оптимальная · Q4_K_M)',
+    tier: 'mid',
+    repo: 'Qwen/Qwen3-14B-GGUF',
+    file: 'Qwen3-14B-Q4_K_M.gguf',
+    sizeBytes: 9001752960,
+    sizeGb: 9.0,
+    minMemGb: 12,
+    minCpuRamGb: 30,
+    minDiskGb: 12.0,
+    desc: 'Глубокая аналитика портфеля и сделок для видеокарт 12–20 ГБ VRAM или 24 ГБ единой памяти.',
+  },
+  {
+    id: 'qwen3-30b-a3b',
+    label: 'Qwen3 30B-A3B MoE (быстрая профи · Q4_K_M)',
+    tier: 'high',
+    repo: 'Qwen/Qwen3-30B-A3B-GGUF',
+    file: 'Qwen3-30B-A3B-Q4_K_M.gguf',
+    sizeBytes: 18556685824,
+    sizeGb: 18.6,
+    minMemGb: 22,
+    minCpuRamGb: 44,
+    minDiskGb: 22.0,
+    desc: 'Быстрая экспертная MoE-модель (30B параметров, 3B активных на токен): идеальна для 24 ГБ VRAM и 64 ГБ AMD Ryzen AI Max+ 395/495.',
+  },
+  {
+    id: 'qwen3-32b',
+    label: 'Qwen3 32B Dense (плотная профи · Q4_K_M)',
+    tier: 'high_dense',
+    repo: 'Qwen/Qwen3-32B-GGUF',
+    file: 'Qwen3-32B-Q4_K_M.gguf',
+    sizeBytes: 19762149024,
+    sizeGb: 19.8,
+    minMemGb: 24,
+    minCpuRamGb: 48,
+    minDiskGb: 24.0,
+    desc: 'Полноразмерная плотная модель 32B повышенной точности рассуждений (от 24–32 ГБ VRAM / единой памяти).',
+  },
+  {
+    id: 'qwen3-next-80b-a3b',
+    label: 'Qwen3-Next 80B-A3B Instruct (Ультра · Q4_K_M)',
+    tier: 'ultra',
+    repo: 'Qwen/Qwen3-Next-80B-A3B-Instruct-GGUF',
+    file: 'Qwen3-Next-80B-A3B-Instruct-Q4_K_M.gguf',
+    sizeBytes: 48410988384,
+    sizeGb: 48.4,
+    minMemGb: 56,
+    minCpuRamGb: 92,
+    minDiskGb: 54.0,
+    desc: 'Флагман 80B MoE (активно 3B): максимальный уровень Стратега для станций AMD Ryzen AI Max+ 395 / 495 (96–128 ГБ единой памяти).',
+  },
+];
+
+let hwCache = { at: 0, data: null };
+let engineChild = null;
+let enginePort = 0;
+let activeLocalModelId = '';
+let activeBackend = '';
+let installAbort = null;
+
+let jobState = {
+  phase: 'idle', // idle | engine | model | starting | running | error
+  modelId: '',
+  backend: '',
+  percent: 0,
+  downloadedBytes: 0,
+  totalBytes: 0,
+  speedMbSec: 0,
+  etaSec: null,
+  message: '',
+  error: '',
+};
+
+let onActivatedCallback = null;
+export function setLocalModelReadyHook(fn) {
+  onActivatedCallback = fn;
+}
+
+function emitStatus() {
+  hub.emit({ type: 'localLlm:status', status: getLocalEngineQuickStatus() });
+}
+
+export function getLocalEngineQuickStatus() {
+  return {
+    running: Boolean(engineChild && !engineChild.killed && enginePort > 0),
+    port: enginePort,
+    activeModelId: activeLocalModelId,
+    activeBackend,
+    job: { ...jobState },
+  };
+}
+
+function round1(x) {
+  return Math.round((Number(x) || 0) * 10) / 10;
+}
+
+async function probeNvidiaGpu() {
+  try {
+    const { stdout } = await execFileAsync(
+      'nvidia-smi',
+      ['--query-gpu=name,memory.total', '--format=csv,noheader,nounits'],
+      { timeout: 3500, windowsHide: true },
+    );
+    const lines = String(stdout || '').trim().split(/\r?\n/).filter(Boolean);
+    if (!lines.length) return null;
+    let bestName = '';
+    let bestMb = 0;
+    for (const line of lines) {
+      const parts = line.split(',').map((s) => s.trim());
+      const mb = Number(parts[parts.length - 1]) || 0;
+      if (mb > bestMb) {
+        bestMb = mb;
+        bestName = parts.slice(0, -1).join(', ');
+      }
+    }
+    if (bestMb > 0) return { vendor: 'nvidia', name: bestName, vramGb: round1(bestMb / 1024) };
+  } catch { /* no nvidia-smi */ }
+  return null;
+}
+
+async function probeWindowsDisplayGpus() {
+  if (process.platform !== 'win32') return [];
+  const psScript = `
+$out = @()
+Get-ItemProperty -Path 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Class\\{4d36e968-e325-11ce-bfc1-08002be10318}\\0*' -ErrorAction SilentlyContinue | ForEach-Object {
+  $desc = $_.'DriverDesc'
+  $mem = $_.'HardwareInformation.qwMemorySize'
+  if (-not $mem) { $mem = $_.'HardwareInformation.MemorySize' }
+  if ($desc) { $out += [PSCustomObject]@{ Name = [string]$desc; Bytes = [int64]($mem -as [int64]) } }
+}
+if ($out.Count -eq 0) {
+  Get-CimInstance Win32_VideoController -ErrorAction SilentlyContinue | ForEach-Object {
+    $out += [PSCustomObject]@{ Name = [string]$_.Name; Bytes = [int64]$_.AdapterRAM }
+  }
+}
+$out | ConvertTo-Json -Compress
+`.trim();
+  try {
+    const { stdout } = await execFileAsync(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command', psScript],
+      { timeout: 4500, windowsHide: true },
+    );
+    const raw = String(stdout || '').trim();
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    const arr = Array.isArray(parsed) ? parsed : [parsed];
+    return arr
+      .filter((x) => x?.Name && !/microsoft basic|remote desktop|parsec|virtual/i.test(x.Name))
+      .map((x) => ({ name: String(x.Name).trim(), vramGb: round1(Math.max(0, Number(x.Bytes) || 0) / GB) }));
+  } catch {
+    return [];
+  }
+}
+
+async function probeLinuxGpus() {
+  if (process.platform !== 'linux') return [];
+  const gpus = [];
+  try {
+    const drmDir = '/sys/class/drm';
+    if (fs.existsSync(drmDir)) {
+      for (const entry of fs.readdirSync(drmDir)) {
+        if (!/^card\d+$/.test(entry)) continue;
+        const vramPath = path.join(drmDir, entry, 'device', 'mem_info_vram_total');
+        if (fs.existsSync(vramPath)) {
+          const bytes = Number(fs.readFileSync(vramPath, 'utf8').trim()) || 0;
+          gpus.push({ name: `AMD GPU (${entry})`, vramGb: round1(bytes / GB) });
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return gpus;
+}
+
+async function probeOllamaLocal() {
+  try {
+    const r = await fetch('http://127.0.0.1:11434/api/tags', { signal: AbortSignal.timeout(1200) });
+    if (!r.ok) return { running: false, models: [] };
+    const j = await r.json().catch(() => ({}));
+    const models = (j.models || []).map((m) => String(m.name || '').trim()).filter(Boolean);
+    return { running: true, models };
+  } catch {
+    return { running: false, models: [] };
+  }
+}
+
+export async function detectLocalHardware({ refresh = false } = {}) {
+  if (!refresh && hwCache.data && Date.now() - hwCache.at < 60000) {
+    return hwCache.data;
+  }
+  const cpus = os.cpus() || [];
+  const cpuModel = String(cpus[0]?.model || 'CPU').trim();
+  const cpuCores = cpus.length || 4;
+  const totalRamGb = round1(os.totalmem() / GB);
+  const freeRamGb = round1(os.freemem() / GB);
+
+  let freeDiskGb = 50;
+  try {
+    const st = fs.statfsSync(DATA_DIR);
+    freeDiskGb = round1((Number(st.bavail) * Number(st.bsize)) / GB);
+  } catch { /* fallback */ }
+
+  let gpuName = '';
+  let gpuVendor = 'none';
+  let dedicatedVramGb = 0;
+  let isUnifiedMemory = false;
+  let isRyzenAiMax = false;
+  let usableVramGb = 0;
+  let recommendedBackend = 'cpu';
+  let availableBackends = ['cpu'];
+
+  const ryzenAiMaxCpu = /ryzen\s+ai\s+max\+?\s*(3\d\d|4\d\d)/i.test(cpuModel);
+
+  if (process.platform === 'darwin' && process.arch === 'arm64') {
+    gpuVendor = 'apple';
+    gpuName = `${cpuModel} (Unified Memory)`;
+    isUnifiedMemory = true;
+    usableVramGb = round1(totalRamGb * 0.75);
+    recommendedBackend = 'metal';
+    availableBackends = ['metal', 'cpu'];
+  } else {
+    const nv = await probeNvidiaGpu();
+    const winGpus = nv ? [] : await probeWindowsDisplayGpus();
+    const linGpus = nv || process.platform !== 'linux' ? [] : await probeLinuxGpus();
+    const allOther = [...winGpus, ...linGpus].sort((a, b) => b.vramGb - a.vramGb);
+    const radeonStrixGpu = allOther.find((g) => /radeon\s+80[56]0s|gfx1151|strix\s*halo|ryzen\s+ai\s+max/i.test(g.name));
+
+    if (ryzenAiMaxCpu || radeonStrixGpu) {
+      gpuVendor = 'amd';
+      isUnifiedMemory = true;
+      isRyzenAiMax = true;
+      gpuName = radeonStrixGpu?.name
+        ? `${radeonStrixGpu.name} · Unified Memory (${totalRamGb} ГБ)`
+        : `${cpuModel} · Radeon Unified Memory`;
+      dedicatedVramGb = radeonStrixGpu?.vramGb || 0;
+      usableVramGb = round1(Math.max(dedicatedVramGb, totalRamGb * 0.75));
+      recommendedBackend = 'vulkan';
+      availableBackends = ['vulkan', 'rocm', 'cpu'];
+    } else if (nv && nv.vramGb >= 4) {
+      gpuVendor = 'nvidia';
+      gpuName = nv.name;
+      dedicatedVramGb = nv.vramGb;
+      usableVramGb = nv.vramGb;
+      recommendedBackend = 'cuda';
+      availableBackends = ['cuda', 'vulkan', 'cpu'];
+    } else if (allOther.length > 0 && allOther[0].vramGb >= 4) {
+      const top = allOther[0];
+      gpuVendor = /amd|radeon/i.test(top.name) ? 'amd' : (/intel|arc/i.test(top.name) ? 'intel' : 'gpu');
+      gpuName = top.name;
+      dedicatedVramGb = top.vramGb;
+      usableVramGb = top.vramGb;
+      recommendedBackend = 'vulkan';
+      availableBackends = gpuVendor === 'amd' ? ['vulkan', 'rocm', 'cpu'] : ['vulkan', 'cpu'];
+    } else if (allOther.length > 0) {
+      gpuName = allOther[0].name;
+      dedicatedVramGb = allOther[0].vramGb;
+      availableBackends = ['cpu', 'vulkan'];
+    }
+  }
+
+  const ollama = await probeOllamaLocal();
+  const canInstall = usableVramGb >= 6 || totalRamGb >= 10;
+  const reasonBlocked = !canInstall
+    ? `Недостаточно ресурсов для локальной ИИ-модели (ОЗУ ${totalRamGb} ГБ, GPU ${usableVramGb} ГБ). Используйте встроенный облачный прокси НейроАльфа или внешний API.`
+    : (freeDiskGb < 4 ? `Недостаточно свободного места на диске (${freeDiskGb} ГБ свободно в ${DATA_DIR}).` : '');
+
+  const data = {
+    platform: process.platform,
+    arch: process.arch,
+    cpuModel,
+    cpuCores,
+    totalRamGb,
+    freeRamGb,
+    freeDiskGb,
+    gpuVendor,
+    gpuName,
+    dedicatedVramGb,
+    usableVramGb,
+    isUnifiedMemory,
+    isRyzenAiMax,
+    recommendedBackend,
+    availableBackends,
+    canInstall: Boolean(canInstall && freeDiskGb >= 4),
+    reasonBlocked,
+    ollama,
+    modelsDir: MODELS_DIR,
+  };
+  hwCache = { at: Date.now(), data };
+  return data;
+}
+
+export async function getLocalEngineFullState({ refresh = false } = {}) {
+  const hw = await detectLocalHardware({ refresh });
+  fs.mkdirSync(MODELS_DIR, { recursive: true });
+
+  const models = LOCAL_MODEL_CATALOG.map((m) => {
+    const fullPath = path.join(MODELS_DIR, m.file);
+    const installed = fs.existsSync(fullPath) && fs.statSync(fullPath).size >= m.sizeBytes * 0.95;
+    const fitsGpu = hw.usableVramGb >= m.minMemGb;
+    const fitsCpu = hw.totalRamGb >= m.minCpuRamGb;
+    const fitsDisk = installed || hw.freeDiskGb >= m.minDiskGb;
+    const compatible = (fitsGpu || fitsCpu) && fitsDisk;
+    return {
+      ...m,
+      installed,
+      fitsGpu,
+      fitsCpu,
+      fitsDisk,
+      compatible,
+      accelMode: fitsGpu ? (hw.isUnifiedMemory ? 'Unified GPU (Vulkan/Metal)' : 'GPU') : (fitsCpu ? 'CPU + RAM' : 'Недостаточно памяти'),
+    };
+  });
+
+  // Выбираем самую сильную совместимую модель (предпочитая qwen3-30b-a3b перед dense 32b на 24–48 ГБ из-за 3× более высокой скорости MoE)
+  let recommendedModelId = '';
+  const priorityOrder = ['qwen3-next-80b-a3b', 'qwen3-30b-a3b', 'qwen3-14b', 'qwen3-8b', 'qwen3-4b'];
+  for (const id of priorityOrder) {
+    const hit = models.find((m) => m.id === id);
+    if (hit && hit.compatible && (hit.fitsGpu || hw.usableVramGb < 6)) {
+      recommendedModelId = id;
+      break;
+    }
+  }
+  if (!recommendedModelId) {
+    const anyCompat = [...models].reverse().find((m) => m.compatible);
+    if (anyCompat) recommendedModelId = anyCompat.id;
+  }
+
+  return {
+    hardware: hw,
+    recommendedModelId,
+    models,
+    ...getLocalEngineQuickStatus(),
+  };
+}
+
+// ---------- Скачивание бинарника llama-server из официальных релизов ggml-org/llama.cpp ----------
+function findExecutableRecursive(dir, targetName) {
+  if (!fs.existsSync(dir)) return '';
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      const sub = findExecutableRecursive(full, targetName);
+      if (sub) return sub;
+    } else if (e.name.toLowerCase() === targetName.toLowerCase()) {
+      return full;
+    }
+  }
+  return '';
+}
+
+function getInstalledServerBinary(backend) {
+  const exeName = process.platform === 'win32' ? 'llama-server.exe' : 'llama-server';
+  return findExecutableRecursive(path.join(ENGINE_ROOT, backend), exeName);
+}
+
+async function downloadFileWithResume(url, destPath, { signal, onProgress, label = '' } = {}) {
+  const partPath = `${destPath}.part`;
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  let startByte = fs.existsSync(partPath) ? fs.statSync(partPath).size : 0;
+
+  const headers = { 'User-Agent': 'NeuroAlpha-LocalLLM/0.7' };
+  if (startByte > 0) headers.Range = `bytes=${startByte}-`;
+
+  const res = await fetch(url, { headers, redirect: 'follow', signal });
+  if (res.status === 416) {
+    // Уже скачан полностью
+    fs.renameSync(partPath, destPath);
+    return destPath;
+  }
+  if (!res.ok) {
+    throw new Error(`Ошибка загрузки ${label || path.basename(destPath)}: HTTP ${res.status}`);
+  }
+  const isPartial = res.status === 206;
+  if (!isPartial) startByte = 0;
+
+  const contentLen = Number(res.headers.get('content-length')) || 0;
+  const totalBytes = contentLen > 0 ? startByte + contentLen : 0;
+  const out = fs.createWriteStream(partPath, { flags: isPartial ? 'a' : 'w' });
+
+  let downloaded = startByte;
+  let lastEmitAt = 0;
+  let speedWindowBytes = 0;
+  let speedWindowStart = Date.now();
+  let speedMbSec = 0;
+
+  try {
+    for await (const chunk of res.body) {
+      if (signal?.aborted) throw Object.assign(new Error('Загрузка отменена пользователем'), { name: 'AbortError' });
+      if (!out.write(chunk)) {
+        await new Promise((r) => out.once('drain', r));
+      }
+      downloaded += chunk.length;
+      speedWindowBytes += chunk.length;
+      const now = Date.now();
+      if (now - lastEmitAt >= 400) {
+        const dt = (now - speedWindowStart) / 1000;
+        if (dt >= 0.8) {
+          speedMbSec = round1((speedWindowBytes / MB) / dt);
+          speedWindowBytes = 0;
+          speedWindowStart = now;
+        }
+        lastEmitAt = now;
+        if (onProgress) onProgress({ downloaded, totalBytes, speedMbSec });
+      }
+    }
+    await new Promise((resolve, reject) => {
+      out.end((err) => (err ? reject(err) : resolve()));
+    });
+    fs.renameSync(partPath, destPath);
+    return destPath;
+  } catch (e) {
+    try { out.destroy(); } catch { /* ignore */ }
+    throw e;
+  }
+}
+
+async function ensureLlamaServerBinary(backend, { signal } = {}) {
+  const existing = getInstalledServerBinary(backend);
+  if (existing) return existing;
+
+  jobState = { ...jobState, phase: 'engine', percent: 0, message: `Поиск актуальной сборки движка llama.cpp (${backend})…` };
+  emitStatus();
+
+  const relRes = await fetch('https://api.github.com/repos/ggml-org/llama.cpp/releases?per_page=8', {
+    headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'NeuroAlpha-LocalLLM/0.7' },
+    signal,
+  });
+  if (!relRes.ok) throw new Error(`Не удалось получить список релизов llama.cpp (HTTP ${relRes.status})`);
+  const releases = await relRes.json();
+  const rel = (releases || []).find((r) => Array.isArray(r.assets) && r.assets.some((a) => /^llama-.*-bin-/.test(a.name)));
+  if (!rel) throw new Error('Не найден бинарный релиз движка llama.cpp');
+
+  const assets = rel.assets || [];
+  const plat = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+
+  const pickAsset = (rxList) => {
+    for (const rx of rxList) {
+      const hit = assets.find((a) => rx.test(a.name));
+      if (hit) return hit;
+    }
+    return null;
+  };
+
+  const toDownload = [];
+  if (plat === 'win32') {
+    if (backend === 'vulkan') {
+      const a = pickAsset([new RegExp(`^llama-.*-bin-win-vulkan-${arch}\\.zip$`, 'i')]);
+      if (a) toDownload.push(a);
+    } else if (backend === 'rocm') {
+      const a = pickAsset([/^llama-.*-bin-win-rocm-.*-x64\.zip$/i, /^llama-.*-bin-win-hip-radeon-x64\.zip$/i]);
+      if (a) toDownload.push(a);
+    } else if (backend === 'cuda') {
+      const a = pickAsset([/^llama-.*-bin-win-cuda-12\..*-x64\.zip$/i, /^llama-.*-bin-win-cuda-.*-x64\.zip$/i]);
+      const rt = pickAsset([/^cudart-llama-.*win-cuda-12\..*-x64\.zip$/i, /^cudart-llama-.*win-cuda-.*-x64\.zip$/i]);
+      if (a) toDownload.push(a);
+      if (rt) toDownload.push(rt);
+    }
+    if (!toDownload.length) {
+      const cpuAsset = pickAsset([new RegExp(`^llama-.*-bin-win-cpu-${arch}\\.zip$`, 'i')]);
+      if (cpuAsset) toDownload.push(cpuAsset);
+    }
+  } else if (plat === 'darwin') {
+    const a = pickAsset([new RegExp(`^llama-.*-bin-macos-${arch}\\.tar\\.gz$`, 'i')]);
+    if (a) toDownload.push(a);
+  } else {
+    if (backend === 'vulkan') {
+      const a = pickAsset([new RegExp(`^llama-.*-bin-ubuntu-vulkan-${arch}\\.tar\\.gz$`, 'i')]);
+      if (a) toDownload.push(a);
+    } else if (backend === 'rocm') {
+      const a = pickAsset([/^llama-.*-bin-ubuntu-rocm-.*-x64\.tar\.gz$/i]);
+      if (a) toDownload.push(a);
+    } else if (backend === 'cuda') {
+      const a = pickAsset([/^llama-.*-bin-ubuntu-cuda-12\..*-x64\.tar\.gz$/i, /^llama-.*-bin-ubuntu-cuda-.*-x64\.tar\.gz$/i]);
+      if (a) toDownload.push(a);
+    }
+    if (!toDownload.length) {
+      const cpuAsset = pickAsset([new RegExp(`^llama-.*-bin-ubuntu-${arch}\\.tar\\.gz$`, 'i')]);
+      if (cpuAsset) toDownload.push(cpuAsset);
+    }
+  }
+
+  if (!toDownload.length) {
+    throw new Error(`Нет готовой сборки llama-server под платформу ${plat}/${arch} (${backend})`);
+  }
+
+  const targetDir = path.join(ENGINE_ROOT, backend);
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  for (const asset of toDownload) {
+    const archivePath = path.join(targetDir, asset.name);
+    jobState = { ...jobState, phase: 'engine', message: `Загрузка движка ${asset.name}…` };
+    emitStatus();
+    await downloadFileWithResume(asset.browser_download_url, archivePath, {
+      signal,
+      label: asset.name,
+      onProgress: ({ downloaded, totalBytes, speedMbSec }) => {
+        jobState = {
+          ...jobState,
+          phase: 'engine',
+          downloadedBytes: downloaded,
+          totalBytes: totalBytes || asset.size || 0,
+          speedMbSec,
+          percent: totalBytes > 0 ? Math.min(99, Math.round((downloaded / totalBytes) * 100)) : 0,
+          message: `Загрузка движка ИИ (${backend}): ${asset.name}`,
+        };
+        emitStatus();
+      },
+    });
+
+    jobState = { ...jobState, message: `Распаковка движка ${asset.name}…` };
+    emitStatus();
+    await execFileAsync('tar', ['-xf', archivePath, '-C', targetDir], { timeout: 90000, windowsHide: true });
+    try { fs.unlinkSync(archivePath); } catch { /* ignore */ }
+  }
+
+  const binPath = getInstalledServerBinary(backend);
+  if (!binPath) throw new Error('После распаковки не найден исполняемый файл llama-server');
+  if (process.platform !== 'win32') {
+    try { fs.chmodSync(binPath, 0o755); } catch { /* ignore */ }
+  }
+  return binPath;
+}
+
+function findFreeLocalPort(preferred = 18089) {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.unref();
+    srv.on('error', () => {
+      const fallback = net.createServer();
+      fallback.unref();
+      fallback.on('error', reject);
+      fallback.listen(0, '127.0.0.1', () => {
+        const p = fallback.address().port;
+        fallback.close(() => resolve(p));
+      });
+    });
+    srv.listen(preferred, '127.0.0.1', () => {
+      const p = srv.address().port;
+      srv.close(() => resolve(p));
+    });
+  });
+}
+
+export function stopLocalEngine() {
+  if (engineChild) {
+    try { engineChild.kill(); } catch { /* ignore */ }
+    engineChild = null;
+  }
+  enginePort = 0;
+  activeLocalModelId = '';
+  activeBackend = '';
+  if (jobState.phase === 'running' || jobState.phase === 'starting') {
+    jobState = { phase: 'idle', modelId: '', backend: '', percent: 0, downloadedBytes: 0, totalBytes: 0, speedMbSec: 0, etaSec: null, message: '', error: '' };
+  }
+  kvSet('localLlmAutoStart', null);
+  emitStatus();
+}
+
+process.on('exit', () => {
+  if (engineChild) {
+    try { engineChild.kill(); } catch { /* ignore */ }
+  }
+});
+
+export async function startLocalEngine({ modelId, backend = '' } = {}) {
+  const model = LOCAL_MODEL_CATALOG.find((m) => m.id === modelId);
+  if (!model) throw new Error('Неизвестная модель локального ИИ');
+  const modelPath = path.join(MODELS_DIR, model.file);
+  if (!fs.existsSync(modelPath)) {
+    throw new Error(`Файл весов ${model.file} ещё не скачан`);
+  }
+
+  const hw = await detectLocalHardware();
+  const chosenBackend = backend || kvGet('localLlmBackend') || hw.recommendedBackend || 'cpu';
+  const binPath = await ensureLlamaServerBinary(chosenBackend);
+
+  if (engineChild) {
+    try { engineChild.kill(); } catch { /* ignore */ }
+    engineChild = null;
+    await new Promise((r) => setTimeout(r, 300));
+  }
+
+  const port = await findFreeLocalPort(18089);
+  const ngl = chosenBackend === 'cpu' ? '0' : '99';
+  const ctxSize = model.tier === 'ultra' || model.tier === 'high' ? '24576' : '16384';
+  const args = [
+    '-m', modelPath,
+    '--alias', model.id,
+    '--host', '127.0.0.1',
+    '--port', String(port),
+    '--jinja',
+    '-ngl', ngl,
+    '-c', ctxSize,
+  ];
+
+  jobState = {
+    phase: 'starting',
+    modelId: model.id,
+    backend: chosenBackend,
+    percent: 100,
+    downloadedBytes: model.sizeBytes,
+    totalBytes: model.sizeBytes,
+    speedMbSec: 0,
+    etaSec: 0,
+    message: `Запуск локальной модели ${model.label} (${chosenBackend})…`,
+    error: '',
+  };
+  emitStatus();
+
+  const child = spawn(binPath, args, {
+    cwd: path.dirname(binPath),
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+
+  let exitedEarly = false;
+  child.once('exit', () => {
+    exitedEarly = true;
+    if (engineChild === child) {
+      engineChild = null;
+      enginePort = 0;
+      activeLocalModelId = '';
+      emitStatus();
+    }
+  });
+
+  const healthUrl = `http://127.0.0.1:${port}/health`;
+  const deadline = Date.now() + 90000;
+  let ready = false;
+  while (Date.now() < deadline && !exitedEarly) {
+    try {
+      const r = await fetch(healthUrl, { signal: AbortSignal.timeout(1500) });
+      if (r.ok) { ready = true; break; }
+    } catch { /* loading weights into VRAM/UMA */ }
+    await new Promise((r) => setTimeout(r, 700));
+  }
+
+  if (!ready) {
+    try { child.kill(); } catch { /* ignore */ }
+    jobState = { ...jobState, phase: 'error', error: 'Локальный сервер llama-server не вышел на готовность (проверьте свободный объём памяти или выберите более лёгкую модель)' };
+    emitStatus();
+    throw new Error(jobState.error);
+  }
+
+  engineChild = child;
+  enginePort = port;
+  activeLocalModelId = model.id;
+  activeBackend = chosenBackend;
+  kvSet('localLlmBackend', chosenBackend);
+  kvSet('localLlmAutoStart', { modelId: model.id, backend: chosenBackend });
+
+  jobState = {
+    phase: 'running',
+    modelId: model.id,
+    backend: chosenBackend,
+    percent: 100,
+    downloadedBytes: model.sizeBytes,
+    totalBytes: model.sizeBytes,
+    speedMbSec: 0,
+    etaSec: 0,
+    message: `Локальная модель ${model.label} запущена на 127.0.0.1:${port}`,
+    error: '',
+  };
+
+  if (onActivatedCallback) {
+    onActivatedCallback({
+      port,
+      modelId: model.id,
+      label: model.label,
+      backend: chosenBackend,
+    });
+  }
+  emitStatus();
+  return getLocalEngineQuickStatus();
+}
+
+export function startLocalModelInstall({ modelId, backend = '' } = {}) {
+  if (jobState.phase === 'engine' || jobState.phase === 'model' || jobState.phase === 'starting') {
+    throw new Error('Установка локальной модели уже выполняется');
+  }
+  const model = LOCAL_MODEL_CATALOG.find((m) => m.id === modelId);
+  if (!model) throw new Error('Выберите модель из каталога');
+
+  const ctrl = new AbortController();
+  installAbort = ctrl;
+
+  jobState = {
+    phase: 'engine',
+    modelId: model.id,
+    backend: backend || '',
+    percent: 0,
+    downloadedBytes: 0,
+    totalBytes: model.sizeBytes,
+    speedMbSec: 0,
+    etaSec: null,
+    message: 'Подготовка к установке локальной модели…',
+    error: '',
+  };
+  emitStatus();
+
+  (async () => {
+    try {
+      const hw = await detectLocalHardware({ refresh: true });
+      const chosenBackend = backend || hw.recommendedBackend || 'cpu';
+      jobState.backend = chosenBackend;
+
+      await ensureLlamaServerBinary(chosenBackend, { signal: ctrl.signal });
+
+      const destModelPath = path.join(MODELS_DIR, model.file);
+      const alreadyHasModel = fs.existsSync(destModelPath) && fs.statSync(destModelPath).size >= model.sizeBytes * 0.95;
+      if (!alreadyHasModel) {
+        if (hw.freeDiskGb < model.minDiskGb) {
+          throw new Error(`Недостаточно свободного места на диске: нужно ${model.minDiskGb} ГБ, доступно ${hw.freeDiskGb} ГБ`);
+        }
+        const hfUrl = `https://huggingface.co/${model.repo}/resolve/main/${model.file}?download=true`;
+        await downloadFileWithResume(hfUrl, destModelPath, {
+          signal: ctrl.signal,
+          label: model.file,
+          onProgress: ({ downloaded, totalBytes, speedMbSec }) => {
+            const tot = totalBytes || model.sizeBytes;
+            const remBytes = Math.max(0, tot - downloaded);
+            const etaSec = speedMbSec > 0.1 ? Math.round((remBytes / MB) / speedMbSec) : null;
+            jobState = {
+              phase: 'model',
+              modelId: model.id,
+              backend: chosenBackend,
+              percent: tot > 0 ? Math.min(99, Math.round((downloaded / tot) * 100)) : 0,
+              downloadedBytes: downloaded,
+              totalBytes: tot,
+              speedMbSec,
+              etaSec,
+              message: `Скачивание весов ${model.label}`,
+              error: '',
+            };
+            emitStatus();
+          },
+        });
+      }
+
+      await startLocalEngine({ modelId: model.id, backend: chosenBackend });
+    } catch (e) {
+      if (e.name === 'AbortError') {
+        jobState = { phase: 'idle', modelId: '', backend: '', percent: 0, downloadedBytes: 0, totalBytes: 0, speedMbSec: 0, etaSec: null, message: 'Загрузка приостановлена (можно продолжить с того же места)', error: '' };
+      } else {
+        jobState = { ...jobState, phase: 'error', error: e.message || String(e) };
+      }
+      emitStatus();
+    } finally {
+      if (installAbort === ctrl) installAbort = null;
+    }
+  })();
+
+  return getLocalEngineQuickStatus();
+}
+
+export function cancelLocalModelInstall() {
+  if (installAbort) {
+    installAbort.abort();
+    installAbort = null;
+  }
+  return getLocalEngineQuickStatus();
+}
+
+export function deleteLocalModel(modelId) {
+  const model = LOCAL_MODEL_CATALOG.find((m) => m.id === modelId);
+  if (!model) throw new Error('Модель не найдена');
+  if (activeLocalModelId === model.id) {
+    stopLocalEngine();
+  }
+  for (const p of [path.join(MODELS_DIR, model.file), path.join(MODELS_DIR, `${model.file}.part`)]) {
+    if (fs.existsSync(p)) {
+      try { fs.unlinkSync(p); } catch { /* ignore */ }
+    }
+  }
+  return { ok: true };
+}
+
+export function resumeSavedLocalEngineOnStartup() {
+  const saved = kvGet('localLlmAutoStart');
+  if (!saved?.modelId) return;
+  const model = LOCAL_MODEL_CATALOG.find((m) => m.id === saved.modelId);
+  if (!model) return;
+  const fullPath = path.join(MODELS_DIR, model.file);
+  if (!fs.existsSync(fullPath)) return;
+  setImmediate(() => {
+    startLocalEngine({ modelId: saved.modelId, backend: saved.backend || '' }).catch(() => {});
+  });
+}