@claude-flow/swarm 3.0.0-alpha.8 → 3.0.0-alpha.9

package/__tests__/consensus-failure-injection.test.ts

@@ -1,161 +0,0 @@
-/**
- * ADR-095 G2 — failure-injection tests.
- *
- * Drives multi-node consensus over a shared LocalTransportRegistry with
- * some nodes silenced (their inbound handler is replaced with a no-op so
- * they receive messages but never participate). Asserts:
- *   - BFT: consensus is reached with ≤ f faulty (f = floor((n-1)/3)),
- *     and NOT reached with > f faulty.
- *   - Raft: a candidate wins the election with a majority of votes,
- *     and loses it when too many peers are silent.
- */
-import { describe, it, expect } from 'vitest';
-import { ByzantineConsensus } from '../src/consensus/byzantine.js';
-import { RaftConsensus } from '../src/consensus/raft.js';
-import { LocalTransport, LocalTransportRegistry } from '../src/consensus/transport.js';
-
-// ---------------------------------------------------------------------------
-// Byzantine — PBFT prepare/commit quorum under f-bounded faults
-// ---------------------------------------------------------------------------
-
-/**
- * Build one ByzantineConsensus node with `peerCount` known peers (so
- * byzantineF() = floor(((peerCount+1)-1)/3)), then feed it `prepareSenders`
- * distinct prepare messages followed by `commitSenders` distinct commit
- * messages for the same (view, seq). Returns whether `consensus.achieved`
- * fired (i.e., commitCount reached 2f+1). This tests the threshold without
- * relying on a full multi-node cascade.
- */
-async function injectQuorum(opts: {
-  peerCount: number;
-  prepareSenders: string[];
-  commitSenders: string[];
-  maxFaultyNodes?: number;
-}): Promise<{ achieved: boolean; f: number }> {
-  const reg = new LocalTransportRegistry();
-  const t = new LocalTransport('node', { registry: reg });
-  const driver = new LocalTransport('driver', { registry: reg });
-  const bft = new ByzantineConsensus('node', { transport: t, ...(opts.maxFaultyNodes !== undefined ? { maxFaultyNodes: opts.maxFaultyNodes } : {}) });
-  for (let i = 0; i < opts.peerCount; i++) bft.addNode(`peer${i}`, i === 0);
-  // Seed the proposal so handleCommit can flip it to 'accepted'.
-  const digest = 'd'.repeat(64);
-  const base = { viewNumber: 0, sequenceNumber: 1, digest, timestamp: new Date().toISOString() };
-  // pre-prepare creates the proposal on this node.
-  await driver.send('node', { type: 'pre-prepare', payload: { type: 'pre-prepare', ...base, payload: { v: 1 } }, viewNumber: 0 });
-
-  let achieved = false;
-  bft.on('consensus.achieved', () => { achieved = true; });
-  const f = (bft as unknown as { byzantineF: () => number }).byzantineF();
-
-  // Inject prepares from distinct senders.
-  for (const sid of opts.prepareSenders) {
-    // Each must come from a distinct `from` so dedup-by-senderId counts it.
-    const dt = new LocalTransport(`p_${sid}`, { registry: reg });
-    await dt.send('node', { type: 'prepare', payload: { type: 'prepare', ...base }, viewNumber: 0 });
-    await dt.close();
-  }
-  // Inject commits from distinct senders.
-  for (const sid of opts.commitSenders) {
-    const dt = new LocalTransport(`c_${sid}`, { registry: reg });
-    await dt.send('node', { type: 'commit', payload: { type: 'commit', ...base }, viewNumber: 0 });
-    await dt.close();
-  }
-
-  await bft.shutdown(); await t.close(); await driver.close();
-  return { achieved, f };
-}
-
-// Note on accounting: the node under test contributes 1 prepare (via the
-// pre-prepare self-handle) and, once prepareCount hits 2f+1, 1 commit (via
-// the prepare→commit self-handle). So `prepareSenders.length` external
-// prepares + the node's own = `len+1`; same for commits. To hit a 2f+1
-// quorum the test injects `2f` external messages of each kind.
-describe('ADR-095 G2 — BFT prepare/commit quorum under f-bounded faults', () => {
-  it('4-node cluster (f=1): 2f external prepares + 2f external commits → quorum 2f+1 reached', async () => {
-    const { achieved, f } = await injectQuorum({ peerCount: 3, prepareSenders: ['s1', 's2'], commitSenders: ['s1', 's2'] });
-    expect(f).toBe(1);
-    expect(achieved).toBe(true); // node + 2 = 3 = 2f+1
-  });
-
-  it('4-node cluster (f=1): only 1 external commit (one node faulty) → NOT reached', async () => {
-    const { achieved, f } = await injectQuorum({ peerCount: 3, prepareSenders: ['s1', 's2'], commitSenders: ['s1'] });
-    expect(f).toBe(1);
-    expect(achieved).toBe(false); // node + 1 = 2 < 2f+1
-  });
-
-  it('7-node cluster (f=2): 2f external prepares + 2f external commits → quorum 2f+1=5 reached', async () => {
-    const { achieved, f } = await injectQuorum({ peerCount: 6, prepareSenders: ['s1', 's2', 's3', 's4'], commitSenders: ['s1', 's2', 's3', 's4'] });
-    expect(f).toBe(2);
-    expect(achieved).toBe(true); // node + 4 = 5 = 2f+1
-  });
-
-  it('7-node cluster (f=2): only 3 external commits (two faulty) → NOT reached', async () => {
-    const { achieved, f } = await injectQuorum({ peerCount: 6, prepareSenders: ['s1', 's2', 's3', 's4'], commitSenders: ['s1', 's2', 's3'] });
-    expect(f).toBe(2);
-    expect(achieved).toBe(false); // node + 3 = 4 < 5
-  });
-
-  it('config.maxFaultyNodes caps f: 10-node cluster + cap 1 → 2f+1=3 reached with only 2 external commits', async () => {
-    const { achieved, f } = await injectQuorum({ peerCount: 9, maxFaultyNodes: 1, prepareSenders: ['s1', 's2'], commitSenders: ['s1', 's2'] });
-    expect(f).toBe(1); // capped, not floor(9/3)=3
-    expect(achieved).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Raft — election under majority/minority of votes
-// ---------------------------------------------------------------------------
-
-/**
- * Drive a single RequestVote round from `candidate` to all `voters` over
- * the transport and tally grants. `silent` voters get a no-op handler so
- * they never reply (the candidate's `send` to them times out → no vote).
- * Returns the grant count (including the candidate's implicit self-vote).
- */
-async function tallyVotes(candidateId: string, voterIds: string[], silent: Set<string>, term: number): Promise<number> {
-  const reg = new LocalTransportRegistry();
-  const transports: LocalTransport[] = [];
-  const nodes = new Map<string, RaftConsensus>();
-  const allIds = [candidateId, ...voterIds];
-  for (const id of allIds) {
-    const t = new LocalTransport(id, { registry: reg, defaultTimeoutMs: 100 });
-    transports.push(t);
-    const r = new RaftConsensus(id, { transport: t });
-    for (const other of allIds) if (other !== id) r.addPeer(other);
-    nodes.set(id, r);
-  }
-  for (const id of silent) transports.find(t => t.nodeId === id)!.onMessage(() => { /* silent: never reply */ });
-
-  let grants = 1; // self-vote
-  const candT = transports.find(t => t.nodeId === candidateId)!;
-  await Promise.all(voterIds.map(async (vid) => {
-    try {
-      const reply = await candT.send(vid, { type: 'request-vote', payload: { term, candidateId, lastLogIndex: 0, lastLogTerm: 0 }, term }, 100);
-      if ((reply?.payload as { granted?: boolean })?.granted === true) grants++;
-    } catch { /* timeout → no vote */ }
-  }));
-
-  for (const n of nodes.values()) await n.shutdown();
-  for (const t of transports) await t.close();
-  return grants;
-}
-
-describe('ADR-095 G2 — Raft election under vote majority/minority', () => {
-  it('5-node cluster, all 4 voters reply → candidate gets 5 votes (majority is 3)', async () => {
-    const grants = await tallyVotes('n1', ['n2', 'n3', 'n4', 'n5'], new Set(), 1);
-    expect(grants).toBe(5);
-    expect(grants).toBeGreaterThanOrEqual(3); // wins
-  });
-
-  it('5-node cluster, 2 voters silent → candidate still gets 3 votes (majority) → wins', async () => {
-    const grants = await tallyVotes('n1', ['n2', 'n3', 'n4', 'n5'], new Set(['n4', 'n5']), 1);
-    expect(grants).toBe(3);
-    expect(grants).toBeGreaterThanOrEqual(3);
-  });
-
-  it('5-node cluster, 3 voters silent → candidate gets only 2 votes (< majority) → loses', async () => {
-    const grants = await tallyVotes('n1', ['n2', 'n3', 'n4', 'n5'], new Set(['n3', 'n4', 'n5']), 1);
-    expect(grants).toBe(2);
-    expect(grants).toBeLessThan(3);
-  });
-});

package/__tests__/consensus-transport.test.ts

@@ -1,200 +0,0 @@
-/**
- * ADR-095 G2 — tests for the ConsensusTransport abstraction.
- */
-import { describe, it, expect } from 'vitest';
-import {
-  LocalTransport,
-  LocalTransportRegistry,
-  generateNodeKeyPair,
-  signMessage,
-  verifyMessage,
-  canonicalizeForSigning,
-  messageDigest,
-  type ConsensusMessage,
-} from '../src/consensus/transport.js';
-
-describe('ADR-095 G2 — Ed25519 message signing', () => {
-  it('signs and verifies a message round-trip', () => {
-    const kp = generateNodeKeyPair();
-    const msg = { type: 'request-vote', from: 'n1', to: 'n2', payload: { term: 3, candidateId: 'n1' }, term: 3, seq: 1 };
-    const sig = signMessage(msg, kp.privateKeyPem);
-    expect(sig).toMatch(/^[A-Za-z0-9+/]+=*$/);
-    expect(verifyMessage({ ...msg, signature: sig }, kp.publicKeyPem)).toBe(true);
-  });
-
-  it('rejects a tampered payload', () => {
-    const kp = generateNodeKeyPair();
-    const msg = { type: 'append-entries', from: 'leader', payload: { term: 5, entries: [] }, term: 5, seq: 2 };
-    const sig = signMessage(msg, kp.privateKeyPem);
-    const tampered: ConsensusMessage = { ...msg, payload: { term: 5, entries: [{ index: 1, data: 'evil' }] }, signature: sig };
-    expect(verifyMessage(tampered, kp.publicKeyPem)).toBe(false);
-  });
-
-  it('rejects a missing signature (fail-closed)', () => {
-    const kp = generateNodeKeyPair();
-    const msg: ConsensusMessage = { type: 'commit', from: 'n3', payload: {}, seq: 1 };
-    expect(verifyMessage(msg, kp.publicKeyPem)).toBe(false);
-  });
-
-  it('rejects a signature from the wrong key', () => {
-    const kpA = generateNodeKeyPair();
-    const kpB = generateNodeKeyPair();
-    const msg = { type: 'prepare', from: 'n1', payload: { digest: 'abc' }, seq: 1 };
-    const sig = signMessage(msg, kpA.privateKeyPem);
-    expect(verifyMessage({ ...msg, signature: sig }, kpB.publicKeyPem)).toBe(false);
-  });
-
-  it('canonicalization is stable regardless of key order', () => {
-    const a = { type: 'x', from: 'n1', payload: { b: 2, a: 1 }, seq: 1 };
-    const b = { seq: 1, payload: { a: 1, b: 2 }, from: 'n1', type: 'x' };
-    expect(canonicalizeForSigning(a).toString()).toBe(canonicalizeForSigning(b).toString());
-    expect(messageDigest(a)).toBe(messageDigest(b));
-    expect(messageDigest(a)).toMatch(/^[a-f0-9]{64}$/);
-  });
-});
-
-describe('ADR-095 G2 — LocalTransport', () => {
-  it('delivers a send to the peer handler and returns its reply', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg });
-
-    b.onMessage(async (msg) => {
-      expect(msg.from).toBe('a');
-      expect(msg.type).toBe('request-vote');
-      return { type: 'vote-response', from: 'b', to: 'a', payload: { granted: true }, term: msg.term };
-    });
-
-    const reply = await a.send('b', { type: 'request-vote', payload: { candidateId: 'a' }, term: 1 });
-    expect(reply).not.toBeNull();
-    expect(reply!.type).toBe('vote-response');
-    expect((reply!.payload as { granted: boolean }).granted).toBe(true);
-
-    await a.close(); await b.close();
-  });
-
-  it('send to unreachable peer rejects', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    await expect(a.send('nobody', { type: 'x', payload: {} })).rejects.toThrow(/unreachable/);
-    await a.close();
-  });
-
-  it('broadcast reaches every peer (not self)', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg });
-    const c = new LocalTransport('c', { registry: reg });
-    const seenB: string[] = [];
-    const seenC: string[] = [];
-    b.onMessage((m) => { seenB.push(m.type); });
-    c.onMessage((m) => { seenC.push(m.type); });
-
-    await a.broadcast({ type: 'pre-prepare', payload: { digest: 'd1' }, viewNumber: 0 });
-    expect(seenB).toEqual(['pre-prepare']);
-    expect(seenC).toEqual(['pre-prepare']);
-
-    await a.close(); await b.close(); await c.close();
-  });
-
-  it('peers() lists registered peers excluding self', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg });
-    const c = new LocalTransport('c', { registry: reg });
-    expect(new Set(a.peers())).toEqual(new Set(['b', 'c']));
-    await a.close();
-    expect(new Set(b.peers())).toEqual(new Set(['c']));
-    await b.close(); await c.close();
-  });
-
-  it('send to a closed peer rejects', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg });
-    await b.close();
-    await expect(a.send('b', { type: 'x', payload: {} })).rejects.toThrow(/unreachable|closed/);
-    await a.close();
-  });
-
-  it('send times out if the peer handler hangs', async () => {
-    const reg = new LocalTransportRegistry();
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg });
-    b.onMessage(() => new Promise(() => { /* never resolves */ }));
-    await expect(a.send('b', { type: 'x', payload: {} }, 50)).rejects.toThrow(/timed out/);
-    await a.close(); await b.close();
-  });
-});
-
-describe('ADR-095 G2 — LocalTransport with signing', () => {
-  it('signs outbound and verifies inbound when both ends have keypairs', async () => {
-    const reg = new LocalTransportRegistry();
-    const kpA = generateNodeKeyPair();
-    const kpB = generateNodeKeyPair();
-    const pubs: Record<string, string> = { a: kpA.publicKeyPem, b: kpB.publicKeyPem };
-    const resolvePeerPublicKey = (id: string) => pubs[id];
-
-    const a = new LocalTransport('a', { registry: reg, keyPair: kpA, resolvePeerPublicKey });
-    const b = new LocalTransport('b', { registry: reg, keyPair: kpB, resolvePeerPublicKey });
-
-    let received: ConsensusMessage | null = null;
-    b.onMessage((m) => { received = m; return { type: 'ack', from: 'b', payload: {} }; });
-
-    const reply = await a.send('b', { type: 'commit', payload: { digest: 'x' } });
-    expect(reply).not.toBeNull();
-    expect(received).not.toBeNull();
-    expect(received!.signature).toBeTruthy();
-    expect(received!.seq).toBe(1);
-
-    await a.close(); await b.close();
-  });
-
-  it('rejects an unsigned message at a signing-enabled peer', async () => {
-    const reg = new LocalTransportRegistry();
-    const kpB = generateNodeKeyPair();
-    const resolvePeerPublicKey = (id: string) => (id === 'b' ? kpB.publicKeyPem : undefined);
-
-    // `a` has no keypair → sends unsigned. `b` requires signatures.
-    const a = new LocalTransport('a', { registry: reg });
-    const b = new LocalTransport('b', { registry: reg, keyPair: kpB, resolvePeerPublicKey });
-    b.onMessage(() => ({ type: 'ack', from: 'b', payload: {} }));
-
-    await expect(a.send('b', { type: 'commit', payload: {} })).rejects.toThrow(/signature verification failed/);
-    await a.close(); await b.close();
-  });
-
-  it('rejects a replayed seq at a signing-enabled peer', async () => {
-    const reg = new LocalTransportRegistry();
-    const kpA = generateNodeKeyPair();
-    const kpB = generateNodeKeyPair();
-    const pubs: Record<string, string> = { a: kpA.publicKeyPem, b: kpB.publicKeyPem };
-    const resolvePeerPublicKey = (id: string) => pubs[id];
-    const a = new LocalTransport('a', { registry: reg, keyPair: kpA, resolvePeerPublicKey });
-    const b = new LocalTransport('b', { registry: reg, keyPair: kpB, resolvePeerPublicKey });
-    b.onMessage(() => ({ type: 'ack', from: 'b', payload: {} }));
-
-    // First send: seq=1 — OK.
-    await a.send('b', { type: 'commit', payload: { n: 1 } });
-    // Manually replay a seq=1 message by constructing it with a's key.
-    const replayed: ConsensusMessage = {
-      type: 'commit', from: 'a', to: 'b', payload: { n: 1 }, seq: 1,
-      signature: signMessage({ type: 'commit', from: 'a', to: 'b', payload: { n: 1 }, seq: 1 }, kpA.privateKeyPem),
-    };
-    // Reach into the registry to redeliver — simulates a network replay.
-    // (No public API for this; the assertion is that the seq check would
-    // reject it. We verify via a fresh send with seq <= last instead.)
-    // Easiest: a second legitimate send has seq=2 which is fine; to force a
-    // replay we'd need internal access. Instead assert seq advanced:
-    const reg2 = new LocalTransportRegistry();
-    const a2 = new LocalTransport('a', { registry: reg2, keyPair: kpA, resolvePeerPublicKey: (id) => pubs[id] });
-    const b2 = new LocalTransport('b', { registry: reg2, keyPair: kpB, resolvePeerPublicKey: (id) => pubs[id] });
-    const seqs: number[] = [];
-    b2.onMessage((m) => { seqs.push(m.seq ?? -1); return { type: 'ack', from: 'b', payload: {} }; });
-    await a2.send('b', { type: 'x', payload: {} });
-    await a2.send('b', { type: 'x', payload: {} });
-    expect(seqs).toEqual([1, 2]);
-    void replayed;
-    await a.close(); await b.close(); await a2.close(); await b2.close();
-  });
-});