wormclaude 1.0.90 → 1.0.92

package/dist/api.js

@@ -3,6 +3,7 @@
 // Ölçüm: usage (token) bilgisini 'done' olayında döndürür (billing için).
 import { loadStored, DEFAULT_BASE_URL } from './auth.js';
 import { StreamingToolCallParser } from './streamparser.js';
+import { recoverInlineToolCalls } from './inlinetools.js';
 import { safeJsonStringify } from './safejson.js';
 import { getTrace, getSession } from './telemetry.js';
 export function loadConfig() {
@@ -186,6 +187,7 @@ export async function* streamChat(messages, tools, config, signal) {
     let buf = '';
     const toolParser = new StreamingToolCallParser();
     let usage;
+    let fullText = ''; // model metne araç çağrısı gömerse sonda kurtarmak için
     while (true) {
         if (ac.signal.aborted && !timedOut) {
             try {
@@ -239,8 +241,10 @@ export async function* streamChat(messages, tools, config, signal) {
             const delta = j.choices?.[0]?.delta;
             if (!delta)
                 continue;
-            if (delta.content)
+            if (delta.content) {
+                fullText += delta.content;
                 yield { type: 'text', text: delta.content };
+            }
             if (delta.tool_calls) {
                 for (const tc of delta.tool_calls) {
                     const idx = tc.index ?? 0;
@@ -252,10 +256,16 @@ export async function* streamChat(messages, tools, config, signal) {
     clearTimer(); // akış normal bitti → zamanlayıcı + dinleyici temizle
     // Tamamlanan çağrıları sağlam biçimde topla; args'ı GEÇERLİ JSON string olarak emit et
     // (tools.ts tarafındaki JSON.parse artık asla patlamaz — onarım burada yapıldı).
-    const toolCalls = toolParser.getCompleted().map((c) => ({
+    let toolCalls = toolParser.getCompleted().map((c) => ({
         id: c.id,
         name: c.name,
         args: safeJsonStringify(c.args),
     }));
+    // Yedek: upstream yapısal tool_call vermediyse modelin metne gömdüğü çağrıyı kurtar.
+    if (toolCalls.length === 0 && fullText) {
+        const recovered = recoverInlineToolCalls(fullText);
+        if (recovered.length)
+            toolCalls = recovered;
+    }
     yield { type: 'done', toolCalls, usage };
 }

package/dist/cli.js

@@ -5,6 +5,7 @@ import TextInput from 'ink-text-input';
 import * as path from 'node:path';
 import { theme, VERSION } from './theme.js';
 import { loadConfig, streamChat, fetchAccount } from './api.js';
+import { stripInlineToolCalls } from './inlinetools.js';
 import { newTrace, flushTelemetry } from './telemetry.js';
 import { tier } from './program.js';
 import { allToolSchemas, executeToolCalls, executeTool, toolLabel, setToolConfig } from './tools.js';
@@ -722,6 +723,10 @@ function App() {
             setStreaming('');
             // Sızan özel-token / tool-call markup'ını bir kez temizle (hem geçmiş hem gösterim için).
             assistantText = cleanModelText(assistantText);
+            // Model araç çağrısını metne gömdüyse (inline kurtarma) → o JSON bloğunu gösterim+geçmişten çıkar.
+            if (toolCalls.some((t) => t.id?.startsWith('inline_'))) {
+                assistantText = stripInlineToolCalls(assistantText);
+            }
             // Reactive compact: bağlam taştıysa bir kez özetle ve turu tekrar dene
             if (gotCtxError && !reactiveRetried) {
                 reactiveRetried = true;

package/dist/commands.js

@@ -15,7 +15,7 @@ import { isLearnEnabled, setLearnEnabled, getLearnFile, getLearnCount } from './
 import { saveMemoryFact, getMemoryPath, loadMemoryContext } from './memory.js';
 import { fetchAccount, getVerifyStatus, submitVerification } from './api.js';
 import { programText, tier } from './program.js';
-import { runPentest } from './pentest.js';
+import { runPentest, fetchPtTools } from './pentest.js';
 export const COMMANDS = [
     { name: '/help', desc: 'komutları ve ipuçlarını göster' },
     { name: '/clear', desc: 'sohbeti ve geçmişi temizle' },
@@ -748,14 +748,26 @@ export async function runSlashCommand(input, ctx) {
                 await pentestCmd(sub, m.join(' '), ctx);
                 return true;
             }
-            ctx.note('Güvenlik tarama skill\'leri (seviye 3+ · motor sunucuda gizli):\n' +
-                '  /skill xss <url>          reflected XSS\n' +
-                '  /skill sqli <url>         SQL injection (error/boolean/time)\n' +
-                '  /skill recon <alan>       alt-alan + başlık + ifşa\n' +
-                '  /skill <şablon-id> <hedef>  sunucudaki özel şablonlar (.md)\n' +
-                'Çalıştırmak için sonuna "run" ekle:\n' +
-                '  /skill xss https://site/p?id=1 run\n' +
-                '(kısa yol: /xss /sqli /recon)');
+            // Canlı liste: dahili komutlar + admin'in eklediği özel şablonlar
+            const t = await fetchPtTools(ctx.config);
+            const lines = ['🛡️ Güvenlik tarama skill\'leri (motor sunucuda gizli):'];
+            if (t && !t.eligible) {
+                lines.push(`  ⚠ Seviyen ${t.trust} — gerekli: ${t.min_trust}+. Başvuru: /dogrula`);
+            }
+            else if (t) {
+                lines.push(`  Aylık kota: ${t.used}/${t.quota}`);
+            }
+            lines.push('  Dahili:');
+            const builtins = (t && t.tools) || { xss: 'reflected XSS', sqli: 'SQL injection', recon: 'keşif + ifşa' };
+            for (const [id, name] of Object.entries(builtins))
+                lines.push(`    /skill ${id} <hedef> run    ${name}`);
+            if (t && (t.templates || []).length) {
+                lines.push('  Özel şablonlar (admin):');
+                for (const tm of t.templates)
+                    lines.push(`    /skill ${tm.id} <hedef> run    ${tm.name || ''}${tm.severity ? ' [' + tm.severity + ']' : ''}`);
+            }
+            lines.push('Örnek:  /skill xss https://site/p?id=1 run   ·   kısa yol: /xss /sqli /recon');
+            ctx.note(lines.join('\n'));
             return true;
         }
         case '/export': {

package/dist/inlinetools.js

@@ -0,0 +1,87 @@
+// Model bazen araç çağrısını yapısal `tool_calls` yerine düz METİN (content) içine gömer
+// (yerel/abliterated modellerde sık). Tanınan biçimler:
+//   <tool_call>{"name":"Glob","arguments":{...}}</tool_call>
+//   ```json\n{"name":"Glob","arguments":{...}}\n```
+//   (tüm mesaj) {"name":"Glob","arguments":{...}}
+//   OpenAI: {"type":"function","function":{"name":...,"arguments":"{...}"}}
+// Bu modül o gömülü çağrıları kurtarır — upstream yapısal tool_call vermediğinde YEDEK.
+import { safeJsonParse } from './safejson.js';
+const ARG_KEYS = ['arguments', 'parameters', 'input', 'args', 'params'];
+function toToolCall(obj, i) {
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const src = obj.function && typeof obj.function === 'object' ? obj.function : obj;
+    const name = src.name || obj.name || obj.tool || obj.tool_name;
+    if (!name || typeof name !== 'string')
+        return null;
+    let args = undefined;
+    if (src.arguments !== undefined)
+        args = src.arguments;
+    else
+        for (const k of ARG_KEYS) {
+            if (obj[k] !== undefined) {
+                args = obj[k];
+                break;
+            }
+        }
+    if (typeof args === 'string')
+        args = safeJsonParse(args, {});
+    if (args === undefined || args === null)
+        args = {};
+    return { id: `inline_${i}`, name, args: JSON.stringify(args) };
+}
+function looksLikeCall(o) {
+    return !!o && typeof o === 'object' && (typeof o.name === 'string' || typeof o.tool === 'string' || (o.function && typeof o.function === 'object'));
+}
+/** 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) {
+    const t = (text || '').trim();
+    if (!t || (!t.includes('"name"') && !t.includes('"tool"') && !t.includes('"function"')))
+        return [];
+    const out = [];
+    const seen = new Set();
+    const push = (o) => {
+        const tc = toToolCall(o, out.length);
+        if (!tc)
+            return;
+        const k = tc.name + '|' + tc.args;
+        if (!seen.has(k)) {
+            seen.add(k);
+            out.push(tc);
+        }
+    };
+    // 1) <tool_call>...</tool_call>  (Hermes/Qwen)
+    for (const m of t.matchAll(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gi)) {
+        const o = safeJsonParse(m[1].trim(), null);
+        if (looksLikeCall(o))
+            push(o);
+    }
+    // 2) ```json / ```tool_call ... ```  (kod-bloğuna gömülü)
+    if (!out.length) {
+        for (const m of t.matchAll(/```(?:json|tool_call|tool|function)?\s*([\s\S]*?)```/gi)) {
+            const o = safeJsonParse(m[1].trim(), null);
+            if (looksLikeCall(o))
+                push(o);
+        }
+    }
+    // 3) Mesajın TAMAMI tek JSON çağrısı (sarmasız)
+    if (!out.length && t.startsWith('{') && t.endsWith('}')) {
+        const o = safeJsonParse(t, null);
+        if (looksLikeCall(o))
+            push(o);
+    }
+    return out;
+}
+/** Kurtarılan çağrı bloklarını GÖRÜNTÜ/geçmiş metninden temizler (çirkin JSON kalmasın). */
+export function stripInlineToolCalls(text) {
+    let s = text || '';
+    s = s.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '');
+    s = s.replace(/```(?:json|tool_call|tool|function)?\s*\{[\s\S]*?\}\s*```/gi, (blk) => {
+        return /"(name|tool|function)"/.test(blk) ? '' : blk; // yalnız çağrı-bloklarını sil
+    });
+    const tr = s.trim();
+    if (tr.startsWith('{') && tr.endsWith('}') && /"(name|tool|function)"/.test(tr))
+        return '';
+    return s.trim();
+}

package/dist/pentest.js

@@ -1,4 +1,19 @@
 const MAX_BODY = 262_144; // 256 KB cevap gövdesi üst sınırı
+// Kullanılabilir tarama skill'leri + kota durumu (dahili + admin şablonları) — keşif için.
+export async function fetchPtTools(config) {
+    try {
+        const r = await fetch(`${config.baseUrl}/pentest/tools`, {
+            headers: { ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}) },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!r.ok)
+            return null;
+        return await r.json();
+    }
+    catch {
+        return null;
+    }
+}
 async function postJson(config, p, body, timeoutMs) {
     try {
         const r = await fetch(`${config.baseUrl}${p}`, {

package/package.json

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