beast-agent 0.26.0 → 0.26.2

package/bin/beast-agent.js

@@ -82,27 +82,44 @@ if (process.argv[2] === 'update') {
     process.exit(1);
   }
   console.log('\n\u2713 beast-agent g\u00FCncellendi \u2014 uygulama ba\u015Flat\u0131l\u0131yor\u2026');
-  try {
-    const electron = require('electron');
-    if (typeof electron === 'string') {
-      spawn(electron, [path.resolve(__dirname, '..')], { stdio: 'ignore', detached: true }).unref();
-    }
-  } catch {}
+  launchDetached([]);
   if (isWin) spawnSync('cmd.exe', ['/c', 'timeout /t 3'], { stdio: 'ignore' });
   process.exit(0);
 }
 
-const electron = require('electron');
-if (typeof electron !== 'string') {
-  /* electron runtime içindeyiz — bu script için anlamsız */
-  process.exit(1);
+/* detached başlatıcı + kendini onaran electron:
+   taze makinalarda npm postinstall sırasında electron binary indirmesi
+   sessizce başarısız olmuş olabilir → burada otomatik tamir edilir. */
+function launchDetached(extraArgs) {
+  let electron = null;
+  try { electron = require('electron'); } catch {}
+  if (typeof electron !== 'string') {
+    let fix = null;
+    try { fix = require('../scripts/fix-electron'); } catch {}
+    if (fix) {
+      console.log('\u27F3 electron \u00e7al\u0131\u015Fma dosyalar\u0131 eksik bulundu \u2014 otomatik onar\u0131l\u0131yor\u2026');
+      const r = fix.repair({ quiet: false });
+      if (r.ok && !r.skipped) console.log('\u2713 electron onar\u0131ld\u0131');
+      if (r.ok) {
+        try { electron = require('electron'); } catch {}
+      }
+    }
+  }
+  if (typeof electron !== 'string') {
+    console.log('\n\u2717 Electron \u00e7al\u0131\u015Fma dosyas\u0131 kurulamad\u0131.');
+    console.log('  Elle \u00e7\u00f6z\u00fcm \u2014 \u015fu 2 komutu \u00e7al\u0131\u015Ft\u0131r:');
+    console.log('    npm config set ignore-scripts false');
+    console.log('    npm install -g beast-agent');
+    return false;
+  }
+  const child = spawn(electron, [path.resolve(__dirname, '..'), ...extraArgs], {
+    stdio: 'ignore',
+    detached: true,
+    /* windowsHide KULLANMA: Chromium ilk pencereyi gizli başlatıyor (tray-only bug) */
+  });
+  child.unref();
+  return true;
 }
 
-const appPath = path.resolve(__dirname, '..');
-const child = spawn(electron, [appPath, ...process.argv.slice(2)], {
-  stdio: 'ignore',
-  detached: true,
-  /* windowsHide KULLANMA: Chromium ilk pencereyi gizli başlatıyor (tray-only bug) */
-});
-child.unref();
+if (!launchDetached(process.argv.slice(2))) process.exit(1);
 process.exit(0);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "0.26.0",
+    "version": "0.26.2",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",
@@ -33,6 +33,7 @@
         "dist": "electron-builder --win nsis portable",
         "test": "node --test \"tests/**/*.test.js\"",
         "release": "node scripts/release.js",
+        "postinstall": "node scripts/fix-electron.js --soft",
         "prepublishOnly": "node scripts/swap-electron.js deps",
         "postpublish": "node scripts/swap-electron.js devdeps"
     },
@@ -54,7 +55,6 @@
         "pdfkit": "^0.20.1",
         "qrcode": "^1.5.4",
         "tesseract.js": "^7.0.0",
-        "undici": "^7.29.0",
         "ws": "^8.21.3",
         "electron": "40.10.2"
     },

package/scripts/fix-electron.js

