wormclaude 1.0.160 → 1.0.162

package/dist/api.js

@@ -111,6 +111,26 @@ async function fetchWithRetry(url, init) {
     }
     throw lastErr ?? new Error('retry exhausted');
 }
+// Konuşmadaki EN SON URL/host'u bul (SecurityScan narration-recovery hedefi). Dosya adlarını
+// (.js/.json/.html…) ELER ki "package.json" gibi şeyler hedef sanılmasın.
+function _lastTargetFromMessages(messages) {
+    const urlRe = /https?:\/\/[^\s"'<>)\]]+/i;
+    const hostRe = /\b((?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,24})\b/i;
+    const badExt = /\.(?:js|ts|tsx|jsx|json|html?|css|png|jpe?g|gif|svg|md|txt|py|sh|yml|yaml|lock|map|ico|woff2?|mjs|cjs)$/i;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const c = messages[i]?.content;
+        const s = typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => x?.text || '').join(' ') : '';
+        if (!s)
+            continue;
+        const u = s.match(urlRe);
+        if (u)
+            return u[0];
+        const h = s.match(hostRe);
+        if (h && !badExt.test(h[1]) && !/\.(localhost)$/i.test(h[1]))
+            return h[1];
+    }
+    return '';
+}
 export async function* streamChat(messages, tools, config, signal) {
     const body = {
         model: config.model,
@@ -263,8 +283,9 @@ export async function* streamChat(messages, tools, config, signal) {
         args: safeJsonStringify(c.args),
     }));
     // Yedek: upstream yapısal tool_call vermediyse modelin metne gömdüğü çağrıyı kurtar.
+    // scanTarget: SecurityScan'i "anlatıp" çağırmayan 32B için hedefi konuşmadan al (en son URL/host).
     if (toolCalls.length === 0 && fullText) {
-        const recovered = recoverInlineToolCalls(fullText);
+        const recovered = recoverInlineToolCalls(fullText, { scanTarget: _lastTargetFromMessages(messages) });
         if (recovered.length)
             toolCalls = recovered;
     }

package/dist/commands.js

