beast-agent 2.12.0 → 2.14.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "2.12.0",
+    "version": "2.14.0",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",

package/src/agent/android.js

@@ -0,0 +1,265 @@
+'use strict';
+
+/* ---------- ANDROID EMÜLATÖR (İSTEĞE BAĞLI — Beast Code mobil önizleme) ----------
+   Ayarlardan (Kurulum) görünür; KUR denince arka planda HAFİF set kurar:
+     JDK 17 (winget, java yoksa) + Android cmdline-tools (~150MB) +
+     platform-tools/emulator + 1 sistem imajı + 1 AVD ("Beast").
+   SDK'yı standarda yerleştirir: %LOCALAPPDATA%\Android\Sdk (Android Studio ile
+   paylaşımlı konum — kullanıcıda zaten varsa KURULUM YAPMAZ, onu kullanır).
+   Beast Code preview akışı: AVD varsa ajan `npx expo start --android` ile
+   uygulamayı emülatörde açar (expo AVD'yi adb üzerinden kendisi bulur). */
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { emitInstallProgress } = require('./progressbus');
+
+const SDK_DIR = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'Android', 'Sdk');
+const CMDTOOLS_URL = 'https://dl.google.com/android/repository/commandlinetools-win-11076708_latest.zip';
+const SYS_IMAGE = 'system-images;android-34;google_apis;x86_64';
+const AVD_NAME = 'Beast';
+
+const state = {
+  installing: false,
+  installFailed: false,
+  installError: '',
+  stage: '',
+  booting: false,
+};
+
+function sdkCandidates() {
+  const list = [];
+  for (const v of [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT]) {
+    if (v && fs.existsSync(v)) list.push(path.resolve(String(v)));
+  }
+  list.push(SDK_DIR);
+  return list.filter((p) => fs.existsSync(p));
+}
+
+function findSdk(rel, name) {
+  for (const sdk of sdkCandidates()) {
+    const p = path.join(sdk, ...rel.split('/'), name);
+    if (fs.existsSync(p)) return p;
+  }
+  /* PATH'te ara (kullanıcı elle kurduysa) */
+  try {
+    const out = String(execSync(`where ${name}`, { timeout: 5000, stdio: 'pipe', encoding: 'utf8', windowsHide: true }));
+    const first = out.split(/\r?\n/).find(Boolean);
+    if (first) return String(first).trim();
+  } catch {}
+  return '';
+}
+
+function findAdb() { return findSdk('platform-tools', 'adb.exe'); }
+
+function findEmulator() { return findSdk('emulator', 'emulator.exe'); }
+
+function javaOk() {
+  try {
+    const out = String(execSync('java -version 2>&1', { timeout: 6000, stdio: 'pipe', encoding: 'utf8', windowsHide: true }));
+    const m = /version "?(\d+)/.exec(out);
+    return m ? Number(m[1]) >= 17 : false;
+  } catch {
+    return false;
+  }
+}
+
+async function listAvds() {
+  const emu = findEmulator();
+  if (!emu) return [];
+  try {
+    const out = String(execSync(`"${emu}" -list-avds`, { timeout: 10000, stdio: 'pipe', encoding: 'utf8', windowsHide: true }));
+    return out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function probe() {
+  const adb = findAdb();
+  const emu = findEmulator();
+  return {
+    sdk: !!(adb && emu),
+    sdkPath: sdkCandidates()[0] || '',
+    adb,
+    emulator: emu,
+    installing: state.installing,
+    failed: state.installFailed,
+    error: state.installError,
+    booting: state.booting,
+  };
+}
+
+/* ---------- ARKA PLAN KURULUM ----------
+   Aşamalar (progress bus 'android'): 1 java → 2 cmdline-tools → 3 sdk paketleri
+   (en ağır: ~1.4GB) → 4 AVD. Yarıda kalırsa idempotent: yeniden KUR kaldığından değil
+   baştan ama varolan parçaları atlar (licenses/paket kontrolü). */
+function autoInstall() {
+  if (state.installing) return { ok: true, installing: true };
+  if (probe().adb && probe().emu) return { ok: true, already: true };
+  state.installing = true;
+  state.installFailed = false;
+  state.installError = '';
+  runInstall().catch((e) => {
+    state.installing = false;
+    state.installFailed = true;
+    state.installError = String((e && e.message) || e).slice(0, 160);
+  });
+  return { ok: true, installing: true };
+}
+
+/* .bat çağırıcı: Node güvenlik yaması (CVE-2024-27980) .bat/.cmd'yi shell'siz
+   spawn etmeyi EINVAL'le reddeder — cmd.exe /c üzerinden güvenli çağrı */
+function spawnBat(bat, args, opts = {}) {
+  const cmdline = ['"' + bat + '"']
+    .concat(args.map((a) => (/[\s;&|^<>(),!%]/.test(a) ? '"' + a + '"' : a)))
+    .join(' ');
+  return spawn('cmd.exe', ['/d', '/s', '/c', cmdline], { windowsHide: true, ...opts.spawnOpts });
+}
+
+/* .bat çağırıcı (GÜVENLİ PATİKA): Node .bat'i shell'siz spawn etmeyi EINVAL'le
+   reddeder; cmd.exe'ye args dizisiyle geçmek de tırnak/redirect kaçışında kırılır.
+   ÇÖZÜM: geçici wrapper .bat YAZ (redirect + tırnaklar cmd'nin içine kalır),
+   wrapper'ı tek tırnaklı /c ile çalıştır. */
+let _batSeq = 0;
+function runBat(bat, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const inner = ['"' + bat + '"']
+      .concat(args.map((a) => (/[\s;&|^<>(),!%]/.test(a) ? '"' + a + '"' : a)))
+      .join(' ') + (opts.redirect ? ' < "' + opts.redirect + '"' : '');
+    const wrapper = path.join(os.tmpdir(), 'beast-sdk-' + Date.now() + '-' + (++_batSeq) + '.bat');
+    fs.writeFileSync(wrapper, '@echo off\r\n' + inner + '\r\nexit /b %ERRORLEVEL%\r\n', 'utf8');
+    /* wrapper'a tüm tırnak/redirect işi bırakılır — .bat spawn için Node shell:true ister */
+    const proc = spawn(wrapper, [], { windowsHide: true, shell: true, ...opts.spawnOpts });
+    let out = '';
+    proc.stdout.on('data', (c) => { out += String(c); opts.onData && opts.onData(String(c)); });
+    proc.stderr.on('data', (c) => { out += String(c); });
+    proc.on('close', (code) => {
+      try { fs.unlinkSync(wrapper); } catch {}
+      (code === 0 ? resolve : reject)(code === 0 ? out : new Error(opts.tag + ' exit ' + code + (out ? ' :: ' + out.slice(-300) : '')));
+    });
+    proc.on('error', (e) => {
+      try { fs.unlinkSync(wrapper); } catch {}
+      reject(e);
+    });
+  });
+}
+
+async function runInstall() {
+  const stage = (pct) => { try { emitInstallProgress('android', { pct }); } catch {} };
+
+  /* 1) JDK 17 (sdkmanager şartı) — java yoksa winget ile */
+  stage(3);
+  if (!javaOk()) {
+    state.stage = 'JDK 17 kuruluyor (winget)';
+    await new Promise((resolve, reject) => {
+      const proc = spawn('winget', ['install', '--id', 'Microsoft.OpenJDK.17', '--accept-source-agreements', '--accept-package-agreements', '--silent'], { windowsHide: true, shell: true });
+      proc.on('close', (code) => (code === 0 || javaOk() ? resolve() : reject(new Error('JDK kurulumu başarısız (winget)'))));
+      proc.on('error', () => reject(new Error('winget bulunamadı — JDK 17 elle kur')));
+    });
+  }
+  stage(15);
+
+  /* 2) cmdline-tools indir + aç */
+  const toolsBin = path.join(SDK_DIR, 'cmdline-tools', 'latest', 'bin', 'sdkmanager.bat');
+  if (!fs.existsSync(toolsBin)) {
+    state.stage = 'cmdline-tools indiriliyor (~150MB)';
+    const zipPath = path.join(os.tmpdir(), 'commandlinetools.zip');
+    const res = await fetch(CMDTOOLS_URL);
+    if (!res.ok) throw new Error('cmdline-tools indirilemedi: HTTP ' + res.status);
+    const buf = Buffer.from(await res.arrayBuffer());
+    fs.mkdirSync(SDK_DIR, { recursive: true });
+    fs.writeFileSync(zipPath, buf);
+    stage(35);
+    execSync(
+      `powershell -NoProfile -Command "Expand-Archive -LiteralPath '${zipPath}' -DestinationPath '${SDK_DIR}' -Force"`,
+      { timeout: 300000, windowsHide: true, stdio: 'pipe' }
+    );
+    /* zip içi: cmdline-tools/ → cmdline-tools/latest/ olmalı */
+    const inner = path.join(SDK_DIR, 'cmdline-tools');
+    if (fs.existsSync(inner) && !fs.existsSync(toolsBin)) {
+      fs.renameSync(inner, inner + '_tmp');
+      fs.mkdirSync(path.join(SDK_DIR, 'cmdline-tools'), { recursive: true });
+      fs.renameSync(inner + '_tmp', path.join(SDK_DIR, 'cmdline-tools', 'latest'));
+    }
+    try { fs.unlinkSync(zipPath); } catch {}
+  }
+  stage(45);
+
+  /* 3) lisanslar + paketler (platform-tools + emulator + sistem imajı ~1.3GB)
+     Cevaplar stdin spam'iyle DEĞİL dosya redirect'iyle verilir — sdkmanager
+     interaktif stdin'i cmd borularında düzgün okumuyor */
+  state.stage = 'SDK paketleri iniyor (platform-tools · emulator · sistem imajı)';
+  const sysEnv = { ...process.env };
+  const yesFile = path.join(os.tmpdir(), 'beast-sdk-yes.txt');
+  fs.writeFileSync(yesFile, 'y\n'.repeat(80), 'utf8');
+  await runBat(toolsBin, ['--licenses'], {
+    tag: 'lisans adımı',
+    spawnOpts: { env: sysEnv },
+    redirect: yesFile,
+  });
+  stage(50);
+  {
+    const pkgs = ['platform-tools', 'emulator', SYS_IMAGE];
+    /* GERÇEK PROGRESS: sdkmanager çıktısı "[====    ] 17% Downloading x" biçiminde
+       GLOBAL yüzde basar (monotonik artar) — %50-95 aralığına doğrudan eşle */
+    let last = 50;
+    const lastPercent = /(\d{1,3})%[^%]*$/;
+    /* sdkmanager ağ ortasında patlarsa: yarım .temp'i temizle + 3 kere yeniden
+       dene (indirilenler korunur — kaldığı yeri hızla atlar) */
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        try { fs.rmSync(path.join(SDK_DIR, '.temp'), { recursive: true, force: true }); } catch {}
+        await runBat(toolsBin, pkgs, {
+          tag: 'sdkmanager',
+          spawnOpts: { env: sysEnv },
+          redirect: yesFile,
+          onData: (s) => {
+            const m = lastPercent.exec(s);
+            if (m) {
+              const sdkPct = Math.max(0, Math.min(100, Number(m[1])));
+              const pct = 50 + sdkPct * 0.45; /* %0→50, %100→95 */
+              if (pct > last + 0.4) { last = pct; stage(pct); }
+            }
+          },
+        });
+        break;
+      } catch (e) {
+        if (attempt < 3 && !findAdb()) continue;
+        throw e;
+      }
+    }
+  }
+
+  /* 4) AVD yarat */
+  stage(96);
+  state.stage = 'AVD (emülatör cihazı) oluşturuluyor';
+  if (!(await listAvds()).includes(AVD_NAME)) {
+    const avdm = path.join(SDK_DIR, 'cmdline-tools', 'latest', 'bin', 'avdmanager.bat');
+    const noFile = path.join(os.tmpdir(), 'beast-sdk-no.txt');
+    fs.writeFileSync(noFile, 'no\n', 'utf8');
+    await runBat(avdm, ['create', 'avd', '-n', AVD_NAME, '-k', SYS_IMAGE, '-d', 'pixel'], {
+      tag: 'avdmanager',
+      spawnOpts: { env: sysEnv },
+      redirect: noFile,
+    });
+  }
+  emitInstallProgress('android', { pct: 100 });
+  state.installing = false;
+}
+
+/* ---------- EMÜLATÖR BAŞLATMA (uzun ömürlü — kendi penceresi açılır) ---------- */
+async function startAvd(name) {
+  const emu = findEmulator();
+  if (!emu) return { ok: false, error: 'emulator.exe yok — önce Kurulum sekmesinden kur' };
+  const target = name || (await listAvds())[0];
+  if (!target) return { ok: false, error: 'AVD yok — önce kur' };
+  state.booting = true;
+  const proc = spawn(emu, ['-avd', target, '-no-snapshot'], { windowsHide: false, detached: false });
+  proc.on('exit', () => { state.booting = false; });
+  /* boot tamamlanmasını bekleme — arka planda; expo/adb kendisi bekler */
+  return { ok: true, avd: target, note: 'emülatör başlatıldı — ilk açılış 30-90 sn sürer' };
+}
+
+module.exports = { probe, autoInstall, listAvds, startAvd };

