🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(memory): isolate backup rotation and restore by store
Rudy Celeklif50488e4d608
diff --git a/v3/@claude-flow/cli/__tests__/memory-backup-store-isolation.test.ts b/v3/@claude-flow/cli/__tests__/memory-backup-store-isolation.test.tsnew file mode 100644index 0000000000..ac7f24f574--- /dev/null+++ b/v3/@claude-flow/cli/__tests__/memory-backup-store-isolation.test.ts@@ -0,0 +1,62 @@+import { afterEach, beforeEach, describe, expect, it } from 'vitest';+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';+import { join } from 'node:path';+import { tmpdir } from 'node:os';+import Database from 'better-sqlite3';+import { backupMemoryDb, restoreMemoryDbFromBackup } from '../src/services/memory-backup.js';++let dir: string;+const start = 1_700_000_000_000;+beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'memory-backup-isolation-')); });+afterEach(() => { rmSync(dir, { recursive: true, force: true }); });+function seed(name: string) {+ const dbPath = join(dir, name);+ const db = new Database(dbPath);+ db.exec('CREATE TABLE memory_entries (content TEXT)');+ db.prepare('INSERT INTO memory_entries VALUES (?)').run(name);+ db.close();+ return dbPath;+}+function content(dbPath: string) {+ const db = new Database(dbPath, { readonly: true });+ try { return db.prepare('SELECT content FROM memory_entries').get(); }+ finally { db.close(); }+}++describe('backup identity across sibling memory stores', () => {+ it('does not overwrite a different store snapshot at the same timestamp', async () => {+ const primary = seed('memory.db');+ const mirror = seed('agentdb-memory.db');+ const a = await backupMemoryDb({ dbPath: primary, timestamp: start });+ const b = await backupMemoryDb({ dbPath: mirror, timestamp: start });+ expect(a.backedUp).toBe(true);+ expect(b.backedUp).toBe(true);+ expect(a.path).not.toBe(b.path);+ expect(content(a.path!)).toEqual({ content: 'memory.db' });+ expect(content(b.path!)).toEqual({ content: 'agentdb-memory.db' });+ });++ it('rotates only snapshots belonging to the selected store', async () => {+ const primary = seed('memory.db');+ const mirror = seed('agentdb-memory.db');+ const a = await backupMemoryDb({ dbPath: primary, timestamp: start, keep: 1 });+ const b = await backupMemoryDb({ dbPath: mirror, timestamp: start + 1000, keep: 1 });+ const c = await backupMemoryDb({ dbPath: mirror, timestamp: start + 2000, keep: 1 });+ expect(existsSync(a.path!)).toBe(true);+ expect(existsSync(b.path!)).toBe(false);+ expect(existsSync(c.path!)).toBe(true);+ expect(c.rotatedAway).toHaveLength(1);+ });++ it.each(['memory.db', 'agentdb-memory.db'])('restores only %s snapshots even when another store is newer', async (name) => {+ const primary = seed(name);+ const other = seed(name === 'memory.db' ? 'agentdb-memory.db' : 'memory.db');+ const a = await backupMemoryDb({ dbPath: primary, timestamp: start });+ await backupMemoryDb({ dbPath: other, timestamp: start + 1000 });+ writeFileSync(primary, 'corrupt source');+ const restored = await restoreMemoryDbFromBackup(primary);+ expect(restored.restored).toBe(true);+ expect(restored.from).toBe(a.path);+ expect(content(primary)).toEqual({ content: name });+ });+});diff --git a/v3/@claude-flow/cli/src/services/memory-backup.ts b/v3/@claude-flow/cli/src/services/memory-backup.tsindex d7093c42ef..faff968a2e 100644--- a/v3/@claude-flow/cli/src/services/memory-backup.ts+++ b/v3/@claude-flow/cli/src/services/memory-backup.ts@@ -47,6 +47,18 @@ function fileStamp(ms: number): string {return new Date(ms).toISOString().replace(/[:.]/g, '-');}+/** Keep legacy memory.db names; give every other basename its own snapshot set. */+function snapshotPrefix(dbPath: string): string {+ const name = path.basename(dbPath);+ return name === 'memory.db' ? 'memory-' : `${encodeURIComponent(name)}-`;+}++function isSnapshotFor(file: string, dbPath: string): boolean {+ const prefix = snapshotPrefix(dbPath);+ return file.startsWith(prefix)+ && /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.db$/.test(file.slice(prefix.length));+}+export async function backupMemoryDb(opts: BackupOptions = {}): Promise<BackupResult> {const dbPath = opts.dbPath ?? defaultMemoryDbPath();if (!dbPath || !fs.existsSync(dbPath)) return { backedUp: false, skipped: 'no-db' };@@ -61,7 +73,7 @@ export async function backupMemoryDb(opts: BackupOptions = {}): Promise<BackupReconst destDir = opts.destDir ?? path.join(path.dirname(dbPath), 'backups');try { fs.mkdirSync(destDir, { recursive: true }); } catch { /* */ }- const destPath = path.join(destDir, `memory-${fileStamp(opts.timestamp ?? Date.now())}.db`);+ const destPath = path.join(destDir, `${snapshotPrefix(dbPath)}${fileStamp(opts.timestamp ?? Date.now())}.db`);// WAL-safe online backup: read-only source, consistent snapshot to destPath.let db: any;@@ -88,7 +100,7 @@ export async function backupMemoryDb(opts: BackupOptions = {}): Promise<BackupReconst keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;const rotatedAway: string[] = [];try {- const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();+ const snaps = fs.readdirSync(destDir).filter(f => isSnapshotFor(f, dbPath)).sort();while (snaps.length > keep) {const old = snaps.shift()!;try { fs.rmSync(path.join(destDir, old), { force: true }); rotatedAway.push(old); } catch { /* */ }@@ -119,7 +131,7 @@ export async function backupMemoryDb(opts: BackupOptions = {}): Promise<BackupReconst keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;const rotatedAway: string[] = [];try {- const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();+ const snaps = fs.readdirSync(destDir).filter(f => isSnapshotFor(f, dbPath)).sort();while (snaps.length > keep) {const old = snaps.shift()!;try { fs.rmSync(path.join(destDir, old), { force: true }); rotatedAway.push(old); } catch { /* */ }@@ -183,7 +195,7 @@ export async function restoreMemoryDbFromBackup(try {snaps = fs.readdirSync(destDir)- .filter(f => /^memory-.*\.db$/.test(f))+ .filter(f => isSnapshotFor(f, dbPath)).map(f => path.join(destDir, f)).sort() // ISO-stamped names sort chronologically.reverse(); // newest first