claude-flow 3.47.1 → 3.49.0

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

@@ -9,7 +9,7 @@
  *
  * @module v3/cli/mcp-tools/memory-tools
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join, resolve } from 'path';
 import { createHash } from 'crypto';
@@ -42,7 +42,15 @@ const MAX_QUERY_LENGTH = 4096;
 // validateMemoryInput. Imported by sanitizeMemoryKey so write-side sanitization
 // and read-side rejection can never drift apart (the symmetry bug behind #1884).
 const DANGEROUS_KEY_CHARS = /[;&|`$(){}[\]<>!#\\\0]|\.\.[/\\]/g;
-const DANGEROUS_KEY_PATTERN = /[;&|`$(){}[\]<>!#\\\0]|\.\.[/\\]/;
+export const DANGEROUS_KEY_PATTERN = /[;&|`$(){}[\]<>!#\\\0]|\.\.[/\\]/;
+/**
+ * #3570: the one key rule for every memory write path (MCP store, CLI store,
+ * import). Plain `/` stays legal (`probe/x`); traversal and shell metacharacters
+ * do not. Returns the error message, or null when the key is acceptable.
+ */
+export function memoryKeyError(key) {
+    return DANGEROUS_KEY_PATTERN.test(key) ? 'Key contains disallowed characters' : null;
+}
 function validateMemoryInput(key, value, query, namespace) {
     if (key && key.length > MAX_KEY_LENGTH) {
         throw new Error(`Key exceeds maximum length of ${MAX_KEY_LENGTH} characters`);
@@ -54,9 +62,9 @@ function validateMemoryInput(key, value, query, namespace) {
         throw new Error(`Query exceeds maximum length of ${MAX_QUERY_LENGTH} characters`);
     }
     // Reject path traversal and shell metacharacters in keys/namespaces (#1425)
-    if (key && DANGEROUS_KEY_PATTERN.test(key)) {
-        throw new Error('Key contains disallowed characters');
-    }
+    const keyError = key ? memoryKeyError(key) : null;
+    if (keyError)
+        throw new Error(keyError);
     if (namespace && DANGEROUS_KEY_PATTERN.test(namespace)) {
         throw new Error('Namespace contains disallowed characters');
     }
@@ -273,11 +281,11 @@ const MEMORY_STATS_MAX_PAGES = 200;
  * breakdown and embedding coverage computed from a prefix, and a listing
  * that reported `success: false` was read as an empty one.
  */
-async function collectAllEntries(listEntries) {
+async function collectAllEntries(listEntries, dbPath) {
     const entries = [];
     let total = 0;
     for (let page = 0; page < MEMORY_STATS_MAX_PAGES; page++) {
-        const result = await listEntries({ limit: MEMORY_STATS_PAGE, offset: entries.length });
+        const result = await listEntries({ limit: MEMORY_STATS_PAGE, offset: entries.length, dbPath });
         if (!result.success) {
             return { success: false, entries, total: result.total ?? total, error: result.error };
         }
@@ -300,10 +308,10 @@ function memoryStatsUnavailable(error) {
  * WAL frames, so it is allowed to fail without that meaning the store is
  * missing — which is exactly the conflation #3311 reports.
  */
-async function readMemoryStatusLabels() {
+async function readMemoryStatusLabels(dbPath) {
     try {
         const { checkMemoryInitialization } = await getMemoryFunctions();
-        const status = await checkMemoryInitialization();
+        const status = await checkMemoryInitialization(dbPath);
         return { version: status.version, features: status.features };
     }
     catch {
@@ -315,37 +323,43 @@ async function readMemoryStatusLabels() {
  * #1606: Wrapped in try/catch to prevent process-level crashes that kill
  * the stdio MCP transport on Windows/Codex.
  */
-async function ensureInitialized() {
+async function ensureInitialized(dbPath) {
     try {
         const { initializeMemoryDatabase, checkMemoryInitialization, storeEntry } = await getMemoryFunctions();
         // Check if already initialized
-        const status = await checkMemoryInitialization();
+        const status = await checkMemoryInitialization(dbPath);
         if (!status.initialized) {
-            await initializeMemoryDatabase({ force: false, verbose: false });
+            await initializeMemoryDatabase({ force: false, verbose: false, dbPath });
         }
         // Migrate legacy JSON data if exists (from old .claude-flow/memory/ location)
+        // A custom import target must not consume the one-time migration marker
+        // for the project's normal memory store.
         if (hasLegacyStore()) {
-            const legacyStore = loadLegacyStore();
-            if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
-                console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
-                let migrated = 0;
-                for (const [key, entry] of Object.entries(legacyStore.entries)) {
-                    try {
-                        const value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
-                        await storeEntry({
-                            key,
-                            value,
-                            namespace: 'default',
-                            generateEmbeddingFlag: true,
-                        });
-                        migrated++;
-                    }
-                    catch (e) {
-                        console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
+            const { resolveDbPath } = await import('../memory/memory-initializer.js');
+            if (!dbPath || dbPath === resolveDbPath()) {
+                const legacyStore = loadLegacyStore();
+                if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
+                    console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
+                    let migrated = 0;
+                    for (const [key, entry] of Object.entries(legacyStore.entries)) {
+                        try {
+                            const value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
+                            await storeEntry({
+                                key,
+                                value,
+                                namespace: 'default',
+                                generateEmbeddingFlag: true,
+                                dbPath,
+                            });
+                            migrated++;
+                        }
+                        catch (e) {
+                            console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
+                        }
                     }
+                    console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
+                    markMigrationComplete();
                 }
-                console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
-                markMigrationComplete();
             }
         }
     }
@@ -407,6 +421,11 @@ export const memoryTools = [
                 };
             }
             validateMemoryInput(key, value, undefined, namespace);
+            // #3570: a namespace written here must be exportable and purgeable, so it
+            // passes the same validator export and purge use.
+            const vNs = validateIdentifier(namespace, 'namespace');
+            if (!vNs.valid)
+                throw new Error(vNs.error);
             const startTime = performance.now();
             try {
                 const result = await storeEntry({
@@ -792,10 +811,18 @@ export const memoryTools = [
         category: 'memory',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                dbPath: { type: 'string', description: 'Database file to inspect; omitted uses the MCP store default' },
+            },
         },
-        handler: async () => {
-            await ensureInitialized();
+        handler: async (input) => {
+            if (input.dbPath !== undefined && (typeof input.dbPath !== 'string' || !input.dbPath.trim())) {
+                return memoryStatsUnavailable('dbPath must be a non-empty string');
+            }
+            const dbPath = typeof input.dbPath === 'string' ? resolve(input.dbPath) : undefined;
+            // An explicit read must not initialize or migrate the unrelated default store.
+            if (!dbPath)
+                await ensureInitialized();
             const { listEntries } = await getMemoryFunctions();
             // #3311: the store's own listing decides whether memory is there.
             // `checkMemoryInitialization` opens a whole-image sql.js snapshot of
@@ -806,7 +833,7 @@ export const memoryTools = [
             // but it no longer gets to overrule a working store.
             let listing;
             try {
-                listing = await collectAllEntries(listEntries);
+                listing = await collectAllEntries(listEntries, dbPath);
             }
             catch (error) {
                 return memoryStatsUnavailable(error instanceof Error ? error.message : 'Unknown error');
@@ -822,16 +849,49 @@ export const memoryTools = [
             // from the breakdown while still being counted in the total.
             const namespaces = Object.create(null);
             let withEmbeddings = 0;
+            let oldest = Infinity;
+            let newest = -Infinity;
             for (const entry of listing.entries) {
                 namespaces[entry.namespace] = (namespaces[entry.namespace] || 0) + 1;
                 if (entry.hasEmbedding)
                     withEmbeddings++;
+                // AgentDB returns INTEGER epoch milliseconds; legacy sql.js rows
+                // may expose ISO strings or numeric strings from SQLite TEXT affinity.
+                const rawCreated = entry.createdAt;
+                const millis = typeof rawCreated === 'number'
+                    ? rawCreated
+                    : typeof rawCreated === 'string' && /^-?\d+$/.test(rawCreated)
+                        ? Number(rawCreated)
+                        : Date.parse(rawCreated ?? '');
+                const created = new Date(millis).getTime();
+                if (Number.isFinite(created)) {
+                    oldest = Math.min(oldest, created);
+                    newest = Math.max(newest, created);
+                }
             }
             const counted = listing.entries.length;
-            const status = await readMemoryStatusLabels();
+            const status = await readMemoryStatusLabels(dbPath);
+            let totalSize = null;
+            if (dbPath) {
+                try {
+                    let bytes = statSync(dbPath).size;
+                    try {
+                        bytes += statSync(dbPath + '-wal').size;
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    }
+                    totalSize = `${bytes} B`;
+                }
+                catch { /* unavailable file metadata is unknown, not zero */ }
+            }
             return {
                 initialized: true,
                 totalEntries: listing.total,
+                ...(dbPath ? { location: dbPath, totalSize } : {}),
+                oldestEntry: counted >= listing.total && Number.isFinite(oldest) ? new Date(oldest).toISOString() : null,
+                newestEntry: counted >= listing.total && Number.isFinite(newest) ? new Date(newest).toISOString() : null,
                 entriesCounted: counted,
                 // The breakdown below covers `entriesCounted` rows, which is every
                 // row unless the listing was truncated; say so rather than letting
@@ -1484,13 +1544,20 @@ export const memoryTools = [
                 inputPath: { type: 'string', description: 'Path to the JSON export file' },
                 merge: { type: 'boolean', description: 'Merge into existing entries (upsert) vs. fail on conflict (default true)' },
                 namespace: { type: 'string', description: 'Override the namespace for all imported entries' },
+                dbPath: { type: 'string', description: 'Database file to import into (defaults to the MCP memory store)' },
             },
             required: ['inputPath'],
         },
         handler: async (input) => {
-            await ensureInitialized();
+            const dbPath = typeof input.dbPath === 'string' && input.dbPath.trim()
+                ? resolve(input.dbPath)
+                : undefined;
+            await ensureInitialized(dbPath);
             const { storeEntry } = await getMemoryFunctions();
             const t0 = Date.now();
+            // Values are re-embedded on import; count the vectors actually written
+            // rather than reporting a constant 0 next to entries that show a vector.
+            let vectors = 0;
             const inputPath = String(input.inputPath ?? '');
             if (!inputPath || !existsSync(inputPath))
                 return { error: `File not found: ${inputPath || '(empty)'}` };
@@ -1508,6 +1575,24 @@ export const memoryTools = [
                 if (!v.valid)
                     throw new Error(v.error);
             }
+            // #3570: validate every entry's namespace up front so a bad file writes nothing.
+            if (!nsOverride) {
+                for (const e of entries) {
+                    if (e && typeof e.key === 'string' && e.namespace !== undefined) {
+                        const v = validateIdentifier(String(e.namespace), 'namespace');
+                        if (!v.valid)
+                            throw new Error(v.error);
+                    }
+                }
+            }
+            // #3570 follow-up: keys get the same up-front, all-or-nothing check.
+            for (const e of entries) {
+                if (e && typeof e.key === 'string') {
+                    const keyError = memoryKeyError(e.key);
+                    if (keyError)
+                        throw new Error(`${keyError}: ${JSON.stringify(e.key)}`);
+                }
+            }
             let imported = 0;
             let skipped = 0;
             for (const e of entries) {
@@ -1517,8 +1602,14 @@ export const memoryTools = [
                 }
                 const value = typeof e.value === 'string' ? e.value : JSON.stringify(e.value ?? null);
                 try {
-                    await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false });
-                    imported++;
+                    const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false, dbPath });
+                    if (result.success) {
+                        imported++;
+                        if (result.embedding)
+                            vectors++;
+                    }
+                    else
+                        skipped++;
                 }
                 catch {
                     skipped++;
@@ -1526,7 +1617,7 @@ export const memoryTools = [
             }
             return {
                 inputPath,
-                imported: { entries: imported, vectors: 0, patterns: 0 },
+                imported: { entries: imported, vectors, patterns: 0 },
                 skipped,
                 duration: Date.now() - t0,
             };

package/v3/@claude-flow/cli/dist/src/mcp-tools/policy-enforcer.d.ts

@@ -62,6 +62,12 @@ export interface McpPolicy {
     harnessId?: string;
     defaultDeny?: boolean;
     auditLog?: boolean;
+    /** Explicit destination; takes precedence over the environment and project default. */
+    auditLogPath?: string;
+    /** Maximum bytes per audit segment. Default 10 MiB; oversized records fail closed. */
+    auditLogMaxBytes?: number;
+    /** Rotated segments retained in addition to the active log. Default 5, maximum 100. */
+    auditLogMaxFiles?: number;
     requireApprovalForDangerous?: boolean;
     toolTimeoutMs?: number;
     /**
@@ -103,10 +109,11 @@ export interface AuditLogEntry {
     toolName: string;
     allowed: boolean;
     reason?: string;
+    projectPath?: string;
 }
 /** Test-only: redirect the audit log to a temp file instead of the default path. */
 export declare function setAuditLogPathForTesting(p: string | null): void;
-export declare function getAuditLogPath(): string;
+export declare function getAuditLogPath(options?: Pick<McpPolicy, 'auditLogPath'>): string;
 /**
  * Appends one JSONL audit record. Returns `true` if `policy.auditLog` is not
  * set (nothing was required) or the write succeeded; `false` only when

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

@@ -58,7 +58,6 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
 export function isPolicyEnforcementEnabled(env = process.env) {
     const v = env.RUFLO_MCP_ENFORCE_POLICY;
     return v === '1' || (v ?? '').toLowerCase() === 'true';
@@ -118,11 +117,18 @@ let auditLogPathOverride = null;
 export function setAuditLogPathForTesting(p) {
     auditLogPathOverride = p;
 }
-function defaultAuditLogPath() {
-    return path.join(os.tmpdir(), 'ruflo-mcp-audit.jsonl');
-}
-export function getAuditLogPath() {
-    return auditLogPathOverride ?? defaultAuditLogPath();
+export function getAuditLogPath(options = {}) {
+    if (auditLogPathOverride !== null)
+        return auditLogPathOverride;
+    if (options.auditLogPath !== undefined &&
+        (typeof options.auditLogPath !== 'string' || options.auditLogPath.trim().length === 0)) {
+        throw new Error('auditLogPath must be a non-empty string');
+    }
+    // Precedence: explicit caller/policy destination, environment, project default.
+    const configured = options.auditLogPath ?? process.env.RUFLO_MCP_AUDIT_LOG_PATH;
+    return configured
+        ? path.resolve(process.cwd(), configured)
+        : path.join(process.cwd(), '.claude-flow', 'logs', 'mcp-audit.jsonl');
 }
 /**
  * Appends one JSONL audit record. Returns `true` if `policy.auditLog` is not
@@ -135,8 +141,74 @@ export function appendAuditLog(policy, entry) {
     if (!policy.auditLog)
         return true;
     try {
-        fs.appendFileSync(getAuditLogPath(), `${JSON.stringify(entry)}\n`, 'utf-8');
-        return true;
+        const maxBytes = policy.auditLogMaxBytes ?? 10 * 1024 * 1024;
+        const maxFiles = policy.auditLogMaxFiles ?? 5;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0 ||
+            !Number.isSafeInteger(maxFiles) || maxFiles < 1 || maxFiles > 100)
+            return false;
+        const line = `${JSON.stringify({ ...entry, projectPath: path.resolve(process.cwd()) })}\n`;
+        const bytes = Buffer.byteLength(line, 'utf8');
+        if (bytes > maxBytes)
+            return false;
+        const logPath = getAuditLogPath(policy);
+        fs.mkdirSync(path.dirname(logPath), { recursive: true, mode: 0o700 });
+        // All writers of a configured path serialize rotation AND append. On
+        // contention (or a stale lock after a crash), deny rather than lose audit
+        // evidence by racing a rename. Only the lock owner removes its lock.
+        const lockPath = `${logPath}.lock`;
+        const lock = fs.openSync(lockPath, 'wx', 0o600);
+        try {
+            let size = 0;
+            try {
+                const stat = fs.lstatSync(logPath);
+                if (!stat.isFile())
+                    throw new Error('Audit log is not a regular file');
+                size = stat.size;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            if (size + bytes > maxBytes) {
+                // Validate the entire chain before moving or expiring any evidence.
+                for (let index = 1; index <= maxFiles; index++) {
+                    try {
+                        if (!fs.lstatSync(`${logPath}.${index}`).isFile())
+                            throw new Error('Audit segment is not a regular file');
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    }
+                }
+                for (let index = maxFiles; index >= 1; index--) {
+                    const source = index === 1 ? logPath : `${logPath}.${index - 1}`;
+                    const target = `${logPath}.${index}`;
+                    if (index === maxFiles) {
+                        try {
+                            fs.unlinkSync(target);
+                        }
+                        catch (error) {
+                            if (error.code !== 'ENOENT')
+                                throw error;
+                        }
+                    }
+                    try {
+                        fs.renameSync(source, target);
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    }
+                }
+            }
+            fs.appendFileSync(logPath, line, { encoding: 'utf8', mode: 0o600 });
+            return true;
+        }
+        finally {
+            fs.closeSync(lock);
+            fs.unlinkSync(lockPath);
+        }
     }
     catch {
         return false;

package/v3/@claude-flow/cli/dist/src/mcp-tools/session-tools.d.ts

@@ -4,5 +4,20 @@
  * Tool definitions for session management with file persistence.
  */
 import { type MCPTool } from './types.js';
+/**
+ * #3573: what session_save learned about memory, so callers can say
+ * "not included" or "no store" instead of printing an invented 0.
+ */
+export interface MemoryCaptureReport {
+    requested: boolean;
+    status: 'not-requested' | 'captured' | 'no-store' | 'error';
+    entries: number;
+    sources: {
+        memoryDb: number;
+        agentdb: number;
+        legacyJson: number;
+    };
+    error?: string;
+}
 export declare const sessionTools: MCPTool[];
 //# sourceMappingURL=session-tools.d.ts.map