@@ -0,0 +1,126 @@
+'use strict';
+
+/* BEAST — electron binary onarıcı.
+   SORUN: `electron` npm paketi binary'yi (dist/electron.exe) postinstall'da
+   GitHub'dan indirir. Taze makinalarda bu indirme SESSİZCE başarısız olabilir
+   (proxy/GitHub engeli, npm ignore-scripts=true, ağ kesintisi) — paket kurulmuş
+   görünür ama `require('electron')` "Electron failed to install correctly" fırlatır.
+   ÇÖZÜM: install.js'i elle çalıştır; olmazsa yedek aynadan (npmmirror) dene.
+   Kullanım yerleri:
+     - package.json postinstall  → kurulumda otomatik (npm i -g beast-agent)
+     - bin/beast-agent.js        → her başlatmada bozuksa otomatik onar */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/* electron paket dizini (index.js'in yeri); paket hiç yoksa null */
+function electronDir() {
+  try {
+    return path.dirname(require.resolve('electron'));
+  } catch {
+    return null;
+  }
+}
+
+/* binary sağlam mı? electron/index.js'in beklentisiyle aynı kontrol:
+   path.txt + dist/<exe> varlığı */
+function status() {
+  const dir = electronDir();
+  if (!dir) return { ok: false, missing: true };
+  const exe = process.platform === 'win32' ? 'electron.exe' : 'electron';
+  const distOk = fs.existsSync(path.join(dir, 'dist', exe));
+  const txtOk = fs.existsSync(path.join(dir, 'path.txt'));
+  return distOk && txtOk ? { ok: true, dir } : { ok: false, dir };
+}
+
+/* platforma göre dist içindeki çalıştırılabilirin göreli yolu (electron/index.js ile aynı) */
+function platformPath() {
+  switch (process.platform) {
+    case 'win32':
+      return 'electron.exe';
+    case 'darwin':
+    case 'mas':
+      return 'Electron.app/Contents/MacOS/Electron';
+    default:
+      return 'electron';
+  }
+}
+
+/* onarım — 3 katman:
+   0) binary sağlam, yalnız path.txt eksik/bozuk → indirimsiz anında yazar
+      (install.js bu durumu "zaten kurulu" sanıp atlayabiliyor)
+   1) dist bozuk/eksik → dist'i sil + install.js (GitHub) ile taze indir
+   2) GitHub engelli → ELECTRON_MIRROR=npmmirror ile tekrar */
+function repair({ quiet } = {}) {
+  let st = status();
+  if (st.ok) return { ok: true, dir: st.dir, skipped: true };
+  if (st.missing) return { ok: false, error: 'electron paketi hi\u00e7 yok — npm install -g beast-agent' };
+  const dir = st.dir;
+  const exeRel = platformPath();
+  const exeAbs = path.join(dir, 'dist', ...exeRel.split('/'));
+  const verFile = path.join(dir, 'dist', 'version');
+  let wantVer = null;
+  try { wantVer = String(require(path.join(dir, 'package.json')).version || ''); } catch {}
+  const distIntact =
+    fs.existsSync(exeAbs) &&
+    (!wantVer ||
+      (fs.existsSync(verFile) &&
+        fs.readFileSync(verFile, 'utf8').replace(/^v/, '').trim() === wantVer));
+
+  if (distIntact) {
+    /* KATMAN 0: hızlı onarım — path.txt'yi kendimiz yazıyoruz (indirim yok) */
+    try { fs.writeFileSync(path.join(dir, 'path.txt'), exeRel, 'utf8'); } catch {}
+    if (status().ok) return { ok: true, dir, fast: true };
+  }
+
+  /* KATMAN 1-2: tam indirim */
+  try { fs.rmSync(path.join(dir, 'dist'), { recursive: true, force: true }); } catch {}
+  try { fs.unlinkSync(path.join(dir, 'path.txt')); } catch {}
+  const installJs = path.join(dir, 'install.js');
+  if (!fs.existsSync(installJs)) {
+    return { ok: false, error: 'install.js yok — yeniden kur: npm install -g beast-agent' };
+  }
+
+  const sources = [null, 'https://npmmirror.com/mirrors/electron/'];
+  for (let i = 0; i < sources.length; i++) {
+    const env = { ...process.env };
+    if (sources[i]) {
+      env.ELECTRON_MIRROR = sources[i];
+      if (!quiet) console.log('  \u2022 varsay\u0131lan kaynak ba\u015Far\u0131s\u0131z \u2014 yedek ayna deneniyor (npmmirror)\u2026');
+    } else if (!quiet) {
+      console.log('  \u2022 electron binary indiriliyor (ilk sefer ~110 MB, 1-2 dk)\u2026');
+    }
+    const r = spawnSync(process.execPath, [installJs], {
+      cwd: dir,
+      env,
+      stdio: quiet ? 'ignore' : 'inherit',
+      timeout: 600000,
+    });
+    if (!r.error && r.status === 0 && status().ok) {
+      return { ok: true, dir, mirror: sources[i] || 'github' };
+    }
+    if (!quiet && r.error) {
+      console.log('  ! deneme ba\u015far\u0131s\u0131z: ' + String(r.error.message || r.error).slice(0, 160));
+    }
+  }
+  return { ok: false, error: 'electron binary indirilemedi (a\u011f/proxy engeli olabilir)' };
+}
+
+module.exports = { electronDir, status, repair };
+
+/* CLI: package.json postinstall → `node scripts/fix-electron.js --soft`
+   (her durumda exit 0 — npm install bozulmasın, başlatma anında tekrar denenir)
+   elle çağrı → hata durumunda exit 1 */
+if (require.main === module) {
+  const soft = process.argv.includes('--soft');
+  const r = repair({ quiet: false });
+  if (r.ok) {
+    console.log(r.skipped ? '\u2713 electron binary tamam' : '\u2713 electron binary onar\u0131ld\u0131');
+    process.exit(0);
+  }
+  console.error('\u2717 electron onar\u0131lamad\u0131: ' + (r.error || '?'));
+  console.error('  elle \u00e7\u00f6z\u00fcm: npm config set ignore-scripts false');
+  console.error('           npm install -g beast-agent');
+  process.exit(soft ? 0 : 1);
+}

