claude-code-swarm 0.3.3 → 0.3.5

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

@@ -0,0 +1,527 @@
+/**
+ * End-to-end tests: Two real agent-inbox instances communicating
+ * through agentic-mesh federation.
+ *
+ * Each test sets up two complete agent-inbox stacks (storage, router,
+ * traceability, notifier, mapClient, federation) connected via linked
+ * MockMeshPeers. Messages sent from agents on one system are delivered
+ * to agents on the other system through the full pipeline:
+ *
+ *   Agent on System-A → router.routeMessage()
+ *     → ConnectionManager.route() → FederationGateway.route()
+ *       → [linked mock mesh] →
+ *         → System-B MapServer.deliverLocally()
+ *           → DeliveryBridge.deliverToAgent()
+ *             → storage.putMessage() + events.emit("message.created")
+ *               → traceability + push notifier
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+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";
+import type { Message } from "../../src/types.js";
+import { createLinkedMeshPeerPair, LinkedMockMeshPeer } from "./mock-meshpeer.js";
+
+// ---------------------------------------------------------------------------
+// Helper: wire up a full agent-inbox stack on a MeshPeer
+// ---------------------------------------------------------------------------
+
+interface InboxStack {
+  peerId: string;
+  systemId: string;
+  storage: InMemoryStorage;
+  events: EventEmitter;
+  router: MessageRouter;
+  traceability: TraceabilityLayer;
+  mapClient: MapClient;
+  federation: ConnectionManager;
+  meshPeer: LinkedMockMeshPeer;
+  stop(): Promise<void>;
+}
+
+async function createInboxOnMesh(
+  meshPeer: LinkedMockMeshPeer,
+  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);
+
+  // Install DeliveryBridge on MapServer
+  const bridge = new DeliveryBridge(storage, events, scope);
+  const server = meshPeer.server;
+  server.setDeliveryHandler(bridge);
+
+  // Set up federation
+  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 agentic-mesh", () => {
+  let meshPeerA: LinkedMockMeshPeer;
+  let meshPeerB: LinkedMockMeshPeer;
+  let inboxA: InboxStack;
+  let inboxB: InboxStack;
+
+  beforeEach(async () => {
+    [meshPeerA, meshPeerB] = createLinkedMeshPeerPair(
+      { peerId: "peer-a", systemId: "system-a" },
+      { peerId: "peer-b", systemId: "system-b" }
+    );
+
+    inboxA = await createInboxOnMesh(meshPeerA);
+    inboxB = await createInboxOnMesh(meshPeerB);
+
+    // Register local agents
+    inboxA.storage.putAgent({
+      agent_id: "alice",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+    inboxB.storage.putAgent({
+      agent_id: "bob",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    // Federate: A ↔ B
+    await inboxA.federation.federate({
+      systemId: "system-b",
+      meshPeerId: "peer-b",
+    });
+    await inboxB.federation.federate({
+      systemId: "system-a",
+      meshPeerId: "peer-a",
+    });
+  });
+
+  afterEach(async () => {
+    await inboxA.stop();
+    await inboxB.stop();
+  });
+
+  // -----------------------------------------------------------------------
+  // 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",
+    });
+
+    // Wait for async delivery through the gateway
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Verify bob received the message on system-b
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].content).toEqual({ type: "text", text: "Hello Bob, this is Alice!" });
+    expect(bobInbox[0].sender_id).toBe("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, 50));
+
+    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).toBe("bob");
+  });
+
+  // -----------------------------------------------------------------------
+  // Reply chain
+  // -----------------------------------------------------------------------
+
+  it("should support a full reply chain: A→B→A", async () => {
+    // Step 1: Alice sends to Bob
+    const original = 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, 50));
+
+    // Verify Bob received it
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].subject).toBe("PR Review");
+    expect(bobInbox[0].importance).toBe("high");
+
+    // Step 2: Bob replies to Alice
+    const bobMessage = bobInbox[0];
+    await inboxB.router.routeMessage({
+      from: "bob",
+      to: "alice@system-a",
+      payload: "LGTM, approved!",
+      subject: "PR Review",
+      threadTag: "pr-42",
+      inReplyTo: bobMessage.id,
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Verify Alice received the reply
+    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 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, 50));
+
+    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, multiple messages
+  // -----------------------------------------------------------------------
+
+  it("should handle multiple agents sending messages in both directions", async () => {
+    // Register a second agent on system-a
+    inboxA.storage.putAgent({
+      agent_id: "carol",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    // Alice → Bob
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "Message 1 from alice",
+    });
+
+    // Carol → Bob
+    await inboxA.router.routeMessage({
+      from: "carol",
+      to: "bob@system-b",
+      payload: "Message 2 from carol",
+    });
+
+    // Bob → Alice
+    await inboxB.router.routeMessage({
+      from: "bob",
+      to: "alice@system-a",
+      payload: "Reply from bob",
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Bob should have 2 messages
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(2);
+    const senders = bobInbox.map((m) => m.sender_id).sort();
+    expect(senders).toEqual(["alice", "carol"]);
+
+    // Alice should have 1 message
+    const aliceInbox = inboxA.storage.getInbox("alice");
+    expect(aliceInbox).toHaveLength(1);
+    expect(aliceInbox[0].sender_id).toBe("bob");
+  });
+
+  // -----------------------------------------------------------------------
+  // Traceability: conversations and turns
+  // -----------------------------------------------------------------------
+
+  it("should trigger traceability on both sides", 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, 50));
+
+    // message.created should have been emitted on system-b
+    expect(traceSpy).toHaveBeenCalledTimes(1);
+    const delivered = traceSpy.mock.calls[0][0] as Message;
+    expect(delivered.sender_id).toBe("alice");
+
+    // Traceability layer on system-b should have created a conversation
+    const conversations = inboxB.storage.listConversations("default");
+    expect(conversations.length).toBeGreaterThan(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Event content types
+  // -----------------------------------------------------------------------
+
+  it("should deliver event-type content across 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, 50));
+
+    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" },
+    });
+  });
+
+  it("should deliver reference-type content across federation", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: { type: "reference", uri: "https://github.com/org/repo/pull/42", label: "PR #42" },
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    expect(bobInbox[0].content).toEqual({
+      type: "reference",
+      uri: "https://github.com/org/repo/pull/42",
+      label: "PR #42",
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Local messages should not go through federation
+  // -----------------------------------------------------------------------
+
+  it("should deliver local messages without federation", async () => {
+    const routeSpy = vi.fn();
+    inboxA.events.on("federation.route", routeSpy);
+
+    // Alice sends to Carol (both on system-a)
+    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");
+
+    // Federation should not have been invoked
+    expect(routeSpy).not.toHaveBeenCalled();
+  });
+
+  // -----------------------------------------------------------------------
+  // Message with metadata passthrough
+  // -----------------------------------------------------------------------
+
+  it("should preserve custom metadata through 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, 50));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(1);
+    // Custom metadata is encoded in _meta and carried through
+    const meta = bobInbox[0].metadata;
+    expect(meta.customTag).toBe("important");
+    expect(meta.priority_override).toBe(true);
+    expect(meta.nested).toEqual({ key: "value" });
+  });
+
+  // -----------------------------------------------------------------------
+  // Rapid-fire: many messages in sequence
+  // -----------------------------------------------------------------------
+
+  it("should handle rapid sequential messages", async () => {
+    const count = 20;
+    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, 100));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox).toHaveLength(count);
+
+    // Verify all messages arrived (order may vary)
+    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}`);
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Bidirectional concurrent messaging
+  // -----------------------------------------------------------------------
+
+  it("should handle concurrent bidirectional messaging", async () => {
+    // Both sides send simultaneously
+    const sends = [
+      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 Promise.all(sends);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    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" });
+  });
+
+  // -----------------------------------------------------------------------
+  // String payload normalization
+  // -----------------------------------------------------------------------
+
+  it("should normalize string payloads on both sides", async () => {
+    await inboxA.router.routeMessage({
+      from: "alice",
+      to: "bob@system-b",
+      payload: "plain string",
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const bobInbox = inboxB.storage.getInbox("bob");
+    expect(bobInbox[0].content).toEqual({ type: "text", text: "plain string" });
+  });
+
+  // -----------------------------------------------------------------------
+  // Importance levels
+  // -----------------------------------------------------------------------
+
+  it("should preserve all importance levels across 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, 50));
+
+    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);
+    }
+  });
+});