claude-flow 3.56.5 → 3.56.7

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

@@ -107,18 +107,38 @@ export function installMod(projectRoot, scope, dryRun = false, plugins = MOD_PLU
         backup = `${settingsFile}.bak-ruflo-mods-${Date.now()}`;
         copyFileSync(settingsFile, backup);
     }
-    writeJson(settingsFile, next);
-    // What ruflo added once is still ruflo's to remove: merge into the record.
-    const record = readRecord(projectRoot) ?? { version: 2, installedAt: '', files: {} };
-    const before = record.files[settingsFile] ?? { plugins: [], marketplace: false, env: false };
-    record.files[settingsFile] = {
-        plugins: [...new Set([...before.plugins, ...added.plugins])],
-        marketplace: before.marketplace || added.marketplace,
-        env: before.env || added.env,
-        claudeInstalled: before.claudeInstalled ?? [],
-    };
-    record.installedAt = new Date().toISOString();
-    writeJson(join(resolve(projectRoot), INSTALL_RECORD), record);
+    // One operation: the settings and the record that lets uninstall take them back are written together.
+    // If the record cannot be written, the settings go back as they were (or the file ruflo created goes
+    // away), so nothing is left half-installed with no record to remove it by.
+    try {
+        writeJson(settingsFile, next);
+        // What ruflo added once is still ruflo's to remove: merge into the record.
+        const record = readRecord(projectRoot) ?? { version: 2, installedAt: '', files: {} };
+        const before = record.files[settingsFile] ?? { plugins: [], marketplace: false, env: false };
+        record.files[settingsFile] = {
+            plugins: [...new Set([...before.plugins, ...added.plugins])],
+            marketplace: before.marketplace || added.marketplace,
+            env: before.env || added.env,
+            claudeInstalled: before.claudeInstalled ?? [],
+        };
+        record.installedAt = new Date().toISOString();
+        writeJson(join(resolve(projectRoot), INSTALL_RECORD), record);
+    }
+    catch (error) {
+        try {
+            if (backup) {
+                copyFileSync(backup, settingsFile);
+                unlinkSync(backup);
+            }
+            else if (existsSync(settingsFile)) {
+                unlinkSync(settingsFile);
+            }
+        }
+        catch {
+            // the restore itself failed: the original error below is the one to report
+        }
+        throw error;
+    }
     return { settingsFile, backup, added, dryRun, next };
 }
 /** The install record, v1 (3.50.0: one file, ruflo-mods only) read as v2. */

package/v3/@claude-flow/cli/dist/src/mods/plugin-resolve.js

@@ -160,7 +160,9 @@ export function resolveFindings(projectRoot, scope, configDir, fs = nodeReadFs,
         else if (!market.location) {
             findings.push(installed.installed
                 ? { name, status: 'pass', message: `installed (${installed.scope} scope, ${installed.installPath})` }
-                : { name, status: 'warn', message: plugin.required ? 'loads once Claude Code has cloned the marketplace' : 'pending: not released in the ruflo marketplace yet' });
+                : plugin.required
+                    ? { name, status: 'warn', message: 'loads once Claude Code has cloned the marketplace (a headless `claude -p` run on a fresh config does not clone it, so the mod is absent there)', fix }
+                    : { name, status: 'warn', message: 'pending: not released in the ruflo marketplace yet' });
         }
         else if (!plugin.required) {
             findings.push({ name, status: 'warn', message: `pending: not in the ruflo marketplace yet (${market.location})${also}` });

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

@@ -8,8 +8,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join, resolve } from 'node:path';
 import { findClaudeInstalls, judgeInstalls } from './claude-installs.js';
