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

feat(cli): add 'ruflo verify' for signed witness manifest verification

Reuven6d37a5ff9720
diff --git a/v3/@claude-flow/cli/src/commands/index.ts b/v3/@claude-flow/cli/src/commands/index.ts
index 35dbdf5afa..0f7fd08f28 100644
--- a/v3/@claude-flow/cli/src/commands/index.ts
+++ b/v3/@claude-flow/cli/src/commands/index.ts
@@ -52,6 +52,8 @@ const commandLoaders: Record<string, CommandLoader> = {
// P0 Commands
completions: () => import('./completions.js'),
doctor: () => import('./doctor.js'),
+ // Verification (ADR-095, signed witness manifest)
+ verify: () => import('./verify.js'),
// Analysis Commands
analyze: () => import('./analyze.js'),
// Q-Learning Routing Commands
diff --git a/v3/@claude-flow/cli/src/commands/verify.ts b/v3/@claude-flow/cli/src/commands/verify.ts
new file mode 100644
index 0000000000..b55dc976d5
--- /dev/null
+++ b/v3/@claude-flow/cli/src/commands/verify.ts
@@ -0,0 +1,294 @@
+/**
+ * V3 CLI Verify Command
+ *
+ * Fetches the verification.md.json witness manifest from the live repo,
+ * recomputes SHA-256 of every cited file in the user's installed
+ * artifact, re-derives the Ed25519 public key from the manifest's git
+ * commit, and verifies the signature.
+ *
+ * Run via: ruflo verify [--branch <branch>] [--manifest <local-path>]
+ *
+ * If everything checks, the user has byte-for-byte the same fix
+ * footprint as the manifest claims. If anything mismatches, the
+ * command exits non-zero and prints which fix regressed or which file
+ * drifted.
+ */
+
+import { createHash } from 'crypto';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, sep } from 'path';
+import { fileURLToPath } from 'url';
+import type { Command, CommandContext, CommandResult } from '../types.js';
+import { output } from '../output.js';
+
+interface ManifestFix {
+ id: string;
+ desc: string;
+ file: string;
+ sha256: string;
+ marker: string;
+ markerVerified: boolean;
+}
+
+interface Manifest {
+ schema: string;
+ issuedAt: string;
+ gitCommit: string;
+ branch: string;
+ releases: Record<string, string>;
+ summary: { totalFixes: number; verified: number; failed: number };
+ fixes: ManifestFix[];
+}
+
+interface Witness {
+ manifest: Manifest;
+ integrity: {
+ manifestHashAlgo: string;
+ manifestHash: string;
+ signatureAlgo: string;
+ publicKey: string;
+ signature: string;
+ seedDerivation: string;
+ };
+}
+
+const DEFAULT_MANIFEST_URL = 'https://raw.githubusercontent.com/ruvnet/ruflo/{branch}/verification.md.json';
+
+async function fetchWitness(branch: string): Promise<Witness> {
+ const url = DEFAULT_MANIFEST_URL.replace('{branch}', branch);
+ const res = await fetch(url);
+ if (!res.ok) {
+ throw new Error(`Failed to fetch manifest from ${url}: ${res.status} ${res.statusText}`);
+ }
+ return await res.json() as Witness;
+}
+
+function loadLocalWitness(localPath: string): Witness {
+ if (!existsSync(localPath)) {
+ throw new Error(`Manifest not found: ${localPath}`);
+ }
+ return JSON.parse(readFileSync(localPath, 'utf-8')) as Witness;
+}
+
+/**
+ * Locate the user's installed package root.
+ *
+ * The witness manifest paths are repo-relative (e.g.
+ * "v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js"). For
+ * end users, only the dist/ subtree ships in node_modules. We map
+ * the repo path → the installed equivalent by stripping the
+ * "v3/@claude-flow/<pkg>/" prefix and looking up node_modules/<pkg>/.
+ */
+function repoPathToInstalledPath(repoPath: string): string | null {
+ // Match v3/@claude-flow/<pkg>/<rest>
+ const match = repoPath.match(/^v3\/(@claude-flow\/[^/]+)\/(.+)$/);
+ if (match) {
+ const pkg = match[1];
+ const rest = match[2];
+ // Try several anchors: cwd/node_modules, the dirname of this script's package
+ const candidates: string[] = [];
+ candidates.push(join(process.cwd(), 'node_modules', pkg, rest));
+ try {
+ const __filename = fileURLToPath(import.meta.url);
+ // Walk up looking for node_modules
+ let dir = dirname(__filename);
+ for (let i = 0; i < 10; i++) {
+ candidates.push(join(dir, 'node_modules', pkg, rest));
+ const parent = dirname(dir);
+ if (parent === dir) break;
+ dir = parent;
+ }
+ } catch { /* ignore */ }
+ for (const c of candidates) {
+ if (existsSync(c)) return c;
+ }
+ return null;
+ }
+ // Top-level paths (e.g. package.json) — return relative to cwd
+ const top = join(process.cwd(), repoPath);
+ return existsSync(top) ? top : null;
+}
+
+function fileSha256(path: string): string {
+ return createHash('sha256').update(readFileSync(path)).digest('hex');
+}
+
+function fileContains(path: string, marker: string): boolean {
+ return readFileSync(path, 'utf-8').includes(marker);
+}
+
+async function verifySignature(witness: Witness): Promise<{
+ manifestHashOk: boolean;
+ publicKeyReproducible: boolean;
+ signatureValid: boolean;
+}> {
+ // Lazy-load @noble/ed25519 — keep verify command snappy when no signature check needed
+ let ed: typeof import('@noble/ed25519') | null = null;
+ try {
+ ed = await import('@noble/ed25519');
+ } catch {
+ return { manifestHashOk: false, publicKeyReproducible: false, signatureValid: false };
+ }
+ // Configure sync sha512 for the v2 API
+ const sha512Sync = (...m: Uint8Array[]): Uint8Array => {
+ const h = createHash('sha512');
+ for (const x of m) h.update(x);
+ return h.digest();
+ };
+ (ed as { etc: { sha512Sync: typeof sha512Sync } }).etc.sha512Sync = sha512Sync;
+
+ const manifestCanonical = JSON.stringify(witness.manifest);
+ const recomputedHash = createHash('sha256').update(manifestCanonical).digest('hex');
+ const manifestHashOk = recomputedHash === witness.integrity.manifestHash;
+
+ const seed = createHash('sha256').update(witness.manifest.gitCommit + ':ruflo-witness/v1').digest();
+ const reKey = ed.getPublicKey(seed);
+ const publicKeyReproducible = Buffer.from(reKey).toString('hex') === witness.integrity.publicKey;
+
+ const signatureValid = ed.verify(
+ Buffer.from(witness.integrity.signature, 'hex'),
+ Buffer.from(witness.integrity.manifestHash, 'hex'),
+ Buffer.from(witness.integrity.publicKey, 'hex'),
+ );
+
+ return { manifestHashOk, publicKeyReproducible, signatureValid };
+}
+
+export const verifyCommand: Command = {
+ name: 'verify',
+ description: 'Verify installed artifact against the signed witness manifest',
+ options: [
+ {
+ name: 'branch',
+ short: 'b',
+ type: 'string',
+ description: 'Git branch to fetch verification.md.json from (defaults to fix/issues-may-1-3)',
+ default: 'fix/issues-may-1-3',
+ },
+ {
+ name: 'manifest',
+ short: 'm',
+ type: 'string',
+ description: 'Local path to a verification.md.json file (overrides --branch)',
+ },
+ {
+ name: 'json',
+ type: 'boolean',
+ description: 'Output JSON instead of human-readable table',
+ default: false,
+ },
+ ],
+ examples: [
+ { command: 'ruflo verify', description: 'Fetch latest manifest from main branch + verify' },
+ { command: 'ruflo verify --branch main', description: 'Verify against a specific branch' },
+ { command: 'ruflo verify --manifest ./verification.md.json', description: 'Use a local manifest copy' },
+ { command: 'ruflo verify --json', description: 'Machine-readable output for CI' },
+ ],
+ action: async (ctx: CommandContext): Promise<CommandResult> => {
+ const branch = (ctx.flags.branch as string) || 'fix/issues-may-1-3';
+ const localPath = ctx.flags.manifest as string | undefined;
+ const asJson = ctx.flags.json === true;
+
+ if (!asJson) {
+ output.writeln();
+ output.writeln(output.bold('Ruflo Verification'));
+ output.writeln(output.dim('─'.repeat(50)));
+ }
+
+ let witness: Witness;
+ try {
+ witness = localPath ? loadLocalWitness(localPath) : await fetchWitness(branch);
+ } catch (err) {
+ const msg = err instanceof Error ? err.message : String(err);
+ if (asJson) output.printJson({ ok: false, error: msg });
+ else output.printError(`Could not load witness manifest: ${msg}`);
+ return { success: false, exitCode: 1 };
+ }
+
+ // Signature verification
+ const sig = await verifySignature(witness);
+
+ // File verification
+ const fileResults = witness.manifest.fixes.map((fix) => {
+ const installedPath = repoPathToInstalledPath(fix.file);
+ if (!installedPath) {
+ return { ...fix, status: 'missing' as 'missing' | 'pass' | 'drift' | 'regressed', sha256Match: false, markerPresent: false, installedPath: null as string | null, localSha256: undefined as string | undefined };
+ }
+ const localHash = fileSha256(installedPath);
+ const markerPresent = fileContains(installedPath, fix.marker);
+ const sha256Match = localHash === fix.sha256;
+ const status: 'pass' | 'drift' | 'regressed' = sha256Match && markerPresent
+ ? 'pass'
+ : (markerPresent ? 'drift' : 'regressed');
+ return { ...fix, status, sha256Match, markerPresent, localSha256: localHash, installedPath: installedPath.replace(process.cwd() + sep, '') };
+ });
+
+ const passCount = fileResults.filter((r) => r.status === 'pass').length;
+ const driftCount = fileResults.filter((r) => r.status === 'drift').length;
+ const regressedCount = fileResults.filter((r) => r.status === 'regressed').length;
+ const missingCount = fileResults.filter((r) => r.status === 'missing').length;
+
+ const allOk = sig.manifestHashOk && sig.publicKeyReproducible && sig.signatureValid && regressedCount === 0;
+
+ if (asJson) {
+ output.printJson({
+ ok: allOk,
+ manifest: witness.manifest,
+ signature: sig,
+ results: fileResults,
+ summary: { pass: passCount, drift: driftCount, regressed: regressedCount, missing: missingCount },
+ });
+ return { success: allOk, exitCode: allOk ? 0 : 1 };
+ }
+
+ output.writeln();
+ output.writeln(output.bold('Manifest signature'));
+ output.writeln(` manifest hash matches: ${sig.manifestHashOk ? output.success('yes') : output.error('no')}`);
+ output.writeln(` public key reproducible from gitCommit: ${sig.publicKeyReproducible ? output.success('yes') : output.error('no')}`);
+ output.writeln(` Ed25519 signature valid: ${sig.signatureValid ? output.success('yes') : output.error('no')}`);
+ output.writeln();
+
+ output.writeln(output.bold('Fix verification'));
+ for (const r of fileResults) {
+ const status = r.status === 'pass'
+ ? output.success('pass')
+ : r.status === 'drift'
+ ? output.warning('drift')
+ : output.error(r.status);
+ output.writeln(` [${status}] ${r.id} — ${r.desc}`);
+ if (r.status === 'drift' && r.localSha256) {
+ output.writeln(output.dim(` expected sha256: ${r.sha256.slice(0, 16)}…`));
+ output.writeln(output.dim(` local sha256: ${r.localSha256.slice(0, 16)}…`));
+ } else if (r.status === 'regressed') {
+ output.writeln(output.dim(` marker missing: '${r.marker}' not found in ${r.installedPath ?? r.file}`));
+ } else if (r.status === 'missing') {
+ output.writeln(output.dim(` file not found in node_modules: ${r.file}`));
+ }
+ }
+
+ output.writeln();
+ output.writeln(output.bold('Summary'));
+ output.writeln(` pass: ${passCount}`);
+ output.writeln(` drift: ${driftCount}`);
+ output.writeln(` regressed: ${regressedCount}`);
+ output.writeln(` missing: ${missingCount}`);
+ output.writeln();
+
+ if (allOk) {
+ output.printSuccess('All fixes verified. Installed artifact matches the signed witness manifest.');
+ return { success: true };
+ }
+ if (regressedCount > 0) {
+ output.printError(`${regressedCount} fix(es) regressed. Markers not found in installed artifact.`);
+ }
+ if (driftCount > 0) {
+ output.printWarning(`${driftCount} fix(es) drifted. Markers present, but file SHA-256 differs (could be a benign edit; inspect the diff).`);
+ }
+ if (!sig.signatureValid || !sig.manifestHashOk) {
+ output.printError('Manifest signature failed verification. The witness file may have been tampered with or corrupted.');
+ }
+ return { success: false, exitCode: 1 };
+ },
+};
+
+export default verifyCommand;