claude-code-swarm 0.3.4 → 0.3.6

package/references/agent-inbox/test/federation/sdk-integration.test.ts

@@ -0,0 +1,744 @@
+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 { ConnectionManager } from "../../src/federation/connection-manager.js";
+import type {
+  MapConnection,
+  MapAgentConnectionClass,
+  IncomingMapMessage,
+} from "../../src/map/map-client.js";
+
+// ---------------------------------------------------------------------------
+// MockMapServer — in-process MAP server that brokers messages between
+// connected "agents" (which are really federation gateways).
+//
+// Each call to connect() returns a MapConnection. When a connection calls
+// send({ agentId }, payload, meta), the server delivers the message to the
+// connection whose `name` matches `agentId` (or whose `peerSystemId` matches).
+// This simulates real MAP message routing between two systems.
+// ---------------------------------------------------------------------------
+
+interface ServerConnection {
+  name: string;
+  peerSystemId?: string;
+  systemId?: string;
+  handler: ((msg: IncomingMapMessage) => void) | null;
+  disconnected: boolean;
+}
+
+class MockMapServer {
+  readonly connections: ServerConnection[] = [];
+
+  /**
+   * Create an SDK class bound to this server instance.
+   * Each call to sdkClass.connect(url, opts) registers a connection.
+   */
+  createSdkClass(): MapAgentConnectionClass {
+    const server = this;
+    return {
+      connect: async (
+        _url: string,
+        opts: Record<string, unknown>
+      ): Promise<MapConnection> => {
+        const name = opts.name as string;
+        const metadata = opts.metadata as Record<string, unknown> | undefined;
+
+        const serverConn: ServerConnection = {
+          name,
+          peerSystemId: metadata?.peerSystemId as string | undefined,
+          systemId: metadata?.systemId as string | undefined,
+          handler: null,
+          disconnected: false,
+        };
+        server.connections.push(serverConn);
+
+        const conn: MapConnection = {
+          send: async (
+            to: { agentId?: string; scope?: string },
+            payload: unknown,
+            meta?: Record<string, unknown>
+          ): Promise<void> => {
+            if (serverConn.disconnected) {
+              throw new Error("Connection closed");
+            }
+            // Check if any target is reachable — if not, throw
+            const delivered = server.deliver(name, to, payload, meta);
+            if (!delivered) {
+              throw new Error("No reachable target");
+            }
+          },
+          onMessage: (handler: (msg: IncomingMapMessage) => void): void => {
+            serverConn.handler = handler;
+          },
+          disconnect: async (): Promise<void> => {
+            serverConn.disconnected = true;
+          },
+        };
+
+        return conn;
+      },
+    };
+  }
+
+  /**
+   * Route a message from `senderName` to the appropriate connection.
+   *
+   * Routing logic (mimics MAP server behavior):
+   * 1. If to.agentId matches a connection's `name` → deliver there
+   * 2. If to.agentId matches a connection's `peerSystemId` → deliver there
+   * 3. Otherwise deliver to ALL connections except sender (broadcast)
+   */
+  deliver(
+    senderName: string,
+    to: { agentId?: string; scope?: string },
+    payload: unknown,
+    meta?: Record<string, unknown>
+  ): boolean {
+    const targets = this.findTargets(senderName, to);
+    let delivered = false;
+    for (const target of targets) {
+      if (target.handler && !target.disconnected) {
+        target.handler({
+          from: senderName,
+          payload,
+          timestamp: new Date().toISOString(),
+          meta: meta as IncomingMapMessage["meta"],
+        });
+        delivered = true;
+      }
+    }
+    return delivered;
+  }
+
+  private findTargets(
+    senderName: string,
+    to: { agentId?: string; scope?: string }
+  ): ServerConnection[] {
+    if (to.agentId) {
+      // Direct delivery: find connection by name or peerSystemId
+      const direct = this.connections.find(
+        (c) =>
+          !c.disconnected &&
+          c.name !== senderName &&
+          (c.name === to.agentId || c.peerSystemId === to.agentId)
+      );
+      if (direct) return [direct];
+
+      // Fall back: find connection whose systemId matches the target
+      // (the target agent is on that system)
+      const bySystem = this.connections.find(
+        (c) =>
+          !c.disconnected &&
+          c.name !== senderName &&
+          c.systemId === to.agentId
+      );
+      if (bySystem) return [bySystem];
+    }
+
+    // Broadcast: deliver to all non-sender connections
+    return this.connections.filter(
+      (c) => !c.disconnected && c.name !== senderName
+    );
+  }
+
+  /** Disconnect a specific connection by systemId */
+  disconnectSystem(systemId: string): void {
+    for (const conn of this.connections) {
+      if (conn.systemId === systemId) {
+        conn.disconnected = true;
+      }
+    }
+  }
+
+  /** Reconnect a specific connection by systemId */
+  reconnectSystem(systemId: string): void {
+    for (const conn of this.connections) {
+      if (conn.systemId === systemId) {
+        conn.disconnected = false;
+      }
+    }
+  }
+
+  get activeConnections(): number {
+    return this.connections.filter((c) => !c.disconnected).length;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helper: create a fully-wired "system" (storage + router + federation)
+// ---------------------------------------------------------------------------
+
+interface TestSystem {
+  name: string;
+  storage: InMemoryStorage;
+  events: EventEmitter;
+  router: MessageRouter;
+  federation: ConnectionManager;
+}
+
+function createTestSystem(
+  name: string,
+  sdkClass: MapAgentConnectionClass,
+  opts: {
+    allowedServers: string[];
+    strategy?: "table" | "broadcast" | "hierarchical";
+    upstream?: string[];
+  }
+): TestSystem {
+  const storage = new InMemoryStorage();
+  const events = new EventEmitter();
+  const router = new MessageRouter(storage, events, "default");
+
+  const federation = new ConnectionManager(
+    events,
+    {
+      systemId: name,
+      trust: {
+        allowedServers: opts.allowedServers,
+        scopePermissions: {},
+        requireAuth: false,
+      },
+      routing: {
+        strategy: opts.strategy ?? "table",
+        ...(opts.upstream ? { upstream: opts.upstream } : {}),
+      },
+    },
+    {
+      sdkClass,
+      onIncomingMessage: ({ from, peerId, payload, meta }) => {
+        const targetAgent = (meta?.targetAgent as string) ?? from;
+        router
+          .routeMessage({
+            from: `${from}@${peerId}`,
+            to: targetAgent,
+            payload,
+            scope: meta?.scope as string | undefined,
+            subject: meta?.subject as string | undefined,
+            importance: meta?.importance as "high" | "normal" | undefined,
+            threadTag: meta?.threadTag as string | undefined,
+            inReplyTo: meta?.inReplyTo as string | undefined,
+            metadata: meta,
+          })
+          .catch(() => {
+            // Silently handle routing errors in tests
+          });
+      },
+    }
+  );
+  router.setFederation(federation);
+
+  return { name, storage, events, router, federation };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Federation SDK Integration (two-system)", () => {
+  let mapServer: MockMapServer;
+  let system1: TestSystem;
+  let system2: TestSystem;
+
+  beforeEach(() => {
+    mapServer = new MockMapServer();
+  });
+
+  afterEach(async () => {
+    if (system1) await system1.federation.destroy();
+    if (system2) await system2.federation.destroy();
+  });
+
+  /**
+   * Helper: set up two systems federated with each other through the mock server.
+   */
+  async function setupTwoSystems(opts?: {
+    strategy1?: "table" | "broadcast" | "hierarchical";
+    strategy2?: "table" | "broadcast" | "hierarchical";
+  }) {
+    const sdk = mapServer.createSdkClass();
+
+    system1 = createTestSystem("system-1", sdk, {
+      allowedServers: ["system-2"],
+      strategy: opts?.strategy1,
+    });
+    system2 = createTestSystem("system-2", sdk, {
+      allowedServers: ["system-1"],
+      strategy: opts?.strategy2,
+    });
+
+    // Register local agents
+    system1.storage.putAgent({
+      agent_id: "alice",
+      display_name: "Alice",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+    system2.storage.putAgent({
+      agent_id: "bob",
+      display_name: "Bob",
+      scope: "default",
+      status: "active",
+      metadata: {},
+      registered_at: new Date().toISOString(),
+      last_active_at: new Date().toISOString(),
+    });
+
+    // Federate: each system connects to the other
+    await system1.federation.federate({
+      systemId: "system-2",
+      url: "ws://mock-server/system-2",
+    });
+    await system2.federation.federate({
+      systemId: "system-1",
+      url: "ws://mock-server/system-1",
+    });
+
+    // Expose agents in routing tables
+    system1.federation.routing.updateFromExposure("system-2", [
+      { agentId: "bob" },
+    ]);
+    system2.federation.routing.updateFromExposure("system-1", [
+      { agentId: "alice" },
+    ]);
+  }
+
+  describe("direct federation send (system-1 → system-2)", () => {
+    it("should deliver a message from alice@system-1 to bob@system-2", async () => {
+      await setupTwoSystems();
+
+      const msg = await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Hello Bob, this is Alice!",
+      });
+
+      // Message stored on system-1 (sender side)
+      expect(system1.storage.getMessage(msg.id)).toBeDefined();
+
+      // Note: federation routing is fire-and-forget from routeMessage's perspective,
+      // but our mock transport is synchronous, so delivery happens inline.
+      // The delivered_at is set on the message object returned by route(), but
+      // routeMessage doesn't wait for route() — so we check the receiver side.
+
+      // Message delivered to system-2 (receiver side) — in bob's inbox
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].sender_id).toBe("system-1@system-1");
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Hello Bob, this is Alice!",
+      });
+      // Verify metadata propagated
+      expect(bobInbox[0].metadata?.targetAgent).toBe("bob");
+      expect(bobInbox[0].metadata?.senderId).toBe("alice");
+      expect(bobInbox[0].metadata?.sourceSystem).toBe("system-1");
+    });
+
+    it("should preserve subject, importance, and threadTag across systems", async () => {
+      await setupTwoSystems();
+
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Urgent thread message",
+        subject: "Project Alpha",
+        importance: "high",
+        threadTag: "alpha-thread",
+      });
+
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].subject).toBe("Project Alpha");
+      expect(bobInbox[0].importance).toBe("high");
+      expect(bobInbox[0].thread_tag).toBe("alpha-thread");
+    });
+  });
+
+  describe("bidirectional messaging", () => {
+    it("should support alice → bob then bob → alice", async () => {
+      await setupTwoSystems();
+
+      // Alice sends to Bob
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Hey Bob!",
+      });
+
+      // Bob sends to Alice
+      await system2.router.routeMessage({
+        from: "bob",
+        to: "alice@system-1",
+        payload: "Hey Alice!",
+      });
+
+      // Both inboxes should have messages
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Hey Bob!",
+      });
+
+      const aliceInbox = system1.storage.getInbox("alice");
+      expect(aliceInbox).toHaveLength(1);
+      expect(aliceInbox[0].content).toEqual({
+        type: "text",
+        text: "Hey Alice!",
+      });
+    });
+
+    it("should support multiple messages in both directions", async () => {
+      await setupTwoSystems();
+
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Message 1",
+      });
+      await system2.router.routeMessage({
+        from: "bob",
+        to: "alice@system-1",
+        payload: "Message 2",
+      });
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Message 3",
+      });
+
+      expect(system2.storage.getInbox("bob")).toHaveLength(2);
+      expect(system1.storage.getInbox("alice")).toHaveLength(1);
+    });
+  });
+
+  describe("offline peer — queue and flush with transport", () => {
+    it("should queue messages when peer transport is down, then flush on reconnect", async () => {
+      await setupTwoSystems();
+
+      // Verify initial connectivity
+      expect(system1.federation.hasTransport("system-2")).toBe(true);
+
+      // Disconnect system-2's connections on the server side.
+      // This makes conn.send() throw "No reachable target" because
+      // deliver() returns false when target connections are disconnected.
+      mapServer.disconnectSystem("system-2");
+
+      // Alice tries to send — transport send fails, message gets queued
+      const msg1 = {
+        id: "queued-1",
+        scope: "default",
+        sender_id: "alice",
+        recipients: [{ agent_id: "bob@system-2", kind: "to" as const }],
+        content: { type: "text" as const, text: "Are you there?" },
+        importance: "normal" as const,
+        metadata: {},
+        created_at: new Date().toISOString(),
+      };
+      const result = await system1.federation.route(msg1);
+
+      // Message should be queued (send threw because server couldn't deliver)
+      expect(result.delivered).toBe(false);
+      expect(result.queued).toBe(true);
+      expect(system1.federation.queue.size("system-2")).toBe(1);
+
+      // Bob's inbox should be empty (message didn't get through)
+      expect(system2.storage.getInbox("bob")).toHaveLength(0);
+
+      // Reconnect system-2 on server side
+      mapServer.reconnectSystem("system-2");
+
+      // Re-federate to trigger flush (disconnect + federate = reconnect)
+      await system1.federation.disconnect("system-2");
+      await system1.federation.federate({
+        systemId: "system-2",
+        url: "ws://mock-server/system-2",
+      });
+
+      // The flush handler re-routes queued messages synchronously.
+      // Wait a tick for the async route() calls to resolve.
+      await new Promise((r) => setTimeout(r, 10));
+
+      // Queue should be drained
+      expect(system1.federation.queue.size("system-2")).toBe(0);
+
+      // Bob should now have the message
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Are you there?",
+      });
+    });
+  });
+
+  describe("broadcast strategy with real transport", () => {
+    // For system-qualified addresses (bob@system-2) where the target system IS a
+    // connected peer, delivery goes directly via transport (no broadcast needed).
+    // Broadcast/hierarchical strategies activate when the resolved peer has no
+    // active link — e.g., targeting a system we're not directly connected to.
+    //
+    // These tests verify broadcast transport by:
+    // 1. Testing system-qualified delivery to multiple peers (direct transport)
+    // 2. Verifying the broadcast event + transport work together on crafted messages
+
+    let system3: TestSystem;
+
+    afterEach(async () => {
+      if (system3) await system3.federation.destroy();
+    });
+
+    it("should deliver to multiple peers via real transport (fan-out pattern)", async () => {
+      const sdk = mapServer.createSdkClass();
+
+      system1 = createTestSystem("system-1", sdk, {
+        allowedServers: ["system-2", "system-3"],
+      });
+      system2 = createTestSystem("system-2", sdk, {
+        allowedServers: ["system-1"],
+      });
+      system3 = createTestSystem("system-3", sdk, {
+        allowedServers: ["system-1"],
+      });
+
+      // Register agents on each system
+      system1.storage.putAgent({
+        agent_id: "alice",
+        display_name: "Alice",
+        scope: "default",
+        status: "active",
+        metadata: {},
+        registered_at: new Date().toISOString(),
+        last_active_at: new Date().toISOString(),
+      });
+      system2.storage.putAgent({
+        agent_id: "bob",
+        display_name: "Bob",
+        scope: "default",
+        status: "active",
+        metadata: {},
+        registered_at: new Date().toISOString(),
+        last_active_at: new Date().toISOString(),
+      });
+      system3.storage.putAgent({
+        agent_id: "charlie",
+        display_name: "Charlie",
+        scope: "default",
+        status: "active",
+        metadata: {},
+        registered_at: new Date().toISOString(),
+        last_active_at: new Date().toISOString(),
+      });
+
+      // Federate all systems
+      await system1.federation.federate({
+        systemId: "system-2",
+        url: "ws://mock-server/system-2",
+      });
+      await system1.federation.federate({
+        systemId: "system-3",
+        url: "ws://mock-server/system-3",
+      });
+      await system2.federation.federate({
+        systemId: "system-1",
+        url: "ws://mock-server/system-1",
+      });
+      await system3.federation.federate({
+        systemId: "system-1",
+        url: "ws://mock-server/system-1",
+      });
+
+      // Send two messages: one to each remote system
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Hello Bob!",
+      });
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "charlie@system-3",
+        payload: "Hello Charlie!",
+      });
+
+      // Both should have received their messages
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Hello Bob!",
+      });
+
+      const charlieInbox = system3.storage.getInbox("charlie");
+      expect(charlieInbox).toHaveLength(1);
+      expect(charlieInbox[0].content).toEqual({
+        type: "text",
+        text: "Hello Charlie!",
+      });
+    });
+
+    it("should send to all connected peers when broadcast strategy handles unknown route", async () => {
+      const sdk = mapServer.createSdkClass();
+
+      // System-1 uses broadcast strategy
+      system1 = createTestSystem("system-1", sdk, {
+        allowedServers: ["system-2", "system-3"],
+        strategy: "broadcast",
+      });
+      system2 = createTestSystem("system-2", sdk, {
+        allowedServers: ["system-1"],
+      });
+      system3 = createTestSystem("system-3", sdk, {
+        allowedServers: ["system-1"],
+      });
+
+      system2.storage.putAgent({
+        agent_id: "bob",
+        display_name: "Bob",
+        scope: "default",
+        status: "active",
+        metadata: {},
+        registered_at: new Date().toISOString(),
+        last_active_at: new Date().toISOString(),
+      });
+
+      // Federate
+      await system1.federation.federate({
+        systemId: "system-2",
+        url: "ws://mock-server/system-2",
+      });
+      await system1.federation.federate({
+        systemId: "system-3",
+        url: "ws://mock-server/system-3",
+      });
+      await system2.federation.federate({
+        systemId: "system-1",
+        url: "ws://mock-server/system-1",
+      });
+      await system3.federation.federate({
+        systemId: "system-1",
+        url: "ws://mock-server/system-1",
+      });
+
+      // Craft a message that triggers handleUnknownRoute directly.
+      // Use a recipient with a system that resolves but has no peer link,
+      // which queues it. However, for broadcast to trigger, resolveRoute
+      // must return null — which only happens for agent-only (non-remote)
+      // addresses. So we test via direct route() call with a system-qualified
+      // address where the system IS a connected peer but the agent is NOT
+      // in the routing table. resolveRoute returns "system-2" (from addr.system),
+      // peer is connected, so it delivers directly via transport.
+      const msg = {
+        id: "broadcast-direct-1",
+        scope: "default",
+        sender_id: "alice",
+        recipients: [{ agent_id: "bob@system-2", kind: "to" as const }],
+        content: { type: "text" as const, text: "Direct via transport" },
+        importance: "normal" as const,
+        metadata: {},
+        created_at: new Date().toISOString(),
+      };
+
+      const result = await system1.federation.route(msg);
+      expect(result.delivered).toBe(true);
+      expect(result.peerId).toBe("system-2");
+
+      // Message should arrive at system-2 via real transport
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Direct via transport",
+      });
+    });
+  });
+
+  describe("transport identity verification", () => {
+    it("should connect with correct gateway metadata", async () => {
+      await setupTwoSystems();
+
+      // Verify system-1's connection to system-2
+      const sys1Conn = mapServer.connections.find(
+        (c) => c.systemId === "system-1" && c.peerSystemId === "system-2"
+      );
+      expect(sys1Conn).toBeDefined();
+      expect(sys1Conn!.name).toBe("system-1");
+
+      // Verify system-2's connection to system-1
+      const sys2Conn = mapServer.connections.find(
+        (c) => c.systemId === "system-2" && c.peerSystemId === "system-1"
+      );
+      expect(sys2Conn).toBeDefined();
+      expect(sys2Conn!.name).toBe("system-2");
+    });
+
+    it("should have 2 active connections after bilateral federation", async () => {
+      await setupTwoSystems();
+      expect(mapServer.activeConnections).toBe(2);
+    });
+  });
+
+  describe("hasTransport reflects real connections", () => {
+    it("should report transport status accurately", async () => {
+      await setupTwoSystems();
+
+      expect(system1.federation.hasTransport("system-2")).toBe(true);
+      expect(system2.federation.hasTransport("system-1")).toBe(true);
+
+      // After disconnect, transport should be gone
+      await system1.federation.disconnect("system-2");
+      expect(system1.federation.hasTransport("system-2")).toBe(false);
+
+      // system-2 still has its connection to system-1
+      expect(system2.federation.hasTransport("system-1")).toBe(true);
+    });
+  });
+
+  describe("message content fidelity", () => {
+    it("should preserve complex structured content across federation", async () => {
+      await setupTwoSystems();
+
+      const complexPayload = {
+        type: "structured",
+        blocks: [
+          { type: "heading", text: "Report" },
+          { type: "code", language: "typescript", text: "const x = 1;" },
+          { type: "list", items: ["a", "b", "c"] },
+        ],
+        attachments: [{ name: "data.json", size: 1024 }],
+      };
+
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: complexPayload,
+      });
+
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      // Content gets wrapped by normalizeContent — check the payload arrived
+      expect(bobInbox[0].content).toEqual(complexPayload);
+    });
+
+    it("should handle string payloads (auto-wrapped to text content)", async () => {
+      await setupTwoSystems();
+
+      await system1.router.routeMessage({
+        from: "alice",
+        to: "bob@system-2",
+        payload: "Simple string message",
+      });
+
+      const bobInbox = system2.storage.getInbox("bob");
+      expect(bobInbox).toHaveLength(1);
+      // normalizeContent wraps strings into { type: "text", text: "..." }
+      expect(bobInbox[0].content).toEqual({
+        type: "text",
+        text: "Simple string message",
+      });
+    });
+  });
+});