package/src/agent/bots.js

@@ -327,6 +327,14 @@ function update(id, patch) {
       changes.push('dış tarayıcı komutu güncellendi');
       b.extCommand = String(patch.extCommand).slice(0, 200);
     }
+    if (typeof patch.model === 'string') {
+      /* bot bazlı model override — boş string = global seçim */
+      const next = patch.model.trim().slice(0, 160);
+      if (next !== (b.model || '')) {
+        changes.push('model güncellendi');
+        b.model = next;
+      }
+    }
     if (Array.isArray(patch.plugins)) {
       const next = [...new Set(patch.plugins.map((p) => String(p).slice(0, 40)).filter((p) => PLUGIN_LIST.includes(p)))];
       if (JSON.stringify(next) !== JSON.stringify(b.plugins || [])) {

package/src/agent/discord.js

@@ -0,0 +1,268 @@
+'use strict';
+
+/* DISCORD KÖPRÜSÜ — Telegram köprüsünün Discord hali.
+   Bağımlılık: yalnızca `ws` (paket zaten kurulu — baileys ile geliyor).
+   - Gateway WebSocket: Identify → READY → MESSAGE_CREATE dispatch
+   - REST (api/v10): mesaj gönderme (2000 karakter sınırında bölerek)
+   - Sunucu (guild) mesajlarında yalnız @mention'a cevap verilir (spam koruması);
+     DM'de her izinli kullanıcıya cevap verilir.
+   - Bağlantı koparsa backoff ile yeniden bağlanır (yeniden Identify;
+     çevrimdışıyken gelen mesajlar backfill edilmez — Telegram long-poll'un aksine).
+   ÖNEMLİ: Discord Developer Portal'da bot için "MESSAGE CONTENT INTENT"
+   açılmalıdır — yoksa mesaj içerikleri boş gelir. */
+
+const WebSocket = require('ws');
+const https = require('https');
+
+const API_BASE = 'https://discord.com/api/v10';
+const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json';
+const SEND_CHUNK = 1900; // Discord mesaj sınırı 2000 — güvenli pay
+/* GUILDS(1) | GUILD_MESSAGES(512) | DIRECT_MESSAGES(4096) | MESSAGE_CONTENT(32768) */
+const INTENTS = 1 | 512 | 4096 | 32768;
+
+/* AĞ ARA YAZILIMI (antivirüs SSL taraması / proxy / ağ filtresi) Discord
+   trafiğine araya girip SELF-SIGNED sertifika sunarsa Node varsayılan olarak
+   bağlantıyı reddeder ("self signed certificate") ve bot hiç bağlanamaz.
+   Çözüm: hata tespit edilince bu köprü için TLS doğrulaması esnetilir ve
+   uyarı loglanır — YALNIZ Discord bağlantıları etkilenir, app'in geri kalanı
+   normal doğrulama kullanmaya devam eder. */
+let tlsRelaxed = false;
+const CERT_ERR_RE = /self[ -]?signed|unable to verify the first certificate|depth zero|err_tls|certificate has expired|cert_has_expired|unable_to_get_issuer|self signed certificate/i;
+
+function isCertError(e) {
+  return CERT_ERR_RE.test(String((e && (e.message || e.code)) || e || ''));
+}
+
+class DiscordBridge {
+  constructor({ token, emit, onIncoming }) {
+    this.token = String(token || '').trim();
+    this.emit = emit || (() => {});
+    this.onIncoming = onIncoming || null;
+    this.connected = false;
+    this.stopping = false;
+    this.status = 'disconnected';
+    this.user = null; // { id, username, ... }
+    this._ws = null;
+    this._hbTimer = null;
+    this._seq = null;
+    this._backoff = 2000;
+  }
+
+  _setStatus(status, user) {
+    this.status = status;
+    this.connected = status === 'connected';
+    this.emit({ type: 'status', status, user: user || null });
+  }
+
+  /* REST çağrısı — JSON (token: "Bot <token>"). Cert engeli tespit edilirse
+     TLS esnetilip TEK seferlik yeniden denenir. */
+  api(method, path, body, attempt = 0) {
+    return new Promise((resolve, reject) => {
+      const payload = body ? JSON.stringify(body) : null;
+      const req = https.request(
+        `${API_BASE}${path}`,
+        {
+          method,
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bot ' + this.token,
+            ...(payload ? { 'Content-Length': Buffer.byteLength(payload) } : {}),
+          },
+          timeout: 15000,
+          rejectUnauthorized: !tlsRelaxed,
+        },
+        (res) => {
+          let data = '';
+          res.setEncoding('utf8');
+          res.on('data', (c) => (data += c));
+          res.on('end', () => {
+            try {
+              const j = data ? JSON.parse(data) : null;
+              if (res.statusCode >= 200 && res.statusCode < 300) resolve(j);
+              else reject(new Error(`discord ${path}: HTTP ${res.statusCode} ${(j && j.message) || ''}`.trim()));
+            } catch {
+              reject(new Error(`discord ${path}: bozuk yanıt`));
+            }
+          });
+        }
+      );
+      req.on('timeout', () => req.destroy(new Error('zaman aşımı')));
+      req.on('error', reject);
+      if (payload) req.write(payload);
+      req.end();
+    }).catch((e) => {
+      /* ara yazılım sertifikası tespit: esnet ve aynı isteği bir kez daha dene */
+      if (isCertError(e) && !tlsRelaxed) {
+        tlsRelaxed = true;
+        this.emit({
+          type: 'warn',
+          text: 'ağ ara yazılımı (antivirüs/proxy) self-signed sertifikası tespit edildi — Discord bağlantısı esnek TLS ile devam ediyor',
+        });
+        if (attempt < 1) return this.api(method, path, body, attempt + 1);
+      }
+      throw e;
+    });
+  }
+
+  async start() {
+    if (!this.token) {
+      this._setStatus('error');
+      return false;
+    }
+    this.stopping = false;
+    this._setStatus('connecting');
+    try {
+      const me = await this.api('GET', '/users/@me');
+      this.user = me; // { id, username, ... }
+      this._setStatus('connected', '@' + (me.username || 'bot'));
+    } catch (e) {
+      this._setStatus('error');
+      throw e;
+    }
+    this._connect();
+    return true;
+  }
+
+  _connect() {
+    if (this.stopping) return;
+    clearInterval(this._hbTimer);
+    this._hbTimer = null;
+    let identified = false;
+    const ws = new WebSocket(GATEWAY_URL, { rejectUnauthorized: !tlsRelaxed });
+    this._ws = ws;
+
+    ws.on('message', (raw) => {
+      let p = null;
+      try { p = JSON.parse(String(raw)); } catch { return; }
+      const op = p.op;
+      const d = p.d;
+      const t = p.t;
+      if (typeof p.s === 'number') this._seq = p.s;
+
+      if (op === 10) {
+        /* Hello: heartbeat aralığı gelıyor → hafif erken at (güvenli pay) */
+        const iv = (d && d.heartbeat_interval) || 41250;
+        clearInterval(this._hbTimer);
+        this._hbTimer = setInterval(() => {
+          try {
+            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ op: 1, d: this._seq }));
+          } catch {}
+        }, Math.max(5000, Math.floor(iv * 0.8)));
+        if (!identified) {
+          identified = true;
+          try {
+            ws.send(
+              JSON.stringify({
+                op: 2,
+                d: {
+                  token: this.token,
+                  intents: INTENTS,
+                  properties: { os: 'windows', browser: 'beast-agent', device: 'beast-agent' },
+                },
+              })
+            );
+          } catch {}
+        }
+        return;
+      }
+      if (op === 1) {
+        /* sunucu heartbeat istedi — hemen at */
+        try {
+          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ op: 1, d: this._seq }));
+        } catch {}
+        return;
+      }
+      if (op === 9 || op === 7) {
+        /* invalid session / reconnect isteği — kapat, close handler yeniden bağlanır */
+        try { ws.close(); } catch {}
+        return;
+      }
+      if (op === 0 && t === 'READY') {
+        this._backoff = 2000;
+        this._setStatus('connected', '@' + ((d && d.user && d.user.username) || 'bot'));
+        return;
+      }
+      if (op === 0 && t === 'MESSAGE_CREATE' && this.onIncoming) {
+        try {
+          const m = d || {};
+          if (!m.author || m.author.bot || m.webhook_id) return;
+          let text = String(m.content || '').trim();
+          if (!text) return;
+          const botId = this.user && this.user.id;
+          const mentioned = !!(botId && text.includes('<@' + botId + '>'));
+          if (botId) text = text.split('<@' + botId + '>').join(' ').replace(/\s+/g, ' ').trim();
+          const payload = {
+            text: text.slice(0, 6000),
+            senderId: String((m.author && m.author.id) || ''),
+            username: String((m.author && m.author.username) || ''),
+            senderName: String((m.author && (m.author.global_name || m.author.username)) || ''),
+            isGroup: !!m.guild_id,
+            mentioned,
+            channelId: String(m.channel_id || ''),
+          };
+          if (!payload.channelId) return;
+          /* Sunucu mesajlarında yalnız @mention (spam koruması); DM'de hepsi */
+          if (payload.isGroup && !mentioned) return;
+          this.onIncoming(payload.channelId, payload);
+        } catch {}
+        return;
+      }
+    });
+
+    ws.on('close', () => {
+      clearInterval(this._hbTimer);
+      this._hbTimer = null;
+      if (this.stopping) return;
+      this._setStatus('connecting');
+      const wait = this._backoff;
+      this._backoff = Math.min(30000, this._backoff * 2);
+      setTimeout(() => this._connect(), wait);
+    });
+
+    ws.on('error', (e) => {
+      /* gateway TLS'i de ara yazılımdan etkilenebilir — esnet ve close sonrası
+         yeniden bağlanma zaten relaxed ile kurar */
+      if (isCertError(e) && !tlsRelaxed) {
+        tlsRelaxed = true;
+        this.emit({
+          type: 'warn',
+          text: 'ağ ara yazılımı (antivirüs/proxy) self-signed sertifikası tespit edildi — Discord bağlantısı esnek TLS ile devam ediyor',
+        });
+      }
+    });
+  }
+
+  async stop() {
+    this.stopping = true;
+    clearInterval(this._hbTimer);
+    this._hbTimer = null;
+    try {
+      if (this._ws) this._ws.close();
+    } catch {}
+    this._ws = null;
+    this.connected = false;
+    this.status = 'disconnected';
+  }
+
+  snapshot() {
+    return {
+      status: this.status,
+      user: this.user ? '@' + (this.user.username || 'bot') : null,
+      connected: this.connected,
+    };
+  }
+
+  /* Metin gönder — 2000 karakter sınırı için parçalara böl */
+  async send(channelId, text) {
+    const t = String(text || '');
+    if (!t.trim() || !channelId) return false;
+    const chunks = [];
+    for (let i = 0; i < t.length; i += SEND_CHUNK) chunks.push(t.slice(i, i + SEND_CHUNK));
+    for (const part of chunks) {
+      await this.api('POST', `/channels/${channelId}/messages`, { content: part });
+    }
+    return true;
+  }
+}
+
+module.exports = { DiscordBridge };