claude-flow 3.6.17 → 3.6.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.17",
+  "version": "3.6.19",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -73,7 +73,7 @@
     "@ruvector/rvf-wasm": "0.1.5",
     "@hono/node-server": ">=1.19.10",
     "flatted": ">=3.4.0",
-    "tar": ">=7.5.0",
+    "tar": ">=7.5.11",
     "picomatch": ">=4.0.3",
     "path-to-regexp": ">=8.2.1",
     "undici": ">=7.18.0",
@@ -81,7 +81,9 @@
     "@isaacs/brace-expansion": ">=5.0.1",
     "cacache": ">=20.0.0",
     "make-fetch-happen": ">=15.0.0",
-    "express-rate-limit": ">=8.4.1"
+    "express-rate-limit": ">=8.4.1",
+    "protobufjs": ">=7.5.5",
+    "uuid": ">=14.0.0"
   },
   "devDependencies": {
     "@openai/codex": "^0.98.0",

package/v3/@claude-flow/cli/dist/src/index.d.ts

@@ -4,6 +4,7 @@
  *
  * Created with ❤️ by ruv.io
  */
+import './log-filters.js';
 export declare const VERSION: string;
 export interface CLIOptions {
     name?: string;

package/v3/@claude-flow/cli/dist/src/index.js

@@ -4,6 +4,13 @@
  *
  * Created with ❤️ by ruv.io
  */
+// MUST be the first import — installs console filter for the cosmetic
+// "[AgentDB Patch] Controller index not found" warning before any
+// agentic-flow / agentdb code can load. ES module imports are evaluated
+// in source order, so this file runs its side effects before any other
+// import in this module's import graph (including transitive imports of
+// agentic-flow via commands/index.js).
+import './log-filters.js';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';

package/v3/@claude-flow/cli/dist/src/log-filters.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Console filter for the cosmetic "[AgentDB Patch] Controller index not found"
+ * warning emitted by agentic-flow's runtime patch (it expects agentdb v1.x
+ * layout but we use v3). This file MUST be imported as the first side-effect
+ * import in any entry point so the patch is in place before agentic-flow
+ * (and anything that transitively imports it) loads.
+ *
+ * The previous attempt put the suppression as a top-level code block inside
+ * src/index.ts, but ES module imports are evaluated before the file's own
+ * top-level code, so transitive imports of agentic-flow were still
+ * triggering the warning before the suppression took effect. A dedicated
+ * side-effect module imported FIRST avoids that.
+ *
+ * Tight match: requires BOTH "[AgentDB Patch]" AND "Controller index not
+ * found". Other [AgentDB Patch] messages (real issues) flow through.
+ * Audit log audit_1776483149979 flagged the previous broad filter as too
+ * aggressive — this one is tight enough to be safe.
+ */
+declare const isCosmeticAgentdbPatchNoise: (msg: unknown) => boolean;
+declare const origWarn: (message?: any, ...optionalParams: any[]) => void;
+declare const origLog: (message?: any, ...optionalParams: any[]) => void;
+//# sourceMappingURL=log-filters.d.ts.map

package/v3/@claude-flow/cli/dist/src/log-filters.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Console filter for the cosmetic "[AgentDB Patch] Controller index not found"
+ * warning emitted by agentic-flow's runtime patch (it expects agentdb v1.x
+ * layout but we use v3). This file MUST be imported as the first side-effect
+ * import in any entry point so the patch is in place before agentic-flow
+ * (and anything that transitively imports it) loads.
+ *
+ * The previous attempt put the suppression as a top-level code block inside
+ * src/index.ts, but ES module imports are evaluated before the file's own
+ * top-level code, so transitive imports of agentic-flow were still
+ * triggering the warning before the suppression took effect. A dedicated
+ * side-effect module imported FIRST avoids that.
+ *
+ * Tight match: requires BOTH "[AgentDB Patch]" AND "Controller index not
+ * found". Other [AgentDB Patch] messages (real issues) flow through.
+ * Audit log audit_1776483149979 flagged the previous broad filter as too
+ * aggressive — this one is tight enough to be safe.
+ */
+const isCosmeticAgentdbPatchNoise = (msg) => {
+    const s = String(msg ?? '');
+    return s.includes('[AgentDB Patch]') && s.includes('Controller index not found');
+};
+const origWarn = console.warn.bind(console);
+const origLog = console.log.bind(console);
+console.warn = (...args) => {
+    if (isCosmeticAgentdbPatchNoise(args[0]))
+        return;
+    origWarn(...args);
+};
+console.log = (...args) => {
+    if (isCosmeticAgentdbPatchNoise(args[0]))
+        return;
+    origLog(...args);
+};
+//# sourceMappingURL=log-filters.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/security-tools.js

@@ -18,6 +18,20 @@ const require = createRequire(import.meta.url);
 let aidefenceInstance = null;
 // Track if we've attempted install this session
 let installAttempted = false;
+// ADR-093 follow-up: wrapper-level counters for the lightweight aidefence
+// tools (has_pii, is_safe, scan-quick) that bypass the package's own
+// stats tracking. The audit flagged that aidefence_stats stayed at zero
+// regardless of detections from these paths. Stats now combine the
+// underlying defender.getStats() with our wrapper counters so the user
+// sees a true reflection of how often each tool category fired.
+const wrapperStats = {
+    hasPiiCalls: 0,
+    hasPiiHits: 0,
+    isSafeCalls: 0,
+    isSafeUnsafeVerdicts: 0,
+    quickScanCalls: 0,
+    quickScanThreats: 0,
+};
 /**
  * Get or create AIDefence instance (throws if unavailable)
  */
