claude-flow 3.32.1 → 3.32.8

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

@@ -0,0 +1,68 @@
+/**
+ * meta-proxy release verification (ADR-307) — mirrors src/init/helper-signing.ts's
+ * raw-EdDSA `crypto.verify(null, ...)` pattern almost exactly, and matches the
+ * exact scheme confirmed live 2026-07-16 against a real v0.1.0 release: ONE
+ * combined `SHA256SUMS.sig` (raw Ed25519 over the `SHA256SUMS` file's bytes,
+ * base64-encoded — not a per-binary signature), then a per-asset SHA-256
+ * check against the matching `SHA256SUMS` line. Refuse-all-or-nothing on any
+ * mismatch, same discipline as `writeCriticalHelpers()`.
+ *
+ * @module proxy/verify
+ */
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+/**
+ * meta-proxy's committed release-signing public key (SPKI PEM), confirmed
+ * live 2026-07-16 by verifying a real `SHA256SUMS.sig` from the v0.1.0
+ * release against it (crypto.verify -> true).
+ */
+export const PROXY_RELEASE_PUBKEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAjhLDomjIGdcltYC7j+aiESQFD4LWoHaULietG1PuDjw=
+-----END PUBLIC KEY-----`;
+export class ReleaseVerificationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReleaseVerificationError';
+    }
+}
+/** Raw EdDSA verify of `SHA256SUMS.sig` (base64) over `SHA256SUMS`'s exact bytes. */
+export function verifySha256SumsSignature(sumsBytes, sigBase64, pubkeyPem = PROXY_RELEASE_PUBKEY_PEM) {
+    const pubkey = createPublicKey(pubkeyPem);
+    const sig = Buffer.from(sigBase64.trim(), 'base64');
+    return cryptoVerify(null, sumsBytes, pubkey, sig);
+}
+/** Parses `<sha256>  <filename>` lines (sha256sum's own output format). */
+export function parseSha256Sums(sumsText) {
+    const result = {};
+    for (const line of sumsText.split(/\r?\n/)) {
+        const match = line.match(/^([0-9a-f]{64})\s+(.+)$/i);
+        if (!match)
+            continue;
+        result[match[2]] = match[1].toLowerCase();
+    }
+    return result;
+}
+export function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+/**
+ * Full verification: signature over SHA256SUMS, then the asset's own hash
+ * against the matching line. Throws `ReleaseVerificationError` on ANY
+ * failure — there is no partial-trust outcome, matching ADR-307's "refuses
+ * on any mismatch" requirement.
+ */
+export function verifyRelease(input) {
+    if (!verifySha256SumsSignature(input.sumsBytes, input.sigBase64, input.pubkeyPem)) {
+        throw new ReleaseVerificationError('SHA256SUMS.sig failed Ed25519 verification — refusing to install');
+    }
+    const sums = parseSha256Sums(input.sumsBytes.toString('utf-8'));
+    const expected = sums[input.assetFilename];
+    if (!expected) {
+        throw new ReleaseVerificationError(`SHA256SUMS has no entry for ${input.assetFilename}`);
+    }
+    const actual = sha256Hex(input.assetBytes);
+    if (actual !== expected) {
+        throw new ReleaseVerificationError(`sha256 mismatch for ${input.assetFilename}: expected ${expected.slice(0, 12)}…, got ${actual.slice(0, 12)}…`);
+    }
+    return { sha256: actual };
+}
+//# sourceMappingURL=verify.js.map

package/v3/@claude-flow/cli/dist/src/security/builtin-aidefence.d.ts

@@ -0,0 +1,34 @@
+export interface BuiltinThreat {
+    type: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    description: string;
+    confidence: number;
+}
+export interface DefenceResult {
+    safe: boolean;
+    threats: BuiltinThreat[];
+    piiFound: boolean;
+    detectionTimeMs: number;
+    inputHash: string;
+}
+export interface DefenceEngine {
+    detect(input: string): Promise<DefenceResult>;
+    quickScan(input: string): {
+        threat: boolean;
+        confidence: number;
+        type?: string;
+    };
+    getStats(): Promise<{
+        detectionCount: number;
+        avgDetectionTimeMs: number;
+        learnedPatterns: number;
+        mitigationStrategies: number;
+        avgMitigationEffectiveness: number;
+    }>;
+    getBestMitigation(type: string): Promise<{
+        strategy: string;
+        effectiveness: number;
+    } | null>;
+}
+export declare function createBuiltinAIDefence(): DefenceEngine;
+//# sourceMappingURL=builtin-aidefence.d.ts.map

package/v3/@claude-flow/cli/dist/src/security/builtin-aidefence.js

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+const THREAT_PATTERNS = [
+    {
+        type: 'prompt-injection',
+        severity: 'high',
+        confidence: 0.96,
+        description: 'Attempts to override or discard trusted instructions',
+        pattern: /\b(?:ignore|disregard|forget|override)\b[\s\S]{0,40}\b(?:previous|prior|system|developer|trusted)\b[\s\S]{0,24}\b(?:instructions?|prompts?|rules?|messages?)\b/i,
+    },
+    {
+        type: 'system-prompt-extraction',
+        severity: 'high',
+        confidence: 0.94,
+        description: 'Attempts to reveal hidden system or developer instructions',
+        pattern: /\b(?:reveal|show|print|repeat|dump|expose)\b[\s\S]{0,32}\b(?:system|developer|hidden|initial)\b[\s\S]{0,20}\b(?:prompt|message|instructions?)\b/i,
+    },
+    {
+        type: 'jailbreak',
+        severity: 'high',
+        confidence: 0.91,
+        description: 'Attempts to bypass model safeguards or enter an unrestricted mode',
+        pattern: /\b(?:developer mode|DAN mode|jailbreak|bypass (?:all )?(?:safeguards|restrictions|filters)|unrestricted mode)\b/i,
+    },
+    {
+        type: 'data-exfiltration',
+        severity: 'critical',
+        confidence: 0.93,
+        description: 'Attempts to transmit secrets or credentials to an external destination',
+        pattern: /\b(?:send|upload|post|exfiltrate|transmit)\b[\s\S]{0,48}\b(?:secret|credential|password|api key|token|private key)\b/i,
+    },
+];
+const PII_PATTERNS = [
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
+    /\b\d{3}-\d{2}-\d{4}\b/,
+    /\b(?:sk-|ghp_|xox[baprs]-)[A-Za-z0-9_-]{16,}\b/,
+    /\bAKIA[A-Z0-9]{16}\b/,
+];
+export function createBuiltinAIDefence() {
+    let detectionCount = 0;
+    let totalDetectionTimeMs = 0;
+    const scan = (input) => THREAT_PATTERNS
+        .filter(({ pattern }) => pattern.test(input))
+        .map(({ pattern: _pattern, ...threat }) => threat);
+    return {
+        async detect(input) {
+            const startedAt = performance.now();
+            const threats = scan(input);
+            const piiFound = PII_PATTERNS.some((pattern) => pattern.test(input));
+            const detectionTimeMs = performance.now() - startedAt;
+            detectionCount++;
+            totalDetectionTimeMs += detectionTimeMs;
+            return {
+                safe: threats.length === 0 && !piiFound,
+                threats,
+                piiFound,
+                detectionTimeMs,
+                inputHash: createHash('sha256').update(input).digest('hex'),
+            };
+        },
+        quickScan(input) {
+            const threat = scan(input)[0];
+            return threat
+                ? { threat: true, confidence: threat.confidence, type: threat.type }
+                : { threat: false, confidence: 0 };
+        },
+        async getStats() {
+            return {
+                detectionCount,
+                avgDetectionTimeMs: detectionCount === 0 ? 0 : totalDetectionTimeMs / detectionCount,
+                learnedPatterns: 0,
+                mitigationStrategies: 4,
+                avgMitigationEffectiveness: 0.9,
+            };
+        },
+        async getBestMitigation(type) {
+            const strategies = {
+                'prompt-injection': 'Keep trusted instructions immutable and reject instruction overrides',
+                'system-prompt-extraction': 'Do not disclose system or developer messages',
+                jailbreak: 'Apply the configured policy without adopting alternate personas',
+                'data-exfiltration': 'Block external transmission and rotate exposed credentials',
+            };
+            return strategies[type] ? { strategy: strategies[type], effectiveness: 0.9 } : null;
+        },
+    };
+}
+//# sourceMappingURL=builtin-aidefence.js.map

package/v3/@claude-flow/cli/dist/src/services/fable-harness.d.ts

@@ -90,6 +90,7 @@ export interface ReflectResult {
 export interface CoPilotSnapshot {
     security?: {
         status: string;
+        findings?: number;
         cvesFixed: number;
         totalCves: number;
     };

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.1",
+  "version": "3.32.8",
   "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",
@@ -112,7 +112,7 @@
   },
   "optionalDependencies": {
     "@claude-flow/memory": "^3.0.0-alpha.21",
-    "@claude-flow/security": "^3.0.0-alpha.10",
+    "@claude-flow/security": "^3.0.0-alpha.12",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
     "ruvector": "^0.2.27"