@@ -57,6 +57,7 @@ export const COMMANDS = [
     { name: '/scan', desc: '[seviye 3+] yetkili hedefte genel tarama (keşif+başlıklar): /scan <alan>' },
     { name: '/xss', desc: '[seviye 3+] yetkili hedefte XSS taraması (kendi motorumuz): /xss <url>' },
     { name: '/sqli', desc: '[seviye 3+] yetkili hedefte SQLi taraması (kendi motorumuz): /sqli <url>' },
+    { name: '/fullscan', desc: '[seviye 3+] tam kapsamlı DETERMİNİSTİK tarama: recon+XSS+SQLi tek komutta: /fullscan <hedef>' },
     { name: '/exploit', desc: 'yetkili testte doğrulanmış PoC üret: /exploit <cve|açıklama>' },
     { name: '/harden', desc: 'savunma çıktısı üret (YARA/Sigma + yama önerisi): /harden <hedef|tehdit>' },
     { name: '/export', desc: 'sohbeti dosyaya kaydet' },
@@ -187,7 +188,7 @@ function formatFinding(x) {
 // FALSE-POZİTİF guard: ilk kelime tam komut adı + argüman var + soru DEĞİL ("recon nedir?" tetiklemez).
 // Yalnız hedef-alan komutları; ve hedef URL/domain GİBİ görünmeli ("xss ile tara" → komut DEĞİL,
 // model SecurityScan ile halleder). "?'li URL kabul edilir (parametreli xss/sqli hedefi).
-const _BARE_CMDS = new Set(['recon', 'scan', 'xss', 'sqli']);
+const _BARE_CMDS = new Set(['recon', 'scan', 'xss', 'sqli', 'fullscan']);
 const _TARGET_RE = /(^https?:\/\/)|(\.[a-z]{2,})|(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/i;
 export function detectBareCommand(input) {
     const s = (input || '').trim();
@@ -269,6 +270,76 @@ async function pentestCmd(tool, arg, ctx) {
     }
     ctx.assistant(lines.join('\n'));
 }
+// /fullscan — DETERMİNİSTİK tam tarama. Modelin doğaçlamasına (nmap/sqlmap orkestrasyonu →
+// narration/uydurma/PATH derdi) GÜVENMEZ: recon → XSS → SQLi motorunu KOD sırayla, her hedefte
+// aynı şekilde koşar, gerçek bulguları tek raporda birleştirir. Tekrarlanabilir (red team/öğrenci).
+async function fullScanCmd(arg, ctx) {
+    const parts = (arg || '').trim().split(/\s+/).filter(Boolean);
+    let scopeAck = false;
+    if (parts.length && /^(run|onayla|çalıştır|calistir|--yes|-y|yes|evet)$/i.test(parts[parts.length - 1])) {
+        scopeAck = true;
+        parts.pop();
+    }
+    const cleaned = [];
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[i].startsWith('-')) {
+            if (parts[i + 1] && !parts[i + 1].startsWith('-'))
+                i++;
+            continue;
+        }
+        cleaned.push(parts[i]);
+    }
+    const target = cleaned.join(' ').trim();
+    if (!target) {
+        ctx.note(tt('Full scan (deterministic: recon + XSS + SQLi)\nUsage: /fullscan <target>\nExample: /fullscan testphp.vulnweb.com', 'Tam tarama (deterministik: recon + XSS + SQLi)\nKullanım: /fullscan <hedef>\nÖrnek: /fullscan testphp.vulnweb.com'));
+        return;
+    }
+    if (!scopeAck) {
+        pendingPentest = `/fullscan ${target} run`;
+        ctx.note(tt(`⚠️  AUTHORIZATION REQUIRED — Full scan (recon + XSS + SQLi)\nTarget: ${target}\n\n` +
+            `Sends REAL requests from YOUR IP. Only on systems you own or have written authorization for.\n` +
+            `To confirm, type "run" (Enter)  ·  or: /fullscan ${target} run`, `⚠️  YETKİ ONAYI GEREKLİ — Tam tarama (recon + XSS + SQLi)\nHedef: ${target}\n\n` +
+            `Hedefe GERÇEK istekler SENİN IP'nden gider. Yalnız sahibi olduğun ya da yazılı izinli sistemlerde.\n` +
+            `Onaylamak için "run" yaz (Enter)  ·  ya da: /fullscan ${target} run`));
+        return;
+    }
+    pendingPentest = null;
+    ctx.note(tt(`Full scan starting — ${target}  (recon → XSS → SQLi, deterministic, repeatable)`, `Tam tarama başlıyor — ${target}  (recon → XSS → SQLi, deterministik, tekrarlanabilir)`));
+    const steps = [['recon', ptLabel('recon')], ['xss', ptLabel('xss')], ['sqli', ptLabel('sqli')]];
+    const all = [];
+    for (const [tool, label] of steps) {
+        ctx.note(`▶ ${label} …`);
+        const out = await runPentest(ctx.config, tool, target, true, (s) => ctx.note(s));
+        if (!out.ok) {
+            const r = out.reason || out.plan?.reason || 'error';
+            // Yetki/kota hatası tüm adımlarda aynı → dur. Diğer hatada o adımı atla, devam et.
+            if (r === 'trust_required' || r === 'quota_exceeded' || r === 'no_quota' || r === 'auth') {
+                ctx.note(`${tt('Full scan stopped', 'Tam tarama durdu')}: ${ptReason(r)}`);
+                return;
+            }
+            ctx.note(`  ${label}: ${ptReason(r)} — ${tt('skipped', 'atlandı')}`);
+            continue;
+        }
+        const f = (out.report?.findings || []).map((x) => ({ ...x, _step: tool }));
+        all.push(...f);
+        ctx.note(`  ${label}: ${f.length} ${tt('finding(s)', 'bulgu')}`);
+    }
+    const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+    all.sort((a, b) => (order[a.severity] ?? 9) - (order[b.severity] ?? 9));
+    const lines = [`✓ ${tt('Full scan complete', 'Tam tarama tamamlandı')} — ${target}`];
+    if (!all.length) {
+        lines.push(tt('No findings on the tested surface (recon/XSS/SQLi). Target looks clean or was unreachable.', 'Test edilen yüzeyde bulgu yok (recon/XSS/SQLi). Hedef temiz görünüyor ya da erişilemedi.'));
+    }
+    else {
+        const sev = (s) => all.filter((x) => x.severity === s).length;
+        lines.push(`${all.length} ${tt('finding(s)', 'bulgu')} — high:${sev('high')} medium:${sev('medium')} low:${sev('low')} info:${sev('info')}`);
+        for (const x of all.slice(0, 60))
+            lines.push('  ' + formatFinding(x));
+        if (all.length > 60)
+            lines.push(`  … +${all.length - 60} ${tt('more', 'daha')}`);
+    }
+    ctx.assistant(lines.join('\n'));
+}
 // /exploit ve /harden — AKTİF tarama DEĞİL, model-üretim görevleri (PoC / YARA-Sigma yazar).
 // Güçlü, yetkili-kapsam çerçevesiyle modele gider (skill gibi). Çıktı kullanıcının dilinde.
 export function buildExploitPrompt(arg) {
@@ -894,6 +965,9 @@ export async function runSlashCommand(input, ctx) {
         case '/sqli':
             await pentestCmd(cmd.slice(1), arg, ctx);
             return true;
+        case '/fullscan':
+            await fullScanCmd(arg, ctx);
+            return true;
         case '/skill': {
             const m = (arg || '').trim().split(/\s+/).filter(Boolean);
             const sub = (m.shift() || '').toLowerCase();

package/dist/inlinetools.js

@@ -232,11 +232,19 @@ function extractTopLevelJsonObjects(text) {
 }
 /** Metindeki gömülü araç çağrılarını kurtarır. Gürültüden kaçınmak için yalnız açık sarmalları
  *  (<tool_call>, ```json) veya mesajın TAMAMI tek JSON çağrısıysa onu alır. */
-export function recoverInlineToolCalls(text) {
+// SecurityScan'i ÇAĞIRMAYIP "anlatan" 32B için: tarama-ismi + aksiyon-fiili + hedef → gerçek çağrı.
+// (Model "Recon işlemini başlatıyorum:" deyip takılıyordu; kullanıcı 'başla' deyip duruyordu.)
+// Stem eşleşmesi (Türkçe ekleri için sondaki \b yok): "tarayacağım/tarıyorum", "keşfederek".
+// tara(?!f) → "taraf/tarafından" YANLIŞ yakalanmaz; "keşif" (isim) + "keşf" (keşfet fiili) ayrı.
+const _SCAN_NOUN_RE = /\b(?:recon|keşif|keşf|kesif|tar[aı](?!f)|scan|securityscan|zafiyet|enjeksiyon|injection|sqli|xss)/i;
+const _SCAN_ACT_RE = /(başl|basl|çalıştır|calistir|gerçekleştir|gerceklestir|kullan|aca[gğ]|ece[gğ]|acak|ecek|[ıiuü]yor|start|run\b|launch|initiat|perform)/i;
+function _scanIntent(s) { return _SCAN_NOUN_RE.test(s) && _SCAN_ACT_RE.test(s); }
+export function recoverInlineToolCalls(text, opts) {
     const t = (text || '').trim();
-    // JSON/prose/ToolName{…}/ToolName(…) çağrısı yoksa erken çık.
+    const scanTarget = (opts?.scanTarget || '').trim();
+    // JSON/prose/ToolName{…}/ToolName(…)/SecurityScan-niyeti çağrısı yoksa erken çık.
     // (Kod fence'i varsa çıkma — dosya-adı etiketli blok olabilir, adım 7 karar verir.)
-    if (!t || (!t.includes('"name"') && !t.includes('"tool"') && !t.includes('"function"') && !/AskUserQuestion/i.test(t) && !TOOL_PREFIX_RE.test(t) && !TOOL_PAREN_RE.test(t) && !t.includes('```')))
+    if (!t || (!t.includes('"name"') && !t.includes('"tool"') && !t.includes('"function"') && !/AskUserQuestion/i.test(t) && !TOOL_PREFIX_RE.test(t) && !TOOL_PAREN_RE.test(t) && !t.includes('```') && !(scanTarget && _scanIntent(t))))
         return [];
     const out = [];
     const seen = new Set();
@@ -334,6 +342,20 @@ export function recoverInlineToolCalls(text) {
             }
         }
     }
+    // 6.5) SecurityScan NARRASYON → gerçek çağrı. 32B "recon başlatıyorum / XSS taraması yapacağım /
+    //      SecurityScan ile tarayacağız" diye NİYET yazıp aracı çağırmıyor → takılıyordu. Hedef
+    //      (konuşmadan) + niyet varsa SecurityScan'i kendimiz emit ediyoruz. Araç metinden seçilir.
+    if (!out.length && scanTarget && _scanIntent(t)) {
+        const low = t.toLowerCase();
+        let tool = 'recon'; // varsayılan: genel "tara" → önce keşif
+        if (/\bxss\b/.test(low))
+            tool = 'xss';
+        else if (/sql/.test(low))
+            tool = 'sqli';
+        else if (/(recon|keşif|keşf|kesif)/.test(low))
+            tool = 'recon';
+        push({ name: 'SecurityScan', arguments: { tool, target: scanTarget } });
+    }
     // 7) SON ÇARE: hiç çağrı kurtarılamadıysa, dosya-adı etiketli ```kod bloklarını
     //    Write'a çevir (model build'de Write yerine kod yapıştırınca dosya kaybolmasın).
     //    Adım 7, gerçek tool-call YOKKEN çalışır → "kod göster"i bozmaz (etiket gerekir).

package/dist/theme.js

@@ -16,4 +16,4 @@ export const theme = {
     synType: '#a78bfa', // tip/sınıf adları, sabitler
     synProp: '#e0e0e0', // özellik/anahtar adları
 };
-export const VERSION = '1.0.160';
+export const VERSION = '1.0.162';

package/dist/tools.js

@@ -747,13 +747,11 @@ async function execOne(call, hooks) {
                 txt += 'Zafiyet bulunamadı (hedef temiz ya da yanıt vermedi).';
             else
                 txt += `${rep.found_count} bulgu:\n` + f.slice(0, 50).map((x) => '  ' + JSON.stringify(x)).join('\n');
-            // HYBRID: bu gömülü ilk-geçiştir. Modele, kullanıcıya derin taramayı TEKLİF ettir.
-            txt += '\n\n[hybrid-note] This was WormClaude\'s fast embedded first-pass scan. After reporting these'
-                + ' findings, OFFER the user (in their language) a deeper full scan with real tools'
-                + ' (nmap, nuclei, sqlmap, dalfox, ffuf), paired with the authorization reminder: for'
-                + ' educational/authorized use only — run it only if the user owns the target or holds a written'
-                + ' authorization document. Escalate ONLY if the user accepts AND has confirmed ownership/written'
-                + ' authorization (ask once if unstated).';
+            // HYBRID: bu gömülü ilk-geçiştir. Derin tarama = DETERMİNİSTİK /fullscan (model doğaçlamasın).
+            txt += `\n\n[hybrid-note] This was WormClaude's fast first-pass scan. For a COMPREHENSIVE scan, tell`
+                + ` the user to run the deterministic command "/fullscan ${target}" — it chains recon + XSS + SQLi`
+                + ` in one reliable, repeatable pass. Do NOT hand-orchestrate nmap/sqlmap yourself; recommend`
+                + ` /fullscan. Pair it with the authorization reminder (only on owned / written-authorized targets).`;
             return { ok: true, output: txt, args };
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wormclaude",
-  "version": "1.0.160",
+  "version": "1.0.162",
   "description": "WormClaude CLI - uncensored security+code assistant (ink TUI, Claude-style)",
   "type": "module",
   "bin": {