@@ -105,13 +119,27 @@ const aidefenceScanTool = {
             const defender = await getAIDefence();
             if (quick) {
                 const result = defender.quickScan(input);
+                // Audit-flagged: quickScan focuses on prompt-injection/jailbreak
+                // patterns and missed obvious PII (email + API key). Layer a fast
+                // PII check so quick mode catches both threat classes.
+                let piiPresent = false;
+                try {
+                    piiPresent = !!defender.hasPII(input);
+                }
+                catch { /* hasPII unavailable */ }
+                const threatDetected = result.threat || piiPresent;
+                wrapperStats.quickScanCalls++;
+                if (threatDetected)
+                    wrapperStats.quickScanThreats++;
                 return {
                     content: [{
                             type: 'text',
                             text: JSON.stringify({
-                                safe: !result.threat,
-                                threatDetected: result.threat,
+                                safe: !threatDetected,
+                                threatDetected,
                                 confidence: result.confidence,
+                                piiDetected: piiPresent,
+                                promptInjectionDetected: result.threat,
                                 mode: 'quick',
                             }, null, 2),
                         }],
@@ -249,11 +277,24 @@ const aidefenceStatsTool = {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
+                            // Underlying defender stats (from full detect() calls via aidefence_scan/aidefence_analyze)
                             detectionCount: stats.detectionCount,
                             avgDetectionTimeMs: stats.avgDetectionTimeMs,
                             learnedPatterns: stats.learnedPatterns,
                             mitigationStrategies: stats.mitigationStrategies,
                             avgMitigationEffectiveness: stats.avgMitigationEffectiveness,
+                            // ADR-093 follow-up: wrapper-level stats for the lightweight
+                            // tools that bypass the defender's own counters. Audit found
+                            // these stayed at 0 even after has_pii/is_safe/scan-quick
+                            // calls — these counters surface real activity.
+                            wrapper: {
+                                hasPiiCalls: wrapperStats.hasPiiCalls,
+                                hasPiiHits: wrapperStats.hasPiiHits,
+                                isSafeCalls: wrapperStats.isSafeCalls,
+                                isSafeUnsafeVerdicts: wrapperStats.isSafeUnsafeVerdicts,
+                                quickScanCalls: wrapperStats.quickScanCalls,
+                                quickScanThreats: wrapperStats.quickScanThreats,
+                            },
                         }, null, 2),
                     }],
             };
@@ -391,12 +432,29 @@ const aidefenceIsSafeTool = {
         }
         const input = args.input;
         try {
+            // Route through the singleton so wrapper stats track this call,
+            // and so a single defender controls both the prompt-injection model
+            // and the PII detector.
+            const defender = await getAIDefence();
             const { isSafe } = await import('@claude-flow/aidefence');
-            const safe = isSafe(input);
+            const promptSafe = isSafe(input);
+            let piiPresent = false;
+            try {
+                piiPresent = !!defender.hasPII(input);
+            }
+            catch { /* hasPII unavailable */ }
+            const safe = promptSafe && !piiPresent;
+            wrapperStats.isSafeCalls++;
+            if (!safe)
+                wrapperStats.isSafeUnsafeVerdicts++;
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify({ safe }, null, 2),
+                        text: JSON.stringify({
+                            safe,
+                            promptSafe,
+                            piiPresent,
+                        }, null, 2),
                     }],
             };
         }
@@ -437,6 +495,9 @@ const aidefenceHasPIITool = {
         try {
             const defender = await getAIDefence();
             const hasPII = defender.hasPII(input);
+            wrapperStats.hasPiiCalls++;
+            if (hasPII)
+                wrapperStats.hasPiiHits++;
             return {
                 content: [{
                         type: 'text',

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -1274,15 +1274,40 @@ export async function loadEmbeddingModel(options) {
         }
     }
     try {
-        // Try to import @xenova/transformers for ONNX embeddings
-        const transformers = await import('@xenova/transformers').catch(() => null);
-        if (transformers) {
+        // ADR-094: prefer @huggingface/transformers (clears protobufjs <7.5.5
+        // critical RCE chain), fall back to legacy @xenova/transformers.
+        // Inlined here rather than depending on @claude-flow/embeddings to
+        // avoid a circular optional-dep at install time; the logic mirrors
+        // @claude-flow/embeddings/src/transformers-loader.ts.
+        let transformersSource = null;
+        let pipelineFn = null;
+        {
+            const tryLoad = async (specifier) => {
+                try {
+                    return (await import(specifier));
+                }
+                catch {
+                    return null;
+                }
+            };
+            const hf = await tryLoad('@huggingface/transformers');
+            if (hf && typeof hf.pipeline === 'function') {
+                pipelineFn = hf.pipeline;
+                transformersSource = '@huggingface/transformers';
+            }
+            else {
+                const xen = await tryLoad('@xenova/transformers');
+                if (xen && typeof xen.pipeline === 'function') {
+                    pipelineFn = xen.pipeline;
+                    transformersSource = '@xenova/transformers';
+                }
+            }
+        }
+        if (pipelineFn && transformersSource) {
             if (verbose) {
-                console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
+                console.log(`Loading ONNX embedding model via ${transformersSource} (all-MiniLM-L6-v2)...`);
             }
-            // Use small, fast model for local embeddings
-            const { pipeline } = transformers;
-            const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            const embedder = await pipelineFn('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
             embeddingModelState = {
                 loaded: true,
                 model: embedder,

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.17",
+  "version": "3.6.19",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",