claude-code-swarm 0.3.3 → 0.3.5

package/references/agent-inbox/test/mesh/e2e-real-meshpeer.test.ts

@@ -0,0 +1,629 @@
+/**
+ * End-to-end tests: Two real agent-inbox instances communicating
+ * through real agentic-mesh MeshPeer federation.
+ *
+ * Unlike the mock-based e2e tests, these use real agentic-mesh components:
+ * - MeshPeer.createEmbedded() for in-process MAP servers
+ * - Real FederationGateway with JSON-RPC handshake + envelope routing
+ * - Real MapServer agent registration + DeliveryHandler dispatch
+ * - InMemoryMapStream pairs simulate the transport layer
+ *
+ * The only mock is the transport: instead of real networking (Nebula/Tailscale),
+ * we use linked in-memory MapStream pairs so frames written on one side appear
+ * instantly on the other. Everything above the transport is real code.
+ *
+ * Message flow:
+ *   Agent on System-A → router.routeMessage()
+ *     → ConnectionManager.route() → inboxMessageToMap()
+ *       → real FederationGateway.route() → federation envelope → MapStream
+ *         → [in-memory linked stream] →
+ *           → real FederationGateway.processIncomingEnvelope()
+ *             → real MapServer.MessageRouter.send()
+ *               → DeliveryBridge.deliverToAgent()
+ *                 → mapMessageToInbox() → storage.putMessage()
+ *                   → events.emit("message.created") → traceability
+ *
+ * Note: The real FederationGateway prefixes sender IDs with the source
+ * system, e.g. "alice" becomes "system-a:alice" when delivered to system-b.
+ * This is standard MAP federation behavior.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { MeshPeer, type MapStream, type MapFrame } from "agentic-mesh";
+import { InMemoryStorage } from "../../src/storage/memory.js";
+import { MessageRouter } from "../../src/router/message-router.js";
+import { TraceabilityLayer } from "../../src/traceability/traceability.js";
+import { MapClient } from "../../src/map/map-client.js";
+import type { MeshPeerLike } from "../../src/map/map-client.js";
+import { ConnectionManager } from "../../src/federation/connection-manager.js";
+import { DeliveryBridge } from "../../src/mesh/delivery-bridge.js";
+
+// ---------------------------------------------------------------------------
+// InMemoryMapStream: linked pair for in-process federation
+// ---------------------------------------------------------------------------
+
+class InMemoryMapStream extends EventEmitter implements MapStream {
+  readonly id: string;
+  private _isOpen = false;
+  private _state: "connecting" | "connected" | "disconnecting" | "disconnected" | "error" =
+    "disconnected";
+  private _frameQueue: MapFrame[] = [];
+  private _waitingReaders: Array<(frame: MapFrame | null) => void> = [];
+  private _peer: InMemoryMapStream | null = null;
+
+  constructor(id: string) {
+    super();
+    this.id = id;
+  }
+
+  get isOpen(): boolean {
+    return this._isOpen;
+  }
+  get state(): "connecting" | "connected" | "disconnecting" | "disconnected" | "error" {
+    return this._state;
+  }
+
+  link(peer: InMemoryMapStream): void {
+    this._peer = peer;
+  }
+
+  open(): void {
+    this._isOpen = true;
+    this._state = "connected";
+  }
+
+  async write(frame: MapFrame): Promise<void> {
+    if (!this._isOpen) throw new Error("Stream closed");
+    if (this._peer) {
+      this._peer._enqueue(frame);
+    }
+  }
+
+  _enqueue(frame: MapFrame): void {
+    if (this._waitingReaders.length > 0) {
+      const resolve = this._waitingReaders.shift()!;
+      resolve(frame);
+    } else {
+      this._frameQueue.push(frame);
+    }
+  }
+
+  async close(): Promise<void> {
+    this._isOpen = false;
+    this._state = "disconnected";
+    for (const resolve of this._waitingReaders) {
+      resolve(null);
+    }
+    this._waitingReaders = [];
+    this.emit("close");
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<MapFrame> {
+    const self = this;
+    return {
+      async next(): Promise<IteratorResult<MapFrame>> {
+        if (!self._isOpen && self._frameQueue.length === 0) {
+          return { done: true, value: undefined };
+        }
+        if (self._frameQueue.length > 0) {
+          return { done: false, value: self._frameQueue.shift()! };
+        }
+        const frame = await new Promise<MapFrame | null>((resolve) => {
+          self._waitingReaders.push(resolve);
+        });
+        if (frame === null) return { done: true, value: undefined };
+        return { done: false, value: frame };
+      },
+    };
+  }
+}
+
+function createLinkedMapStreamPair(): [InMemoryMapStream, InMemoryMapStream] {
+  const a = new InMemoryMapStream("stream-a");
+  const b = new InMemoryMapStream("stream-b");
+  a.link(b);
+  b.link(a);
+  a.open();
+  b.open();
+  return [a, b];
+}
+
+// ---------------------------------------------------------------------------
+// Helper: wire up a full agent-inbox stack on a real MeshPeer
+// ---------------------------------------------------------------------------
+
+interface InboxStack {
+  peerId: string;
+  systemId: string;
+  storage: InMemoryStorage;
+  events: EventEmitter;
+  router: MessageRouter;
+  traceability: TraceabilityLayer;
+  mapClient: MapClient;
+  federation: ConnectionManager;
+  meshPeer: MeshPeer;
+  stop(): Promise<void>;
+}
+
+async function createInboxOnMeshPeer(
+  meshPeer: MeshPeer,
+  scope = "default"
+): Promise<InboxStack> {
+  const storage = new InMemoryStorage();
+  const events = new EventEmitter();
+  const router = new MessageRouter(storage, events, scope);
+  const traceability = new TraceabilityLayer(storage, events);
+
+  const mapClient = new MapClient(storage, router, events);
+  const meshSystemId = await mapClient.connectViaMesh(
+    meshPeer as unknown as MeshPeerLike
+  );
+
+  // Install DeliveryBridge on the real MapServer
+  const bridge = new DeliveryBridge(storage, events, scope);
+  meshPeer.server.setDeliveryHandler(bridge);
+
+  // Set up federation (ConnectionManager will use meshPeer.federateWith())
+  const federation = new ConnectionManager(
+    events,
+    {
+      systemId: meshSystemId,
+      trust: { allowedServers: [], scopePermissions: {}, requireAuth: false },
+    },
+    { meshPeer: meshPeer as unknown as MeshPeerLike }
+  );
+  router.setFederation(federation);
+
+  return {
+    peerId: meshPeer.peerId,
+    systemId: meshSystemId,
+    storage,
+    events,
+    router,
+    traceability,
+    mapClient,
+    federation,
+    meshPeer,
+    async stop() {
+      await federation.destroy();
+      await mapClient.disconnect();
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("E2E: Two agent-inboxes over real agentic-mesh MeshPeers", () => {
+  let peerA: MeshPeer;
+  let peerB: MeshPeer;
+  let streams: InMemoryMapStream[];
+  let inboxA: InboxStack;
+  let inboxB: InboxStack;
+
+  beforeEach(async () => {
+    // Create two real embedded MeshPeers (in-process, no networking)
+    peerA = MeshPeer.createEmbedded({ peerId: "system-a" });
+    peerB = MeshPeer.createEmbedded({ peerId: "system-b" });
+    await peerA.start();
+    await peerB.start();
+
+    // Create linked MapStream pairs and connect FederationGateways.
+    // This must happen BEFORE wiring agent-inbox, so that when
+    // ConnectionManager.federate() calls federateWith(), the gateway
+    // already exists and is connected.
+    const [streamAtoB, streamBtoA] = createLinkedMapStreamPair();
+    streams = [streamAtoB, streamBtoA];
+    const gwA = await peerA.federateWith("system-b");
+    const gwB = await peerB.federateWith("system-a");
+
+    // Connect concurrently — each gateway sends a JSON-RPC handshake
+    // that the other must respond to
+    await Promise.all([gwA.connect(streamAtoB), gwB.connect(streamBtoA)]);
+
+    // Wire up full agent-inbox stacks on each peer
+    inboxA = await createInboxOnMeshPeer(peerA);
+    inboxB = await createInboxOnMeshPeer(peerB);
+
+    // Register local agents on each system.
+    // Agents must be registered BOTH on the real MapServer (so the real
+    // MessageRouter can resolve addresses) AND in inbox storage (so
+    // agent-inbox knows they're local).
+    await peerA.createAgent({ agentId: "alice", name: "Alice" });
+    inboxA.storage.putAgent({
+      agent_id: "alice",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+    await peerB.createAgent({ agentId: "bob", name: "Bob" });
+    inboxB.storage.putAgent({
+      agent_id: "bob",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    // Federate — ConnectionManager picks up the already-connected gateways
+    await inboxA.federation.federate({
+      systemId: "system-b",
+      meshPeerId: "system-b",
+    });
+    await inboxB.federation.federate({
+      systemId: "system-a",
+      meshPeerId: "system-a",
+    });
+  }, 15000);
+
+  afterEach(async () => {
+    await inboxA.stop();
+    await inboxB.stop();
+    // Close streams BEFORE stopping peers to unblock async iterators
+    for (const stream of streams) {
+      await stream.close();
+    }
+    await peerA.stop();
+    await peerB.stop();
+  }, 15000);
+
+  // -----------------------------------------------------------------------
+  // Basic message delivery
+  // -----------------------------------------------------------------------
+
+  it("should deliver a message from alice@system-a to bob@system-b", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "Hello Bob, this is Alice!",
+      importance: "normal",
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].content).toEqual({
+      type: "text",
+      text: "Hello Bob, this is Alice!",
+    });
+    // Real FederationGateway prefixes sender with source system
+    expect(bobInbox[0].sender_id).toContain("alice");
+  });
+
+  it("should deliver a message from bob@system-b to alice@system-a", async () => {
+    await inboxB.router.routeMessage({
+      from: "bob",
+      to: "alice@system-a",
+      payload: "Hey Alice!",
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const aliceInbox = inboxA.storage.getInbox("alice");
+    expect(aliceInbox).toHaveLength(1);
+    expect(aliceInbox[0].content).toEqual({ type: "text", text: "Hey Alice!" });
+    expect(aliceInbox[0].sender_id).toContain("bob");
+  });
+
+  // -----------------------------------------------------------------------
+  // Reply chain
+  // -----------------------------------------------------------------------
+
+  it("should support a full reply chain: A→B→A", async () => {
+    // Alice sends to Bob
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "Can you review PR #42?",
+      subject: "PR Review",
+      threadTag: "pr-42",
+      importance: "high",
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].subject).toBe("PR Review");
+    expect(bobInbox[0].importance).toBe("high");
+
+    // Bob replies to Alice
+    await inboxB.router.routeMessage({
+      from: "bob",
+      to: "alice@system-a",
+      payload: "LGTM, approved!",
+      subject: "PR Review",
+      threadTag: "pr-42",
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const aliceInbox = inboxA.storage.getInbox("alice");
+    expect(aliceInbox).toHaveLength(1);
+    expect(aliceInbox[0].content).toEqual({
+      type: "text",
+      text: "LGTM, approved!",
+    });
+    expect(aliceInbox[0].subject).toBe("PR Review");
+    expect(aliceInbox[0].thread_tag).toBe("pr-42");
+  });
+
+  // -----------------------------------------------------------------------
+  // Subject / thread_tag / importance preservation
+  // -----------------------------------------------------------------------
+
+  it("should preserve subject, thread_tag, and importance through real federation", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: {
+        type: "data",
+        schema: "review",
+        data: { pr: 42, status: "open" },
+      },
+      subject: "Urgent: production hotfix",
+      threadTag: "hotfix-2024",
+      importance: "urgent",
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    const msg = bobInbox[0];
+    expect(msg.subject).toBe("Urgent: production hotfix");
+    expect(msg.thread_tag).toBe("hotfix-2024");
+    expect(msg.importance).toBe("urgent");
+    expect(msg.content).toEqual({
+      type: "data",
+      schema: "review",
+      data: { pr: 42, status: "open" },
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Multiple agents
+  // -----------------------------------------------------------------------
+
+  it("should handle multiple agents sending messages in both directions", async () => {
+    inboxA.storage.putAgent({
+      agent_id: "carol",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "Message 1 from alice",
+    });
+    await inboxA.router.routeMessage({
+      from: "carol",
+      to: "bob@system-b",
+      payload: "Message 2 from carol",
+    });
+    await inboxB.router.routeMessage({
+      from: "bob",
+      to: "alice@system-a",
+      payload: "Reply from bob",
+    });
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(2);
+
+    const aliceInbox = inboxA.storage.getInbox("alice");
+    expect(aliceInbox).toHaveLength(1);
+    expect(aliceInbox[0].sender_id).toContain("bob");
+  });
+
+  // -----------------------------------------------------------------------
+  // Traceability
+  // -----------------------------------------------------------------------
+
+  it("should trigger traceability on both sides via real federation", async () => {
+    const traceSpy = vi.fn();
+    inboxB.events.on("message.created", traceSpy);
+
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "traceability test",
+      threadTag: "trace-thread",
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(traceSpy).toHaveBeenCalledTimes(1);
+    const delivered = traceSpy.mock.calls[0][0] as Message;
+    expect(delivered.sender_id).toContain("alice");
+
+    const conversations = inboxB.storage.listConversations("default");
+    expect(conversations.length).toBeGreaterThan(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Content types
+  // -----------------------------------------------------------------------
+
+  it("should deliver structured content types through real federation", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: {
+        type: "event",
+        event: "deployment.started",
+        data: { version: "1.2.3" },
+      },
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].content).toEqual({
+      type: "event",
+      event: "deployment.started",
+      data: { version: "1.2.3" },
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Concurrent bidirectional messaging
+  // -----------------------------------------------------------------------
+
+  it("should handle concurrent bidirectional messaging", async () => {
+    await Promise.all([
+      inboxA.router.routeMessage({
+        from: "alice",
+        to: "bob@system-b",
+        payload: "from A",
+      }),
+      inboxB.router.routeMessage({
+        from: "bob",
+        to: "alice@system-a",
+        payload: "from B",
+      }),
+    ]);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].content).toEqual({ type: "text", text: "from A" });
+
+    const aliceInbox = inboxA.storage.getInbox("alice");
+    expect(aliceInbox).toHaveLength(1);
+    expect(aliceInbox[0].content).toEqual({ type: "text", text: "from B" });
+  });
+
+  // -----------------------------------------------------------------------
+  // Importance levels
+  // -----------------------------------------------------------------------
+
+  it("should preserve all importance levels through real federation", async () => {
+    const levels = ["low", "normal", "high", "urgent"] as const;
+
+    for (const level of levels) {
+      await inboxA.router.routeMessage({
+        from: "alice",
+        to: "bob@system-b",
+        payload: `${level} message`,
+        importance: level,
+      });
+    }
+
+    await new Promise((r) => setTimeout(r, 400));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(4);
+
+    for (const level of levels) {
+      const msg = bobInbox.find(
+        (m) => m.content.type === "text" && m.content.text === `${level} message`
+      );
+      expect(msg).toBeDefined();
+      expect(msg!.importance).toBe(level);
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Custom metadata
+  // -----------------------------------------------------------------------
+
+  it("should preserve custom metadata through real federation", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "metadata test",
+      metadata: {
+        customTag: "important",
+        priority_override: true,
+        nested: { key: "value" },
+      },
+    });
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    const meta = bobInbox[0].metadata;
+    expect(meta.customTag).toBe("important");
+    expect(meta.priority_override).toBe(true);
+    expect(meta.nested).toEqual({ key: "value" });
+  });
+
+  // -----------------------------------------------------------------------
+  // Rapid-fire messages
+  // -----------------------------------------------------------------------
+
+  it("should handle rapid sequential messages through real federation", async () => {
+    const count = 10;
+    for (let i = 0; i < count; i++) {
+      await inboxA.router.routeMessage({
+        from: "alice",
+        to: "bob@system-b",
+        payload: `message ${i}`,
+      });
+    }
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(count);
+
+    const texts = bobInbox
+      .map((m) => (m.content.type === "text" ? m.content.text : ""))
+      .sort();
+    for (let i = 0; i < count; i++) {
+      expect(texts).toContain(`message ${i}`);
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Gateway state
+  // -----------------------------------------------------------------------
+
+  it("should report gateways as connected on both sides", () => {
+    expect(inboxA.federation.hasGateway("system-b")).toBe(true);
+    expect(inboxB.federation.hasGateway("system-a")).toBe(true);
+  });
+
+  // -----------------------------------------------------------------------
+  // Local messages bypass federation
+  // -----------------------------------------------------------------------
+
+  it("should deliver local messages without federation", async () => {
+    inboxA.storage.putAgent({
+      agent_id: "carol",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "carol",
+      payload: "local message",
+    });
+
+    const carolInbox = inboxA.storage.getInbox("carol");
+    expect(carolInbox).toHaveLength(1);
+    expect(carolInbox[0].sender_id).toBe("alice");
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(0);
+  });
+});