-import { ENABLE_ENV, MOD_PLUGIN_ID, MOD_PLUGIN_IDS, readRecord, readSettingsFile, settingsFileFor } from './install.js';
-import { claudeConfigDir, resolveFindings } from './plugin-resolve.js';
+import { ENABLE_ENV, MARKETPLACE_NAME, MOD_PLUGIN_ID, MOD_PLUGIN_IDS, readRecord, readSettingsFile, settingsFileFor } from './install.js';
+import { claudeConfigDir, installedState, resolveFindings } from './plugin-resolve.js';
 import { PROJECTION_RELATIVE } from './policy-projection.js';
 export const HANDSHAKE_MARKER = 'RUFLO_MODS_OWNS';
 export const HEARTBEAT_RELATIVE = join('.claude-flow', 'mods', 'session.json');
@@ -53,6 +53,65 @@ export function legacyCliHooks(files) {
         return commands(LEGACY_EVENTS[sub]).some((c) => word.test(c));
     });
 }
+/** Settings files (in the order given) where `enabledPlugins[id]` is exactly `value`. */
+function enabledValues(files, id) {
+    const out = new Map();
+    for (const f of files) {
+        try {
+            const v = get(readSettingsFile(f), 'enabledPlugins', id);
+            if (v !== undefined)
+                out.set(f, v);
+        }
+        catch {
+            // an unparseable file is reported elsewhere; never overwritten
+        }
+    }
+    return out;
+}
+function partialInstallFindings(root, files, _inputs) {
+    const enabled = new Set(MOD_PLUGIN_IDS.filter((id) => [...enabledValues(files, id).values()].includes(true)));
+    const out = [];
+    const parts = [];
+    if (enabled.size > 0 && enabled.size < MOD_PLUGIN_IDS.length) {
+        const missing = MOD_PLUGIN_IDS.filter((id) => !enabled.has(id) && ![...enabledValues(files, id).values()].includes(false));
+        if (missing.length)
+            parts.push(`enabled ${[...enabled].join(', ')} but not ${missing.join(', ')}`);
+    }
+    if (enabled.size > 0) {
+        const declared = files.some((f) => {
+            try {
+                return get(readSettingsFile(f), 'extraKnownMarketplaces', MARKETPLACE_NAME) !== undefined;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!declared)
+            parts.push(`no \`${MARKETPLACE_NAME}\` marketplace is declared in settings for Claude Code to load them from`);
+    }
+    const record = readRecord(root);
+    if (record) {
+        const lost = [];
+        for (const [file, added] of Object.entries(record.files)) {
+            try {
+                const now = readSettingsFile(file);
+                for (const id of added.plugins)
+                    if (get(now, 'enabledPlugins', id) !== true && get(now, 'enabledPlugins', id) !== false)
+                        lost.push(id);
+                if (added.marketplace && get(now, 'extraKnownMarketplaces', MARKETPLACE_NAME) === undefined)
+                    lost.push(`${MARKETPLACE_NAME} marketplace`);
+            }
+            catch {
+                // unreadable settings: nothing to compare
+            }
+        }
+        if (lost.length)
+            parts.push(`the install record says ruflo added ${[...new Set(lost)].join(', ')}, which the settings no longer have`);
+    }
+    if (parts.length)
+        out.push({ name: 'partial install', status: 'warn', message: parts.join('; '), fix: 'ruflo mods install' });
+    return out;
+}
 export function probeMods(inputs) {
     const root = resolve(inputs.projectRoot);
     const home = inputs.home ?? homedir();
@@ -69,9 +128,38 @@ export function probeMods(inputs) {
             return false;
         }
     });
+    // A plugin a person set to false is their decision: `ruflo mods install` never flips it, so it is not the repair.
+    const disabledIn = enabledIn ? undefined : files.find((f) => {
+        try {
+            return get(readSettingsFile(f), 'enabledPlugins', MOD_PLUGIN_ID) === false;
+        }
+        catch {
+            return false;
+        }
+    });
+    const cachedInstall = enabledIn || disabledIn ? { installed: false } : installedState(root, configDir, MOD_PLUGIN_ID, inputs.fs);
+    const scopeOf = (f) => (f === files[0] ? 'local' : f === files[1] ? 'project' : 'user');
     findings.push(enabledIn
         ? { name: 'ruflo-mods plugin', status: 'pass', message: `enabled in settings: ${enabledIn} (whether Claude Code can load it: see below)` }
-        : { name: 'ruflo-mods plugin', status: 'warn', message: 'not enabled; classic hooks handle every event', fix: 'ruflo mods install' });
+        : disabledIn
+            ? {
+                name: 'ruflo-mods plugin',
+                status: 'warn',
+                message: `disabled in ${disabledIn} (enabledPlugins is false): the mod does not load and classic hooks handle every event; \`ruflo mods install\` leaves a plugin you switched off alone`,
+                fix: `claude plugin enable ${MOD_PLUGIN_ID} --scope ${scopeOf(disabledIn)}`,
+            }
+            : cachedInstall.installed
+                ? {
+                    name: 'ruflo-mods plugin',
+                    status: 'warn',
+                    message: `installed (${cachedInstall.scope} scope) but not enabled in this project's settings: the mod does not load`,
+                    fix: `claude plugin enable ${MOD_PLUGIN_ID} --scope ${cachedInstall.scope === 'user' ? 'user' : 'local'}`,
+                }
+                : { name: 'ruflo-mods plugin', status: 'warn', message: 'not enabled; classic hooks handle every event', fix: 'ruflo mods install' });
+    // 1b. A half-finished install: some of the mod plugins enabled and not the rest, a plugin enabled with no
+    // marketplace declared for Claude Code to load it from, or keys the install record says ruflo added that
+    // the settings file no longer has. `ruflo mods install` is idempotent and adds exactly what is missing.
+    findings.push(...partialInstallFindings(root, files, inputs));
     // 1a. Enabled is a request; Claude Code silently skips a plugin its
     // marketplace clone does not carry (a clone older than the plugin).
     if (enabledIn) {
@@ -163,7 +251,7 @@ export function probeMods(inputs) {
     const owned = get(beat, 'owned');
     findings.push(typeof startedAt === 'string'
         ? { name: 'last mod start', status: 'pass', message: `${startedAt}, owning ${Array.isArray(owned) && owned.length ? owned.join(', ') : 'nothing'}` }
-        : { name: 'last mod start', status: enabledIn ? 'warn' : 'pass', message: 'the mod has not started in this project' + (enabledIn ? ' (restart Claude Code; check function hooks above)' : '') });
+        : { name: 'last mod start', status: enabledIn ? 'warn' : 'pass', message: 'the mod has not started in this project' + (enabledIn ? ' (restart Claude Code; check function hooks above)' : ''), ...(enabledIn ? { fix: 'restart Claude Code in this project, then run /ruflo mods' } : {}) });
     if (readRecord(root))
         findings.push({ name: 'install record', status: 'pass', message: join(root, '.claude-flow', 'mods', 'install.json') });
     return findings;

package/v3/@claude-flow/cli/dist/src/services/command-recording.d.ts

@@ -0,0 +1,17 @@
+/** Longest command text kept per row. */
+export declare const MAX_RECORDED_COMMAND_CHARS = 2000;
+/**
+ * True when command recording is switched off. Any one of these turns it off:
+ *   - `CLAUDE_FLOW_HOOKS_RECORD_COMMANDS` = 0 | false | off | no
+ *   - `CLAUDE_FLOW_HOOKS_ENABLED`         = 0 | false | off | no
+ *   - `hooks.recordCommands: false` in `claude-flow.config.json` or `.claude-flow/config.json`
+ */
+export declare function commandRecordingDisabled(env?: Record<string, string | undefined>, cwd?: string): boolean;
+/**
+ * The form of a command that may be written to the store: secrets of the
+ * common shapes replaced with `[redacted]`, and the text capped at
+ * `MAX_RECORDED_COMMAND_CHARS`. This is best effort, not a guarantee; the off
+ * switch is the guarantee.
+ */
+export declare function redactCommandForStorage(command: string): string;
+//# sourceMappingURL=command-recording.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/command-recording.js

@@ -0,0 +1,91 @@
+/**
+ * Policy for what the PostToolUse Bash hook may keep (#4056).
+ *
+ * `hooks post-command` used to store every command in full as
+ * `commands/cmd-<ts>`: 27k rows / 285 MB on one project, full command text
+ * that can carry tokens, and no way to switch it off. This module answers two
+ * questions for that writer:
+ *
+ *   1. May a command be recorded at all?  (`commandRecordingDisabled`)
+ *   2. What form of it may be stored?     (`redactCommandForStorage`)
+ *
+ * Every pattern below is bounded, and the input is capped before any pattern
+ * runs, so a hostile command cannot stall the hook (the same lesson as the
+ * settings-risk scanner, #4053).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Longest command text kept per row. */
+export const MAX_RECORDED_COMMAND_CHARS = 2000;
+/** Only this much of a command is ever scanned; the stored text is shorter still. */
+const MAX_SCANNED_CHARS = 8000;
+const OFF_VALUES = new Set(['0', 'false', 'off', 'no']);
+const isOff = (v) => v !== undefined && OFF_VALUES.has(v.trim().toLowerCase());
+function configDisablesRecording(cwd) {
+    for (const file of [
+        path.resolve(cwd, 'claude-flow.config.json'),
+        path.resolve(cwd, '.claude-flow', 'config.json'),
+    ]) {
+        try {
+            if (!fs.existsSync(file))
+                continue;
+            const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (raw?.hooks?.recordCommands === false)
+                return true;
+        }
+        catch {
+            /* malformed config: keep the default (recording on) rather than guess */
+        }
+    }
+    return false;
+}
+/**
+ * True when command recording is switched off. Any one of these turns it off:
+ *   - `CLAUDE_FLOW_HOOKS_RECORD_COMMANDS` = 0 | false | off | no
+ *   - `CLAUDE_FLOW_HOOKS_ENABLED`         = 0 | false | off | no
+ *   - `hooks.recordCommands: false` in `claude-flow.config.json` or `.claude-flow/config.json`
+ */
+export function commandRecordingDisabled(env = process.env, cwd = process.cwd()) {
+    if (isOff(env.CLAUDE_FLOW_HOOKS_RECORD_COMMANDS))
+        return true;
+    if (isOff(env.CLAUDE_FLOW_HOOKS_ENABLED))
+        return true;
+    return configDisablesRecording(cwd);
+}
+const QUOTED_OR_BARE = `"[^"]{0,512}"|'[^']{0,512}'|[^\\s"']{1,512}`;
+// Order matters little; each rule only ever shortens the text.
+const RULES = [
+    // Authorization: Bearer xyz   /   authorization=Basic xyz
+    [/(authorization["']?\s*[:=]\s*)(?:(?:bearer|basic|token)\s+)?[^\s"']{1,512}/gi, '$1[redacted]'],
+    // --password x / --token=x / --api-key "x" / -token x
+    [new RegExp(`(--?(?:password|passwd|pwd|token|secret|api[-_]?key|access[-_]?token|auth[-_]?token|client[-_]?secret)(?:=|\\s+))(?:${QUOTED_OR_BARE})`, 'gi'), '$1[redacted]'],
+    // NPM_TOKEN=x  AWS_SECRET_ACCESS_KEY=x  DB_PASSWORD=x
+    [new RegExp(`\\b([A-Za-z_][A-Za-z0-9_]{0,63}(?:TOKEN|SECRET|PASSWORD|PASSWD|API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|CREDENTIALS?))=(?:${QUOTED_OR_BARE})`, 'gi'), '$1=[redacted]'],
+    // user:password@host in a URL
+    [/(:\/\/[^\s:@/]{1,128}:)[^\s@/]{1,256}(@)/g, '$1[redacted]$2'],
+    // well-known token shapes
+    [/\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[abprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|npm_[A-Za-z0-9]{20,}|eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,})/g, '[redacted]'],
+];
+/**
+ * The form of a command that may be written to the store: secrets of the
+ * common shapes replaced with `[redacted]`, and the text capped at
+ * `MAX_RECORDED_COMMAND_CHARS`. This is best effort, not a guarantee; the off
+ * switch is the guarantee.
+ */
+export function redactCommandForStorage(command) {
+    let text = String(command);
+    if (text.length > MAX_SCANNED_CHARS) {
+        // Cut at a token boundary so a half-token at the cut is not left behind.
+        const cut = text.slice(0, MAX_SCANNED_CHARS);
+        const lastSpace = cut.search(/\s\S*$/);
+        text = lastSpace > 0 ? cut.slice(0, lastSpace) : cut;
+        text += ' ';
+    }
+    for (const [re, replacement] of RULES)
+        text = text.replace(re, replacement);
+    if (text.length > MAX_RECORDED_COMMAND_CHARS) {
+        text = `${text.slice(0, MAX_RECORDED_COMMAND_CHARS)} …[truncated]`;
+    }
+    return text.trimEnd();
+}
+//# sourceMappingURL=command-recording.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.56.5",
+  "version": "3.56.7",
   "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",
@@ -98,13 +98,13 @@
     "vitest": "^4.1.0"
   },
   "dependencies": {
-    "@claude-flow/cli-core": "3.7.0",
-    "@claude-flow/codex": "3.0.3",
+    "@claude-flow/cli-core": "3.7.1",
+    "@claude-flow/codex": "3.0.4",
     "@claude-flow/mcp": "3.1.1",
     "@claude-flow/neural": "3.0.0",
     "@claude-flow/plugin-agent-federation": "1.0.1",
     "@claude-flow/security": "3.0.4",
-    "@claude-flow/shared": "3.0.2",
+    "@claude-flow/shared": "3.0.3",
     "@iarna/toml": "^2.2.5",
     "@noble/ed25519": "2.3.0",
     "@ruvector/rabitq-wasm": "0.1.0",

package/v3/@claude-flow/shared/dist/events/rvf-event-log.js

@@ -69,6 +69,12 @@ export class RvfEventLog extends EventEmitter {
     async initialize() {
         if (this.initialized)
             return;
+        // A failed prior replay may have populated only part of the indexes.
+        // Every initialization attempt must rebuild from an empty state.
+        this.events = [];
+        this.aggregateIndex.clear();
+        this.aggregateVersions.clear();
+        this.snapshots.clear();
         this.ensureDirectory(this.config.logPath);
         // --- events file ---
         if (existsSync(this.config.logPath)) {
@@ -129,10 +135,10 @@ export class RvfEventLog extends EventEmitter {
         const nextVersion = currentVersion + 1;
         event.version = nextVersion;
         // Persist to disk first (crash-safe ordering)
-        this.appendRecord(this.config.logPath, event);
+        const persisted = this.appendRecord(this.config.logPath, event);
         // Update in-memory state
-        this.indexEvent(event);
-        this.emit('event:appended', event);
+        this.indexEvent(persisted);
+        this.emit('event:appended', structuredClone(persisted));
         if (nextVersion % this.config.snapshotThreshold === 0) {
             this.emit('snapshot:recommended', {
                 aggregateId: event.aggregateId,
@@ -143,9 +149,9 @@ export class RvfEventLog extends EventEmitter {
     /** Save a snapshot for an aggregate. */
     async saveSnapshot(snapshot) {
         this.ensureInitialized();
-        this.appendRecord(this.snapshotPath, snapshot);
-        this.snapshots.set(snapshot.aggregateId, snapshot);
-        this.emit('snapshot:saved', snapshot);
+        const persisted = this.appendRecord(this.snapshotPath, snapshot);
+        this.snapshots.set(persisted.aggregateId, persisted);
+        this.emit('snapshot:saved', structuredClone(persisted));
     }
     // ===========================================================================
     // Read Operations
@@ -156,7 +162,7 @@ export class RvfEventLog extends EventEmitter {
         const indices = this.aggregateIndex.get(aggregateId);
         if (!indices || indices.length === 0)
             return [];
-        let result = indices.map((i) => this.events[i]);
+        let result = indices.map((i) => structuredClone(this.events[i]));
         if (fromVersion !== undefined) {
             result = result.filter((e) => e.version >= fromVersion);
         }
@@ -168,9 +174,9 @@ export class RvfEventLog extends EventEmitter {
     async getAllEvents(filter) {
         this.ensureInitialized();
         if (!filter) {
-            return [...this.events].sort((a, b) => a.timestamp - b.timestamp);
+            return structuredClone(this.events).sort((a, b) => a.timestamp - b.timestamp);
         }
-        let result = [...this.events];
+        let result = structuredClone(this.events);
         // Aggregate ID filter
         if (filter.aggregateIds && filter.aggregateIds.length > 0) {
             const set = new Set(filter.aggregateIds);
@@ -203,7 +209,7 @@ export class RvfEventLog extends EventEmitter {
         if (filter.offset) {
             result = result.slice(filter.offset);
         }
-        if (filter.limit) {
+        if (filter.limit !== undefined) {
             result = result.slice(0, filter.limit);
         }
         return result;
@@ -211,7 +217,7 @@ export class RvfEventLog extends EventEmitter {
     /** Get latest snapshot for an aggregate. */
     async getSnapshot(aggregateId) {
         this.ensureInitialized();
-        return this.snapshots.get(aggregateId) ?? null;
+        return structuredClone(this.snapshots.get(aggregateId) ?? null);
     }
     /** Return event store statistics. */
     async getStats() {
@@ -301,10 +307,12 @@ export class RvfEventLog extends EventEmitter {
     /** Append a single record to an RVF file. */
     appendRecord(filePath, record) {
         const json = JSON.stringify(record);
+        const persisted = JSON.parse(json);
         const payload = Buffer.from(json, 'utf8');
         const lengthBuf = Buffer.allocUnsafe(LENGTH_PREFIX_BYTES);
         lengthBuf.writeUInt32BE(payload.length, 0);
         appendFileSync(filePath, Buffer.concat([lengthBuf, payload]));
+        return persisted;
     }
     /** Add an event to the in-memory indexes. */
     indexEvent(event) {

package/v3/@claude-flow/shared/dist/resilience/circuit-breaker.js

@@ -112,9 +112,9 @@ export class CircuitBreaker extends EventEmitter {
             successes: this.requests.filter((r) => r.success).length,
             totalRequests: this.requests.length,
             rejectedRequests: this.rejectedCount,
-            lastFailure: this.lastFailure,
-            lastSuccess: this.lastSuccess,
-            openSince: this.openedAt,
+            lastFailure: this.lastFailure ? new Date(this.lastFailure.getTime()) : null,
+            lastSuccess: this.lastSuccess ? new Date(this.lastSuccess.getTime()) : null,
+            openSince: this.openedAt ? new Date(this.openedAt.getTime()) : null,
         };
     }
     /**
@@ -138,6 +138,7 @@ export class CircuitBreaker extends EventEmitter {
      * Handle successful request
      */
     onSuccess() {
+        this.cleanOldRequests();
         this.lastSuccess = new Date();
         this.requests.push({ timestamp: Date.now(), success: true });
         if (this.state === CircuitBreakerState.HALF_OPEN) {
@@ -152,6 +153,7 @@ export class CircuitBreaker extends EventEmitter {
      * Handle failed request
      */
     onFailure(error) {
+        this.cleanOldRequests();
         this.lastFailure = new Date();
         this.requests.push({ timestamp: Date.now(), success: false });
         if (this.state === CircuitBreakerState.HALF_OPEN) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/shared",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "type": "module",
   "description": "Shared module - common types, events, utilities, core interfaces",
   "main": "dist/index.js",