Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

fix(session): validate imported stores and derive snapshot counts

Rudy Celekli22d8c18accee
diff --git a/v3/@claude-flow/cli/__tests__/session-import-validation-r50.test.ts b/v3/@claude-flow/cli/__tests__/session-import-validation-r50.test.ts
new file mode 100644
index 0000000000..32b53cd6c0
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/session-import-validation-r50.test.ts
@@ -0,0 +1,28 @@
+import { beforeEach, afterEach, expect, it, vi } from 'vitest';
+import { mkdtempSync, writeFileSync, readFileSync, readdirSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const state = vi.hoisted(() => ({ cwd: '' }));
+vi.mock('../src/mcp-tools/types.js', () => ({ getProjectCwd: () => state.cwd }));
+import { sessionTools } from '../src/mcp-tools/session-tools.js';
+const call = (name: string, input: object) => sessionTools.find(t => t.name === name)!.handler(input) as Promise<any>;
+const importData = (data: unknown) => { const inputPath = join(state.cwd, 'input.json'); writeFileSync(inputPath, JSON.stringify(data)); return call('session_import', { inputPath }); };
+beforeEach(() => { state.cwd = mkdtempSync(join(tmpdir(), 'ruflo-import-')); });
+afterEach(() => rmSync(state.cwd, { recursive: true, force: true }));
+it.each([null, [], 7, {}, {name:{bad:true},data:{}}, {name:[],data:{}}, {name:'bad',data:[]}, {name:'bad',data:{tasks:{tasks:[]}}}, {name:'bad',data:{agents:{agents:{a:null}}}}, {name:'bad',data:{memory:{entries:'wrong'}}}].map(data => [data]))('rejects invalid session %j before registration', async data => {
+ const result = await importData(data);
+ expect(result.error).toMatch(/invalid session/i);
+ const dir = join(state.cwd, '.claude-flow/sessions');
+ expect(existsSync(dir) ? readdirSync(dir) : []).toEqual([]);
+});
+it.each([undefined, {tasks:999,agents:999,memoryEntries:999,totalSize:999}])('derives counts from imported data instead of claimed stats %j', async stats => {
+ const data = {tasks:{tasks:{t:{taskId:'t'}}},agents:{agents:{a:{agentId:'a'}}},memory:{entries:{m:{key:'m',value:'v'}}}};
+ const result = await importData({name:'legacy',stats,data});
+ expect(result.stats).toEqual({tasksImported:1,agentsImported:1,memoryEntriesImported:1});
+ const session = JSON.parse(readFileSync(join(state.cwd,'.claude-flow/sessions',result.sessionId+'.json'),'utf8'));
+ expect(session.data).toEqual(data);
+ expect(session.stats.totalSize).toBeGreaterThan(0);
+});
+it('accepts older metadata-only snapshots and recomputes empty counts', async () => {
+ expect(await importData({name:'metadata',sessionId:'old'})).toMatchObject({name:'metadata',stats:{tasksImported:0,agentsImported:0,memoryEntriesImported:0}});
+});
diff --git a/v3/@claude-flow/cli/src/mcp-tools/session-tools.ts b/v3/@claude-flow/cli/src/mcp-tools/session-tools.ts
index 3da5bda412..7ca673397f 100644
--- a/v3/@claude-flow/cli/src/mcp-tools/session-tools.ts
+++ b/v3/@claude-flow/cli/src/mcp-tools/session-tools.ts
@@ -15,6 +15,31 @@ import {
} from '../fs-secure.js';
import { validateIdentifier, validateText } from './validate-input.js';
+function isRecord(value: unknown): value is Record<string, unknown> {
+ return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+// Imported snapshots become live stores on restore. Validate their containers
+// before registering them, while allowing older metadata-only snapshots.
+function validateImportedSession(value: unknown): string | undefined {
+ if (!isRecord(value) || (typeof value.name !== 'string' && !isRecord(value.data))) {
+ return 'Invalid session: expected a named snapshot or snapshot data';
+ }
+ if (value.name !== undefined && typeof value.name !== 'string') {
+ return 'Invalid session: name must be a string';
+ }
+ if (value.data === undefined) return;
+ if (!isRecord(value.data)) return 'Invalid session: data must be an object';
+ for (const [component, collection] of [['tasks', 'tasks'], ['agents', 'agents'], ['memory', 'entries']]) {
+ const store = value.data[component];
+ if (store === undefined) continue;
+ if (!isRecord(store) || !isRecord(store[collection]) ||
+ Object.values(store[collection]).some(record => !isRecord(record))) {
+ return `Invalid session: data.${component}.${collection} must be a record map`;
+ }
+ }
+}
+
// Storage paths
const STORAGE_DIR = '.claude-flow';
const SESSION_DIR = 'sessions';
@@ -549,8 +574,15 @@ export const sessionTools: MCPTool[] = [
let parsed: SessionRecord;
try { parsed = JSON.parse(readFileSync(inputPath, 'utf-8')); }
catch (e) { return { error: `Invalid session JSON: ${(e as Error).message}` }; }
+ const validationError = validateImportedSession(parsed);
+ if (validationError) return { error: validationError };
const newId = `session-${Date.now()}-${randomUUID().slice(0, 8)}`;
- const stats = parsed.stats || { tasks: 0, agents: 0, memoryEntries: 0, totalSize: 0 };
+ const stats = {
+ tasks: Object.keys((parsed.data?.tasks?.tasks as object) || {}).length,
+ agents: Object.keys((parsed.data?.agents?.agents as object) || {}).length,
+ memoryEntries: Object.keys((parsed.data?.memory?.entries as object) || {}).length,
+ totalSize: 0,
+ };
const session: SessionRecord = {
sessionId: newId,
name: input.name ? String(input.name) : (parsed.name || 'imported-session'),
@@ -559,6 +591,7 @@ export const sessionTools: MCPTool[] = [
stats,
data: parsed.data,
};
+ session.stats.totalSize = Buffer.byteLength(JSON.stringify(session), 'utf-8');
saveSession(session);
let activated = false;
if (input.activate === true) {