package/src/agent/engine.js

@@ -1064,6 +1064,39 @@ class Engine {
     return removed;
   }
 
+  /* Düşünme geri-besleme kurtarması: asistan mesajlarındaki reasoning_content'i
+     bellekten + jsonl'den temizler. "must be passed back" hatasını veren sağlayıcı
+     için tek kurtarma yolu — döndürür: temizlenen mesaj sayısı */
+  _stripAssistantReasoning(session) {
+    let dropped = 0;
+    for (const m of session.messages) {
+      if (m && m.role === 'assistant' && (m.reasoning_content || m.reasoning)) {
+        delete m.reasoning_content;
+        delete m.reasoning;
+        dropped++;
+      }
+    }
+    if (!dropped) return 0;
+    try {
+      const file = this._file(session.id);
+      const lines = fs.readFileSync(file, 'utf8').split('\n');
+      for (let i = 0; i < lines.length; i++) {
+        if (!lines[i].trim()) continue;
+        let r;
+        try { r = JSON.parse(lines[i]); } catch { continue; }
+        if (r.t === 'msg' && r.role === 'assistant' && (r.reasoning_content || r.reasoning)) {
+          delete r.reasoning_content;
+          delete r.reasoning;
+          lines[i] = JSON.stringify(r);
+        }
+      }
+      const tmp = file + '.tmp';
+      fs.writeFileSync(tmp, lines.join('\n'));
+      fs.renameSync(tmp, file);
+    } catch {}
+    return dropped;
+  }
+
   _load(id) {
     if (this.cache.has(id)) return this.cache.get(id);
     const file = this._file(id);
@@ -3240,6 +3273,37 @@ class Engine {
          arındırıp turu BİR KEZ görüntüsüz dener. */
       const msgStr = String((e && e.message) || '');
       const aborted = signal && signal.aborted;
+      /* DÜŞÜNME GERİ-BESLEME KURTARMASI: "reasoning_content ... must be passed
+         back" hatası eski oturumlarda (reasoning saklanmadan önce) olur —
+         geçmişi reasoning'siz arındırıp turu BİR KEZ yeniden dene */
+      if (!aborted && /reasoning_content/i.test(msgStr)) {
+        const dropped = this._stripAssistantReasoning(session);
+        if (dropped) {
+          emitSafe(this, session.id, {
+            type: 'status',
+            status: `🧠 düşük uyumlu sağlayıcı: geçmişteki düşünme içerikleri temizlendi (${dropped} mesaj) — tur yeniden deneniyor`,
+          });
+          payload = this._buildPayload(system, session.messages, session.notes, dynBudget, session.summary);
+          res = await this._streamWithFallbacks(
+            session,
+            payload,
+            activeTools,
+            signal,
+            onDelta,
+            sel,
+            role === 'vision'
+          );
+          const actualR = res.usage && res.usage.prompt_tokens;
+          if (actualR > 0) {
+            const predicted = this._payloadTokens(payload);
+            if (predicted > 50) {
+              const r = clamp(actualR / predicted, 0.75, 3);
+              this.tokRatio = clamp(this.tokRatio * 0.7 + r * 0.3, 0.75, 3);
+            }
+          }
+          return res;
+        }
+      }
       const imgish =
         !aborted &&
         /image|vision|multimodal|no endpoints/i.test(msgStr);
@@ -3395,6 +3459,10 @@ class Engine {
 
         const assistant = { role: 'assistant', content: res.content || '' };
         if (res.toolCalls && res.toolCalls.length) assistant.tool_calls = res.toolCalls;
+        /* DÜŞÜNME MODU GERİ-BESLEMESİ: Console Go gibi sağlayıcılar thinking
+           modunda reasoning_content'in GEÇMİŞTE geri gönderilmesini şart koşar
+           ("must be passed back to the API") — saklamazsak sonraki tur 400'le ölür */
+        if (res.reasoning) assistant.reasoning_content = res.reasoning;
         session.messages.push(assistant);
         try {
           this._append(session, assistant);
@@ -3529,6 +3597,16 @@ class Engine {
                     else if (/\b(npm (run )?(dev|start)|npx serve|live-server)\b/i.test(cmdStr)) port = 3000;
                     if (port) bcArtifacts.serverUrl = 'http://localhost:' + port;
                   }
+                  /* Expo dev server: exp://<LAN-IP>:<port> çıktıdan yakalanır —
+                     telefon/Expo Go için QR renderer'a canlı iletilir */
+                  const xm = /exp:\/\/[^\s'"<>]+/i.exec(hay);
+                  if (xm) {
+                    const eurl = xm[0].replace(/[)\].,;:'"]+$/, '');
+                    if (bcArtifacts.expUrl !== eurl) {
+                      bcArtifacts.expUrl = eurl;
+                      emit({ type: 'bc-expurl', url: eurl });
+                    }
+                  }
                 }
               } catch {}
             }
@@ -4068,6 +4146,7 @@ const skills = require('./skills');
         );
         const assistant = { role: 'assistant', content: res.content || '' };
         if (res.toolCalls && res.toolCalls.length) assistant.tool_calls = res.toolCalls;
+        if (res.reasoning) assistant.reasoning_content = res.reasoning; /* thinking geri-besleme */
         msgs.push(assistant);
         if (!res.toolCalls || !res.toolCalls.length) return res.content || '(alt-agent boş döndü)';
         for (const tc of res.toolCalls) {

package/src/agent/headroom.js

@@ -0,0 +1,279 @@
+'use strict';
+
+/* ---------- BEAST × HEADROOM (OPSİYONEL token sıkıştırma) ----------
+   Ayarlardan (Kurulum sekmesi) açılıp kapanır; kapalıyken hiçbir şey yapmaz.
+   Açıkken: LLM istekleri yerel headroom proxy'sinden geçer — araç çıktıları,
+   loglar ve JSON yükleri modele gitmeden sıkıştırılır (testte %39-71 tasarruf).
+   Kurulum: uv tool install "headroom-ai[proxy]" (uv yoksa hata bildirir).
+   Her provider için AYRI proxy portu (base URL farkları için); llm.js
+   providerId → port haritasıyla yönlendirir, kapatınca düz bağlanır. */
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { emitInstallProgress } = require('./progressbus');
+
+const PORT_BASE = 18787;
+const MAX_PROXIES = 8;
+
+const state = {
+  enabled: false,
+  installing: false,
+  installFailed: false,
+  installError: '',
+  starting: false,
+  proxies: new Map(), // providerId -> { proc, port, baseUrl, ready }
+  providerGetter: null, // () => [{ id, name, baseUrl }]
+  statusSink: null, // (probe) => void — main renderer'a akıtır
+};
+
+function _emit() {
+  try { if (state.statusSink) state.statusSink(probe()); } catch {}
+}
+
+function headroomExe() {
+  const local = path.join(os.homedir(), '.local', 'bin', 'headroom.exe');
+  if (fs.existsSync(local)) return local;
+  try {
+    require('child_process').execSync('where headroom', { timeout: 5000, stdio: 'pipe' });
+    return 'headroom';
+  } catch {}
+  return '';
+}
+
+function uvExe() {
+  const local = path.join(os.homedir(), '.local', 'bin', 'uv.exe');
+  if (fs.existsSync(local)) return local;
+  try {
+    require('child_process').execSync('where uv', { timeout: 5000, stdio: 'pipe' });
+    return 'uv';
+  } catch {}
+  return '';
+}
+
+function probe() {
+  return {
+    installed: !!headroomExe(),
+    installing: state.installing,
+    failed: state.installFailed,
+    error: state.installError,
+    enabled: state.enabled,
+    starting: state.starting,
+    proxies: [...state.proxies.values()].map((p) => ({ port: p.port, baseUrl: p.baseUrl, ready: p.ready })),
+  };
+}
+
+/* ---------- KURULUM (arka plan) ----------
+   uv tool install headroom-ai[proxy] — kendi izole Python 3.13 ortamını kurar;
+   sistemde Python gerekmez. uv yoksa pip fallback, o da yoksa elle yönlendirir. */
+function autoInstall() {
+  if (state.installing || headroomExe()) return;
+  const uv = uvExe();
+  if (!uv) {
+    state.installFailed = true;
+    state.installError = 'uv bulunamadı — kur: winget install astral-sh.uv';
+    _emit();
+    return;
+  }
+  state.installing = true;
+  state.installFailed = false;
+  state.installError = '';
+  _emit();
+  emitInstallProgress('headroom', { pct: 4 });
+  const proc = spawn(uv, ['tool', 'install', '--python', '3.13', 'headroom-ai[proxy]'], { windowsHide: true });
+  let buf = '';
+  let stage = 4;
+  const bump = () => {
+    stage = Math.min(92, stage + 7);
+    emitInstallProgress('headroom', { pct: stage });
+  };
+  const onData = (c) => {
+    const s = String(c);
+    if (/Download|Resolve|Installed|Prepared/i.test(s)) bump();
+  };
+  proc.stdout.on('data', onData);
+  proc.stderr.on('data', onData);
+  proc.on('close', (code) => {
+    state.installing = false;
+    if (code === 0 && headroomExe()) {
+      emitInstallProgress('headroom', { pct: 100 });
+    } else {
+      state.installFailed = true;
+      state.installError = 'kurulum başarısız — elle: uv tool install "headroom-ai[proxy]"';
+    }
+    _emit();
+    /* kurulum bitti ve açık kaldıysa proxy'leri hemen başlat */
+    if (state.enabled && headroomExe()) start().catch(() => {});
+  });
+  proc.on('error', () => {
+    state.installing = false;
+    state.installFailed = true;
+    state.installError = 'kurulum başlatılamadı (uv)';
+    _emit();
+  });
+}
+
+/* ---------- PROXY SÜREÇLERİ ----------
+   Provider başına bir proxy; cache modunu BOZMAMAK için mode=token,
+   Beast'in tanımadığı headroom_retrieve aracı enjekte EDİLMESİN diye
+   no-ccr (geri-getirilemez sıkıştırma, en yüksek tasarruf) ve rate limit
+   kapalı (Beast'in kendi istek patlamalarına takılmasın). Beacon kapalı. */
+function nextPort() {
+  const used = new Set([...state.proxies.values()].map((p) => p.port));
+  for (let i = 0; i < MAX_PROXIES; i++) {
+    const port = PORT_BASE + i;
+    if (!used.has(port)) return port;
+  }
+  return 0;
+}
+
+function spawnFor(provider) {
+  return new Promise((resolve) => {
+    const exe = headroomExe();
+    if (!exe) return resolve({ ok: false, error: 'headroom kurulu değil' });
+    const port = nextPort();
+    if (!port) return resolve({ ok: false, error: 'port kalmadı' });
+    let proc;
+    try {
+      proc = spawn(exe, [
+        'proxy', '--port', String(port), '--openai-api-url', provider.baseUrl,
+        '--mode', 'token', '--no-ccr', '--no-rate-limit',
+      ], {
+        windowsHide: true,
+        env: { ...process.env, HEADROOM_BEACON: 'off', DO_NOT_TRACK: '1' },
+      });
+    } catch (e) {
+      return resolve({ ok: false, error: String((e && e.message) || e) });
+    }
+    const rec = { proc, port, baseUrl: provider.baseUrl, ready: false };
+    state.proxies.set(provider.id, rec);
+    _emit();
+    proc.on('exit', () => {
+      if (state.proxies.get(provider.id) === rec) state.proxies.delete(provider.id);
+      _emit();
+    });
+    const t0 = Date.now();
+    const poll = setInterval(async () => {
+      let ready = false;
+      try {
+        const r = await fetch('http://127.0.0.1:' + port + '/health', { signal: AbortSignal.timeout(2000) });
+        ready = !!r.ok;
+      } catch {}
+      if (ready) {
+        clearInterval(poll);
+        rec.ready = true;
+        _emit();
+        return resolve({ ok: true, port });
+      }
+      if (Date.now() - t0 > 90000) {
+        clearInterval(poll);
+        try { rec.proc.kill(); } catch {}
+        state.proxies.delete(provider.id);
+        _emit();
+        resolve({ ok: false, error: 'proxy zaman aşımı (90sn)' });
+      }
+    }, 1200);
+  });
+}
+
+async function start() {
+  const exe = headroomExe();
+  if (!exe) {
+    autoInstall();
+    return { ok: false, error: 'kuruluyor — birkaç dakika sonra hazır olur' };
+  }
+  state.starting = true;
+  _emit();
+  try {
+    const providers = (state.providerGetter ? state.providerGetter() : []).slice(0, MAX_PROXIES);
+    const routes = {};
+    /* önce eskileri temizle: listeden çıkan provider'ın proxy'sini kapat */
+    const keep = new Set(providers.map((p) => p.id));
+    for (const [id, rec] of [...state.proxies.entries()]) {
+      if (keep.has(id)) continue;
+      try { rec.proc.kill(); } catch {}
+      try { spawn('taskkill', ['/pid', String(rec.proc.pid), '/T', '/F'], { windowsHide: true }); } catch {}
+      state.proxies.delete(id);
+    }
+    for (const p of providers) {
+      if (!p.baseUrl || state.proxies.has(p.id)) continue;
+      const r = await spawnFor(p);
+      if (r.ok) routes[p.id] = r.port;
+    }
+    try { require('./llm').setHeadroomRoutes(routes); } catch {}
+    state.enabled = true;
+    return { ok: true, routes };
+  } finally {
+    state.starting = false;
+    _emit();
+  }
+}
+
+async function setEnabled(on) {
+  if (on) {
+    state.enabled = true;
+    if (!headroomExe()) {
+      autoInstall();
+      return { ok: false, installing: true, error: 'headroom arka planda kuruluyor — birkaç dakika sonra hazır' };
+    }
+    return start();
+  }
+  state.enabled = false;
+  stopAll();
+  try { require('./llm').setHeadroomRoutes(null); } catch {}
+  return { ok: true };
+}
+
+/* provider listesi değişti (eklendi/silindi) → proxy setini senkronla */
+function syncProviders() {
+  if (!state.enabled || !headroomExe()) return;
+  start().catch(() => {});
+}
+
+function stopAll() {
+  for (const rec of state.proxies.values()) {
+    try { rec.proc.kill(); } catch {}
+    try { spawn('taskkill', ['/pid', String(rec.proc.pid), '/T', '/F'], { windowsHide: true }); } catch {}
+  }
+  state.proxies.clear();
+  _emit();
+}
+
+function setProviderGetter(fn) { state.providerGetter = typeof fn === 'function' ? fn : null; }
+function setStatusSink(fn) { state.statusSink = typeof fn === 'function' ? fn : null; }
+
+/* proxy /stats özeti (sağlık duvarı yok — hata.yakalanır) */
+async function stats() {
+  const rec = [...state.proxies.values()].find((p) => p.ready);
+  if (!rec) return { ok: false, running: false };
+  try {
+    const r = await fetch('http://127.0.0.1:' + rec.port + '/stats', { signal: AbortSignal.timeout(4000) });
+    const j = await r.json();
+    const s = (j && (j.tokens || j.summary)) || {};
+    return {
+      ok: true,
+      running: true,
+      port: rec.port,
+      input: Number(s.input) || 0,
+      output: Number(s.output) || 0,
+      saved: Number(s.saved) || 0,
+      proxyCompressionSaved: Number(s.proxy_compression_saved) || 0,
+      savingsPercent: Number(s.savings_percent) || 0,
+      allLayersSaved: Number(s.all_layers_saved) || 0,
+    };
+  } catch {
+    return { ok: false, running: true, port: rec.port };
+  }
+}
+
+module.exports = {
+  probe,
+  autoInstall,
+  setEnabled,
+  syncProviders,
+  stopAll,
+  setProviderGetter,
+  setStatusSink,
+  stats,
+};