wormclaude 1.0.13 → 1.0.15

package/dist/agent.js

@@ -20,6 +20,7 @@ export async function runAgentLoop(opts) {
     const maxIters = opts.maxIters ?? 12;
     let finalText = '';
     let iter = 0;
+    let nudged = false;
     for (; iter < maxIters; iter++) {
         if (opts.signal?.aborted)
             break;
@@ -46,8 +47,16 @@ export async function runAgentLoop(opts) {
         messages.push(asMsg);
         if (assistantText.trim())
             finalText = assistantText.trim();
-        if (!toolCalls.length)
+        if (!toolCalls.length) {
+            // Nudge: model ne metin ne araç döndürdüyse bir kez "final sonucu ver" diye dürt.
+            if (!assistantText.trim() && !nudged) {
+                nudged = true;
+                messages.push({ role: 'user', content: 'Lütfen şimdi nihai sonucu metin olarak ver ve araç çağırmayı bırak.' });
+                continue;
+            }
             break;
+        }
+        nudged = false; // ilerleme oldu → nudge sıfırla
         // Paralel çalıştırma (salt-okunur araçlar eşzamanlı). Sonuçlar orijinal sırada.
         const results = await executeToolCalls(toolCalls, {
             onStart: (c) => opts.hooks?.onTool?.(c.name, undefined),

package/dist/api.js

@@ -2,6 +2,8 @@
 // Dayanıklılık: bağlantı kurulumunda exponential backoff + jitter retry.
 // Ö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 { safeJsonStringify } from './safejson.js';
 export function loadConfig() {
     const stored = loadStored();
     return {
@@ -93,7 +95,7 @@ export async function* streamChat(messages, tools, config, signal) {
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = '';
-    const toolAcc = {};
+    const toolParser = new StreamingToolCallParser();
     let usage;
     while (true) {
         if (signal?.aborted) {
@@ -147,17 +149,17 @@ export async function* streamChat(messages, tools, config, signal) {
             if (delta.tool_calls) {
                 for (const tc of delta.tool_calls) {
                     const idx = tc.index ?? 0;
-                    if (!toolAcc[idx])
-                        toolAcc[idx] = { id: tc.id || `call_${idx}`, name: '', args: '' };
-                    if (tc.id)
-                        toolAcc[idx].id = tc.id;
-                    if (tc.function?.name)
-                        toolAcc[idx].name += tc.function.name;
-                    if (tc.function?.arguments)
-                        toolAcc[idx].args += tc.function.arguments;
+                    toolParser.addChunk(idx, tc.function?.arguments || '', tc.id, tc.function?.name);
                 }
             }
         }
     }
-    yield { type: 'done', toolCalls: Object.values(toolAcc), usage };
+    // 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) => ({
+        id: c.id,
+        name: c.name,
+        args: safeJsonStringify(c.args),
+    }));
+    yield { type: 'done', toolCalls, usage };
 }

package/dist/auth.js

@@ -37,6 +37,16 @@ function apiOrigin(baseUrl) {
 }
 function openBrowser(url) {
     try {
+        // Güvenlik: yalnız http/https aç. (Windows 'start' rastgele şema/dosya açabilir; savunma.)
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return;
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return;
         let child;
         if (process.platform === 'win32') {
             child = spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });

package/dist/cli.js

@@ -6,6 +6,8 @@ import * as path from 'node:path';
 import { theme, VERSION } from './theme.js';
 import { loadConfig, streamChat } from './api.js';
 import { allToolSchemas, executeToolCalls, executeTool, toolLabel, setToolConfig } from './tools.js';
+import { sanitizeError, sanitizeOutput } from './errorsan.js';
+import { cleanModelText } from './textclean.js';
 import { summarizeTools } from './toolSummary.js';
 import { pickTipId, tipText } from './tips.js';
 import { t, cmdDesc, setLang, saveLang, loadLang, getLang } from './i18n.js';
@@ -535,13 +537,13 @@ function App() {
             for await (const ev of streamChat(historyRef.current, allToolSchemas(), config, ac.signal)) {
                 if (ev.type === 'text') {
                     assistantText += ev.text;
-                    setStreaming(assistantText);
+                    setStreaming(cleanModelText(assistantText));
                     setTokens(Math.round(assistantText.length / 4));
                 }
                 else if (ev.type === 'error') {
                     if (isContextError(ev.error))
                         gotCtxError = true;
-                    assistantText += `\n[hata: ${ev.error}]`;
+                    assistantText += `\n[hata: ${sanitizeError(ev.error)}]`;
                     setStreaming(assistantText);
                 }
                 else if (ev.type === 'done') {
@@ -550,6 +552,8 @@ 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);
             // Reactive compact: bağlam taştıysa bir kez özetle ve turu tekrar dene
             if (gotCtxError && !reactiveRetried) {
                 reactiveRetried = true;
@@ -613,7 +617,7 @@ function App() {
                 onResult: (c, _i, res) => {
                     if ((c.name === 'WebSearch' || c.name === 'WebFetch') && res.ok)
                         usedWeb = true;
-                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: res.output, ok: res.ok });
+                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: sanitizeOutput(res.output), ok: res.ok });
                 },
                 confirm: (c, args) => new Promise((resolve) => {
                     if (allowedToolsRef.current.has(c.name))

package/dist/cmdsec.js

@@ -0,0 +1,306 @@
+// Komut güvenliği — Bash aracı çalışmadan ÖNCE kontrol eder.
+// Gemini/Blackbox CLI shell-utils.js + shellReadOnlyChecker.js'ten uyarlandı, WormClaude'a özel.
+//   - Hard-deny blocklist (rm -rf /, fork bomb, dd of=/dev, mkfs, curl|bash...)
+//   - Command-substitution engeli ($(), <(), backtick) -> hard deny
+//   - Read-only allowlist (ls, cat, git status... -> izinsiz geçer)
+//   - Kalıcı kullanıcı allowlist'i (kök komut bazlı: "git", "npm")
+//   - escapeShellArg (PowerShell/cmd/bash) -> !{} injection güvenliği
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ── Kalıcı kullanıcı allowlist'i (kök komut: git, npm...) ───────────────────
+const ALLOW_FILE = path.join(os.homedir(), '.wormclaude', 'approved-commands.json');
+let _approved = null;
+function loadApproved() {
+    if (_approved)
+        return _approved;
+    try {
+        const arr = JSON.parse(fs.readFileSync(ALLOW_FILE, 'utf8'));
+        _approved = new Set(Array.isArray(arr) ? arr.map(String) : []);
+    }
+    catch {
+        _approved = new Set();
+    }
+    return _approved;
+}
+export function getApprovedCommands() { return [...loadApproved()].sort(); }
+function saveApproved(set) {
+    _approved = set;
+    try {
+        fs.mkdirSync(path.dirname(ALLOW_FILE), { recursive: true });
+        fs.writeFileSync(ALLOW_FILE, JSON.stringify([...set], null, 2));
+    }
+    catch { }
+}
+export function approveCommands(roots) {
+    const set = loadApproved();
+    const before = set.size;
+    for (const r of roots)
+        if (r)
+            set.add(r);
+    saveApproved(set);
+    return set.size - before;
+}
+export function unapproveCommands(roots) {
+    const set = loadApproved();
+    const before = set.size;
+    for (const r of roots)
+        set.delete(r);
+    saveApproved(set);
+    return before - set.size;
+}
+export function clearApproved() { saveApproved(new Set()); }
+// ── Komut ayrıştırma (shell-utils.js'ten) ──────────────────────────────────
+export function splitCommands(command) {
+    const commands = [];
+    let cur = '';
+    let inS = false, inD = false;
+    let i = 0;
+    while (i < command.length) {
+        const c = command[i], n = command[i + 1];
+        if (c === '\\' && i < command.length - 1) {
+            cur += c + n;
+            i += 2;
+            continue;
+        }
+        if (c === "'" && !inD)
+            inS = !inS;
+        else if (c === '"' && !inS)
+            inD = !inD;
+        if (!inS && !inD) {
+            if ((c === '&' && n === '&') || (c === '|' && n === '|')) {
+                commands.push(cur.trim());
+                cur = '';
+                i++;
+            }
+            else if (c === ';' || c === '&' || c === '|') {
+                commands.push(cur.trim());
+                cur = '';
+            }
+            else
+                cur += c;
+        }
+        else
+            cur += c;
+        i++;
+    }
+    if (cur.trim())
+        commands.push(cur.trim());
+    return commands.filter(Boolean);
+}
+export function getCommandRoot(command) {
+    const t = command.trim();
+    if (!t)
+        return undefined;
+    const m = t.match(/^"([^"]+)"|^'([^']+)'|^(\S+)/);
+    if (m) {
+        const root = m[1] || m[2] || m[3];
+        if (root)
+            return root.split(/[\\/]/).pop();
+    }
+    return undefined;
+}
+export function getCommandRoots(command) {
+    if (!command)
+        return [];
+    return splitCommands(command).map(getCommandRoot).filter((c) => !!c);
+}
+export function stripShellWrapper(command) {
+    const m = command.match(/^\s*(?:sh|bash|zsh|cmd\.exe|powershell|pwsh)\s+(?:\/c|-c|-Command)\s+/i);
+    if (m) {
+        let c = command.substring(m[0].length).trim();
+        if ((c.startsWith('"') && c.endsWith('"')) || (c.startsWith("'") && c.endsWith("'")))
+            c = c.slice(1, -1);
+        return c;
+    }
+    return command.trim();
+}
+// $(), <(), backtick komut-ikamesi tespiti (bash kurallarına göre)
+export function detectCommandSubstitution(command) {
+    let inS = false, inD = false, inB = false;
+    let i = 0;
+    while (i < command.length) {
+        const c = command[i], n = command[i + 1];
+        if (c === '\\' && !inS) {
+            i += 2;
+            continue;
+        }
+        if (c === "'" && !inD && !inB)
+            inS = !inS;
+        else if (c === '"' && !inS && !inB)
+            inD = !inD;
+        else if (c === '`' && !inS)
+            inB = !inB;
+        if (!inS) {
+            if (c === '$' && n === '(')
+                return true;
+            if (c === '<' && n === '(' && !inD && !inB)
+                return true;
+            if (c === '`' && !inB)
+                return true;
+        }
+        i++;
+    }
+    return false;
+}
+export function escapeShellArg(arg, shell = process.platform === 'win32' ? 'cmd' : 'bash') {
+    if (!arg)
+        return shell === 'bash' ? "''" : '""';
+    switch (shell) {
+        case 'powershell': return `'${arg.replace(/'/g, "''")}'`;
+        case 'cmd': return `"${arg.replace(/"/g, '""')}"`;
+        case 'bash':
+        default: return `'${arg.replace(/'/g, "'\\''")}'`;
+    }
+}
+// ── Tehlikeli komut blocklist (HARD DENY) ──────────────────────────────────
+const DANGER = [
+    { re: /\brm\s+(?:-[a-zA-Z]+\s+)*-[a-zA-Z]*[rf][a-zA-Z]*\s+(?:-[a-zA-Z]+\s+)*(?:\/|~|\$HOME|\*|\.)(?:\s|$)/, reason: 'Tehlikeli geniş silme (rm -rf /, ~, *, .)' },
+    { re: /:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/, reason: 'Fork bomb' },
+    { re: /\bmkfs(\.\w+)?\b/, reason: 'Dosya sistemi formatlama (mkfs)' },
+    { re: /\bdd\b[^\n]*\bof=\/dev\/(sd|nvme|hd|mmcblk|disk)/, reason: 'Diske ham yazma (dd of=/dev/...)' },
+    { re: />\s*\/dev\/(sd|nvme|hd|mmcblk|disk)/, reason: 'Blok aygıtına yazma (> /dev/sd...)' },
+    { re: /\bchmod\s+-R\s+0*777\s+\//, reason: 'Kök dizinde chmod -R 777 /' },
+    { re: /\bchown\s+-R\s+[^\s]+\s+\/(?:\s|$)/, reason: 'Kök dizinde chown -R' },
+    { re: /\b(?:curl|wget)\b[^\n|]*\|\s*(?:sudo\s+)?(?:bash|sh|zsh)\b/, reason: 'İnternetten indirip shell\'e pipe (curl|bash)' },
+    { re: /\b(?:shutdown|reboot|halt|poweroff|init\s+0)\b/, reason: 'Sistemi kapatma/yeniden başlatma' },
+    { re: /\bmv\s+[^\n]*\s+\/dev\/null\b/, reason: 'Veriyi /dev/null\'a taşıma' },
+    { re: />\s*\/dev\/null\s+2>&1\s*;\s*rm/, reason: 'Gizli silme' },
+];
+// ── Read-only komut tespiti (shellReadOnlyChecker.js'ten — sağlam) ──────────
+const READONLY_ROOTS = new Set([
+    'awk', 'basename', 'cat', 'cd', 'column', 'cut', 'df', 'dirname', 'du', 'echo', 'env', 'find',
+    'git', 'grep', 'egrep', 'fgrep', 'head', 'less', 'more', 'printenv', 'printf', 'ps', 'pwd', 'rg',
+    'ripgrep', 'sed', 'sort', 'stat', 'tail', 'tree', 'uniq', 'wc', 'which', 'where', 'whoami',
+    'id', 'hostname', 'uname', 'date', 'cal', 'uptime', 'file', 'realpath', 'nl', 'tac', 'cmp',
+    'md5sum', 'sha256sum', 'seq', 'test', 'true', 'false',
+    'node', 'python', 'python3', 'java', 'go', 'rustc', 'php', 'ruby', // yalnız --version
+    'npm', 'pnpm', 'yarn', 'pip', 'pip3', 'docker', 'kubectl', 'cargo', // yalnız read-only alt-komut
+]);
+// Alt-komutu read-only olanlar (yazan alt-komutlar — config/run/install — DAHİL DEĞİL)
+const READONLY_SUB = {
+    git: new Set(['blame', 'branch', 'cat-file', 'diff', 'grep', 'log', 'ls-files', 'remote', 'rev-parse', 'show', 'status', 'describe']),
+    npm: new Set(['ls', 'list', 'view', 'info', 'outdated', 'show', 'search', 'ping', 'whoami', 'doctor', 'why', 'audit']),
+    pnpm: new Set(['ls', 'list', 'view', 'outdated', 'why', 'audit']),
+    yarn: new Set(['list', 'info', 'why', 'outdated', 'audit']),
+    pip: new Set(['show', 'list', 'freeze', 'check']),
+    pip3: new Set(['show', 'list', 'freeze', 'check']),
+    docker: new Set(['ps', 'images', 'logs', 'inspect', 'version', 'info', 'stats', 'top', 'port', 'diff', 'history']),
+    kubectl: new Set(['get', 'describe', 'logs', 'top', 'explain', 'version', 'api-resources']),
+    cargo: new Set(['tree', 'search', 'metadata']),
+};
+const VERSION_ONLY = new Set(['node', 'python', 'python3', 'java', 'go', 'rustc', 'php', 'ruby']);
+const BLOCKED_FIND = new Set(['-delete', '-exec', '-execdir', '-ok', '-okdir']);
+const BLOCKED_FIND_PREFIX = ['-fprint'];
+const BLOCKED_GIT_REMOTE = new Set(['add', 'remove', 'rename', 'set-url', 'prune', 'update']);
+const BLOCKED_GIT_BRANCH = new Set(['-d', '-D', '--delete', '--move', '-m']);
+const ENV_ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+// Tırnak dışında '>' (yazma yönlendirmesi) -> read-only DEĞİL.
+function hasWriteRedirection(cmd) {
+    let inS = false, inD = false, esc = false;
+    for (const ch of cmd) {
+        if (esc) {
+            esc = false;
+            continue;
+        }
+        if (ch === '\\' && !inS) {
+            esc = true;
+            continue;
+        }
+        if (ch === "'" && !inD) {
+            inS = !inS;
+            continue;
+        }
+        if (ch === '"' && !inS) {
+            inD = !inD;
+            continue;
+        }
+        if (!inS && !inD && ch === '>')
+            return true;
+    }
+    return false;
+}
+function cmdIsReadOnly(single) {
+    const s = stripShellWrapper(single);
+    if (!s.trim())
+        return true;
+    if (detectCommandSubstitution(s))
+        return false;
+    if (hasWriteRedirection(s))
+        return false;
+    let tk = s.trim().split(/\s+/).filter(Boolean);
+    let i = 0;
+    while (i < tk.length && ENV_ASSIGN.test(tk[i]))
+        i++; // FOO=bar cmd -> atla
+    tk = tk.slice(i);
+    if (tk.length === 0)
+        return true;
+    const root = (tk[0].split(/[\\/]/).pop() || '').toLowerCase();
+    if (!READONLY_ROOTS.has(root))
+        return false;
+    const args = tk.slice(1);
+    if (VERSION_ONLY.has(root)) {
+        return args.some((a) => /^(--version|-v|-V|version)$/.test(a)) &&
+            !args.some((a) => a.startsWith('-') && !/^(-v|-V|--version)$/.test(a));
+    }
+    if (root === 'find') {
+        return !args.some((a) => BLOCKED_FIND.has(a.toLowerCase()) || BLOCKED_FIND_PREFIX.some((p) => a.toLowerCase().startsWith(p)));
+    }
+    if (root === 'sed') {
+        return !args.some((a) => a.startsWith('-i') || a === '--in-place');
+    }
+    if (READONLY_SUB[root]) {
+        let j = 0;
+        while (j < args.length && args[j].startsWith('-')) {
+            const f = args[j].toLowerCase();
+            if (f === '--version' || f === '--help')
+                return true;
+            j++;
+        }
+        if (j >= args.length)
+            return true;
+        const sub = args[j].toLowerCase();
+        if (!READONLY_SUB[root].has(sub))
+            return false;
+        const subArgs = args.slice(j + 1);
+        if (root === 'git' && sub === 'remote')
+            return !subArgs.some((a) => BLOCKED_GIT_REMOTE.has(a.toLowerCase()));
+        if (root === 'git' && sub === 'branch')
+            return !subArgs.some((a) => BLOCKED_GIT_BRANCH.has(a));
+        return true;
+    }
+    return true;
+}
+export function isShellCommandReadOnly(command) {
+    if (typeof command !== 'string' || !command.trim())
+        return false;
+    const segs = splitCommands(command);
+    return segs.length > 0 && segs.every(cmdIsReadOnly);
+}
+// ── Asıl güvenlik motoru ───────────────────────────────────────────────────
+export function checkCommand(rawCommand) {
+    const command = stripShellWrapper(String(rawCommand || ''));
+    const roots = getCommandRoots(command);
+    // 1) Command substitution -> HARD DENY
+    if (detectCommandSubstitution(command)) {
+        return { decision: 'deny', reason: 'Komut ikamesi ($(), <(), backtick) güvenlik nedeniyle engellendi', roots };
+    }
+    // 2) Tehlikeli blocklist -> HARD DENY
+    for (const d of DANGER) {
+        try {
+            if (d.re instanceof RegExp && d.re.test(command))
+                return { decision: 'deny', reason: d.reason, roots };
+        }
+        catch { }
+    }
+    // 3) Read-only -> izinsiz geç
+    if (isShellCommandReadOnly(command))
+        return { decision: 'allow', reason: 'read-only', roots };
+    // 4) Kullanıcı allowlist'i (tüm kökler onaylıysa) -> izinsiz geç
+    const approved = loadApproved();
+    if (roots.length > 0 && roots.every((r) => approved.has(r))) {
+        return { decision: 'allow', reason: 'kullanıcı onaylı', roots };
+    }
+    // 5) Kalan -> onay iste
+    return { decision: 'confirm', roots };
+}

package/dist/commands.js

@@ -10,6 +10,7 @@ import * as usage from './usage.js';
 import { runCompact, contextPercent, autoCompactThreshold } from './compact.js';
 import { cmdDesc, setLang, saveLang, getLang } from './i18n.js';
 import { loadSkills, getSkills, getSkillsDir, installSkill, updateSkill, removeSkill, getRegistry } from './skills.js';
+import { getApprovedCommands, approveCommands, unapproveCommands, clearApproved } from './cmdsec.js';
 import { isLearnEnabled, setLearnEnabled, getLearnFile, getLearnCount } from './learn.js';
 export const COMMANDS = [
     { name: '/help', desc: 'komutları ve ipuçlarını göster' },
@@ -36,6 +37,7 @@ export const COMMANDS = [
     { name: '/dream', desc: 'arka planda hafızayı konsolide et (.wormclaude/memory.md)' },
     { name: '/learn', desc: 'web-öğrenme datasını göster / aç-kapa (eğitim için)' },
     { name: '/copy', desc: 'son yaniti panoya kopyala (/copy all = tum sohbet)' },
+    { name: '/izinler', desc: 'onayli shell komutlarini yonet (list/add/remove/clear)' },
     { name: '/export', desc: 'sohbeti dosyaya kaydet' },
     { name: '/resume', desc: 'en son kaydedilen oturumu yükle' },
     { name: '/quit', desc: 'çıkış' },
@@ -537,6 +539,30 @@ export async function runSlashCommand(input, ctx) {
                 : 'Pano aracı yok (win: clip · mac: pbcopy · linux: xclip/wl-copy). /export ile dosyaya kaydedebilirsin.');
             return true;
         }
+        case '/izinler': {
+            const sub = (arg.split(/\s+/)[0] || '').toLowerCase();
+            const vals = arg.split(/\s+/).slice(1).filter(Boolean);
+            if (sub === 'add' && vals.length) {
+                const n = approveCommands(vals);
+                ctx.note(n > 0 ? `✓ ${n} komut onaylandı: ${vals.join(', ')}` : 'Belirtilenler zaten onaylıydı.');
+            }
+            else if (sub === 'remove' && vals.length) {
+                const n = unapproveCommands(vals);
+                ctx.note(n > 0 ? `✓ ${n} komut onaydan çıkarıldı.` : 'Belirtilenler onaylı listede yoktu.');
+            }
+            else if (sub === 'clear') {
+                clearApproved();
+                ctx.note('✓ Tüm onaylı komutlar temizlendi.');
+            }
+            else {
+                const list = getApprovedCommands();
+                const body = list.length ? list.map((c) => `  • ${c}`).join('\n') : '  (henüz yok — "Evet, hep" seçince eklenir)';
+                ctx.note(`Onaylı shell komutları (${list.length}) — bunlar onaysız çalışır:\n${body}\n\n` +
+                    `Kullanım:\n  /izinler              → listele\n  /izinler add git npm  → onayla\n  /izinler remove git   → çıkar\n  /izinler clear        → hepsini temizle\n` +
+                    `(Tehlikeli komutlar — rm -rf /, fork bomb vb. — onaylasan da engellenir.)`);
+            }
+            return true;
+        }
         case '/export': {
             fs.mkdirSync(SESSION_DIR, { recursive: true });
             const file = path.join(SESSION_DIR, `session-${tsStamp()}.json`);

package/dist/errorsan.js

@@ -0,0 +1,94 @@
+// Hata/çıktı temizleme: (1) gizli anahtar redaksiyonu, (2) backend kimlik maskeleme (white-label),
+// (3) OpenAI-tarzı JSON hata ayrıştırma, (4) dostça timeout mesajı.
+// Gemini errorSanitizer (sadece provider-maskeleme) + errorHandler'dan uyarlandı; gerçek secret-redaction eklendi.
+const PRODUCT = 'WormClaude';
+// ── (1) Gizli anahtar redaksiyonu ─────────────────────────────────────────────
+// Yalnız NET secret desenleri — kullanıcının normal metnini bozmamak için dar tutuldu.
+const SECRET_PATTERNS = [
+    [/\bwc_live_[A-Za-z0-9]{6,}/g, 'wc_live_[REDACTED]'],
+    [/\bwc_sk_[A-Za-z0-9]{6,}/g, 'wc_sk_[REDACTED]'],
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, 'sk-[REDACTED]'],
+    [/\bghp_[A-Za-z0-9]{20,}/g, 'ghp_[REDACTED]'],
+    [/\bAKIA[A-Z0-9]{16}\b/g, 'AKIA[REDACTED]'],
+    [/\b(Bearer)\s+[A-Za-z0-9._\-]{12,}/gi, '$1 [REDACTED]'],
+    // key/secret/token/password [:= veya boşluk] <değer>  (env dump, config echo)
+    [/\b(api[_-]?key|secret|token|password|passwd|vllm[_-]?key)\b(["']?\s*[:=\s]\s*["']?)([A-Za-z0-9._\-]{6,})/gi,
+        '$1$2[REDACTED]'],
+];
+// Agresif: çıplak uzun-hex anahtarlar (48+ hex). git SHA (40) ve kısa hash'leri KORUR.
+// SADECE hata mesajlarında kullanılır — tool çıktısında değil (git log SHA'larını bozmasın).
+const BARE_HEX = /\b[0-9a-f]{48,}\b/gi;
+export function redactSecrets(text, aggressive = false) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of SECRET_PATTERNS)
+        out = out.replace(re, rep);
+    if (aggressive)
+        out = out.replace(BARE_HEX, '[REDACTED]');
+    return out;
+}
+// ── (2) Backend kimlik maskeleme (white-label) ────────────────────────────────
+// SADECE backend-kaynaklı metne uygulanır (hata mesajları). Kullanıcının kendi içeriğine UYGULANMAZ
+// (ör. tool çıktısındaki "localhost" kullanıcının kendi dev sunucusu olabilir).
+const BACKEND_PATTERNS = [
+    [/\bQwen[0-9]?(?:\.[0-9]+)?-?[A-Za-z0-9.\-]*/gi, PRODUCT],
+    [/\bqwen[_-]?\w*/gi, PRODUCT],
+    [/\bvllm\b/gi, `${PRODUCT} engine`],
+    [/\bhermes\b/gi, `${PRODUCT}`],
+    [/\b127\.0\.0\.1(?::\d+)?/g, PRODUCT],
+    [/\b0\.0\.0\.0(?::\d+)?/g, PRODUCT],
+    [/\blocalhost:(?:8000|8001|8788)\b/gi, PRODUCT],
+];
+export function maskBackend(text) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of BACKEND_PATTERNS)
+        out = out.replace(re, rep);
+    return out;
+}
+// ── (3) OpenAI-tarzı JSON hata ayrıştırma ─────────────────────────────────────
+function parseApiError(text) {
+    const t = (text || '').trim();
+    // "HTTP 500: {...}" veya düz JSON gövde içinde {"error":{"message":...}}
+    const jsonStart = t.indexOf('{');
+    if (jsonStart === -1)
+        return text;
+    try {
+        const obj = JSON.parse(t.slice(jsonStart));
+        const msg = obj?.error?.message || obj?.message || obj?.detail;
+        if (typeof msg === 'string' && msg.trim()) {
+            const prefix = t.slice(0, jsonStart).trim();
+            return prefix ? `${prefix} ${msg}` : msg;
+        }
+    }
+    catch { /* JSON değil — olduğu gibi bırak */ }
+    return text;
+}
+// ── (4) Dostça timeout mesajı ─────────────────────────────────────────────────
+const TIMEOUT_HINTS = [
+    'timeout', 'timed out', 'connection timeout', 'read timeout',
+    'etimedout', 'esockettimedout', 'deadline exceeded', 'und_err_socket',
+];
+export function isTimeoutError(text) {
+    const t = (text || '').toLowerCase();
+    return TIMEOUT_HINTS.some((h) => t.includes(h));
+}
+function friendlyTimeout(text) {
+    return `${text}\n  • Girdiyi kısaltmayı veya bağlamı sadeleştirmeyi dene.\n  • Ağ bağlantını kontrol et.\n  • Sorun sürerse birkaç saniye sonra tekrar dene.`;
+}
+// ── Birleşik: kullanıcıya gösterilecek hata ───────────────────────────────────
+export function sanitizeError(input) {
+    let text = input instanceof Error ? input.message : String(input ?? '');
+    text = parseApiError(text);
+    text = maskBackend(text);
+    text = redactSecrets(text, true); // hata mesajı → agresif (çıplak hex dahil)
+    if (isTimeoutError(text))
+        text = friendlyTimeout(text);
+    return text.trim();
+}
+// Tool çıktısı için: yalnız gizli anahtar redaksiyonu (kimlik maskeleme YOK — kullanıcının kendi içeriği).
+export function sanitizeOutput(text) {
+    return redactSecrets(text);
+}

package/dist/extensions.js

@@ -11,6 +11,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { resolveInjections } from './injections.js';
 let EXTENSIONS = [];
 // Pakete gömülü extensions (npm ile gelir) + kullanıcı + proje dizinleri.
 const BUNDLED_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
@@ -121,15 +122,20 @@ export function getExtCommand(name) {
 export function getExcludedTools() {
     return [...new Set(EXTENSIONS.flatMap((x) => x.excludeTools))];
 }
-// Komut prompt'unu kök dizin referansı + kullanıcı argümanı ile birleştirir.
-// {{args}} placeholder'ı varsa onunla değişir; yoksa argüman sona eklenir.
+// Komut prompt'unu çözer: !{komut} (shell çıktısı, cmdsec'li) · @{dosya} (içerik) · {{args}}.
+// {{args}} placeholder'ı yoksa kullanıcı argümanı sona eklenir.
 export function buildExtCommandPrompt(cmd, args) {
-    let p = cmd.prompt;
-    if (p.includes('{{args}}')) {
-        p = p.replace(/\{\{args\}\}/g, args || '');
+    const a = args || '';
+    const hasArgsPlaceholder = cmd.prompt.includes('{{args}}');
+    let p;
+    try {
+        p = resolveInjections(cmd.prompt, { args: a, cwd: process.cwd(), contextName: cmd.name });
+    }
+    catch (e) {
+        p = cmd.prompt + `\n\n[injection hatası: ${e?.message || e}]`;
     }
-    else if (args && args.trim()) {
-        p += `\n\n## User input\n\n${args.trim()}`;
+    if (!hasArgsPlaceholder && a.trim()) {
+        p += `\n\n## User input\n\n${a.trim()}`;
     }
     return (`Extension base directory: ${cmd.dir}\n` +
         `(You may Read files here — templates/, context, assets — as needed to complete this command.)\n\n` +