agent-inbox 0.1.7 → 0.1.9

package/test/mesh/meshpeer-integration.test.ts

@@ -0,0 +1,442 @@
+/**
+ * Phase 2 integration tests: agent-inbox + MeshPeer.
+ *
+ * Tests the full flow of agent-inbox using a mock MeshPeer:
+ * - connectViaMesh() registers agent-inbox as an agent
+ * - DeliveryHandler bridge routes MAP messages to inbox storage
+ * - ConnectionManager uses FederationGateway for cross-mesh routing
+ * - Type mapping preserves inbox fields through _meta roundtrip
+ */
+
+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 { MapClient } from "../../src/map/map-client.js";
+import type {
+  MeshPeerLike,
+  MeshAgentConnection,
+  MeshMapServer,
+  MeshMapMessage,
+  MeshDeliveryHandler,
+  MeshFederationGateway,
+} 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";
+
+// ---------------------------------------------------------------------------
+// Mock MeshPeer (simulates agentic-mesh v0.2.0)
+// ---------------------------------------------------------------------------
+
+class MockAgentConnection extends EventEmitter implements MeshAgentConnection {
+  readonly agentId: string;
+  readonly isRegistered = true;
+  private _registered = false;
+
+  constructor(
+    agentId: string,
+    private server: MockMapServer
+  ) {
+    super();
+    this.agentId = agentId;
+  }
+
+  async register() {
+    this._registered = true;
+    return {
+      id: this.agentId,
+      name: this.agentId,
+      state: "active" as const,
+      ownerId: null,
+    };
+  }
+
+  async unregister() {
+    this._registered = false;
+    this.server.removeMessageHandler(this.agentId);
+  }
+
+  async send(to: unknown, payload: unknown, meta?: Record<string, unknown>) {
+    return { messageId: `msg-${Date.now()}`, delivered: [] as string[] };
+  }
+}
+
+class MockMapServer extends EventEmitter implements MeshMapServer {
+  readonly systemId = "mock-mesh-system";
+  readonly systemName = "Mock Mesh";
+
+  private messageHandlers = new Map<string, (agentId: string, message: MeshMapMessage) => void>();
+  private deliveryHandler: MeshDeliveryHandler | null = null;
+  private agents = new Map<string, unknown>();
+
+  registerAgent(params: { agentId?: string; name?: string; role?: string }) {
+    const id = params.agentId ?? `agent-${Date.now()}`;
+    const agent = { id, name: params.name, role: params.role, state: "active", ownerId: null };
+    this.agents.set(id, agent);
+    return agent;
+  }
+
+  unregisterAgent(agentId: string) {
+    this.agents.delete(agentId);
+    this.messageHandlers.delete(agentId);
+    return { id: agentId, state: "stopped", ownerId: null };
+  }
+
+  setMessageHandler(agentId: string, handler: (agentId: string, message: MeshMapMessage) => void) {
+    this.messageHandlers.set(agentId, handler);
+  }
+
+  removeMessageHandler(agentId: string) {
+    this.messageHandlers.delete(agentId);
+  }
+
+  setDeliveryHandler(handler: MeshDeliveryHandler): MeshDeliveryHandler {
+    const prev = this.deliveryHandler ?? {
+      async deliverToAgent() { return false; },
+      async forwardToPeer() { return false; },
+    };
+    this.deliveryHandler = handler;
+    return prev;
+  }
+
+  /** Simulate delivering a message to an agent via the message handler */
+  simulateIncomingMessage(agentId: string, message: MeshMapMessage) {
+    const handler = this.messageHandlers.get(agentId);
+    if (handler) {
+      handler(agentId, message);
+    }
+  }
+
+  /** Simulate delivering via the delivery handler (like MapServer's router would) */
+  async simulateDeliveryToAgent(agentId: string, message: MeshMapMessage): Promise<boolean> {
+    if (this.deliveryHandler) {
+      return this.deliveryHandler.deliverToAgent(agentId, message);
+    }
+    return false;
+  }
+}
+
+class MockFederationGateway extends EventEmitter implements MeshFederationGateway {
+  readonly localSystemId: string;
+  readonly remoteSystemId: string;
+  isConnected = true;
+  routedMessages: Array<{ message: unknown; targetAgentIds: string[] }> = [];
+
+  constructor(localSystemId: string, remoteSystemId: string) {
+    super();
+    this.localSystemId = localSystemId;
+    this.remoteSystemId = remoteSystemId;
+  }
+
+  async route(message: unknown, targetAgentIds: string[]): Promise<boolean> {
+    this.routedMessages.push({ message, targetAgentIds });
+    return true;
+  }
+}
+
+class MockMeshPeer extends EventEmitter implements MeshPeerLike {
+  readonly peerId: string;
+  readonly server: MockMapServer;
+  private agentConnections = new Map<string, MockAgentConnection>();
+  private gateways = new Map<string, MockFederationGateway>();
+
+  constructor(peerId: string) {
+    super();
+    this.peerId = peerId;
+    this.server = new MockMapServer();
+  }
+
+  async createAgent(config: {
+    agentId?: string;
+    name?: string;
+    role?: string;
+    scopes?: string[];
+    capabilities?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+  }): Promise<MeshAgentConnection> {
+    const agentId = config.agentId ?? `agent-${Date.now()}`;
+    this.server.registerAgent({
+      agentId,
+      name: config.name,
+      role: config.role,
+    });
+    const conn = new MockAgentConnection(agentId, this.server);
+    await conn.register();
+    this.agentConnections.set(agentId, conn);
+    return conn;
+  }
+
+  async federateWith(remoteSystemId: string, _config?: unknown): Promise<MockFederationGateway> {
+    const gateway = new MockFederationGateway(this.peerId, remoteSystemId);
+    this.gateways.set(remoteSystemId, gateway);
+    return gateway;
+  }
+
+  getFederationGateway(remoteSystemId: string): MockFederationGateway | undefined {
+    return this.gateways.get(remoteSystemId);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Phase 2: MeshPeer integration", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let mapClient: MapClient;
+  let meshPeer: MockMeshPeer;
+
+  beforeEach(() => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    mapClient = new MapClient(storage, router, events);
+    meshPeer = new MockMeshPeer("local-system");
+  });
+
+  afterEach(async () => {
+    await mapClient.disconnect();
+  });
+
+  describe("connectViaMesh()", () => {
+    it("should register agent-inbox as an agent on the MeshPeer", async () => {
+      const systemId = await mapClient.connectViaMesh(meshPeer);
+
+      expect(systemId).toBe("mock-mesh-system");
+      expect(mapClient.getMeshPeer()).toBe(meshPeer);
+    });
+
+    it("should set up message handler for incoming messages", async () => {
+      await mapClient.connectViaMesh(meshPeer);
+
+      const messageSpy = vi.fn();
+      events.on("message.created", messageSpy);
+
+      // Simulate an incoming MAP message to agent-inbox
+      meshPeer.server.simulateIncomingMessage("agent-inbox", {
+        id: "map-msg-1",
+        from: "remote-agent",
+        to: { agent: "agent-inbox" },
+        timestamp: Date.now(),
+        payload: { type: "text", text: "hello from mesh" },
+        meta: { priority: "high" },
+      });
+
+      expect(messageSpy).toHaveBeenCalledTimes(1);
+      const storedMsg = messageSpy.mock.calls[0][0];
+      expect(storedMsg.sender_id).toBe("remote-agent");
+      expect(storedMsg.importance).toBe("high");
+      expect(storedMsg.content).toEqual({ type: "text", text: "hello from mesh" });
+    });
+
+    it("should disconnect cleanly", async () => {
+      await mapClient.connectViaMesh(meshPeer);
+      expect(mapClient.getMeshPeer()).toBe(meshPeer);
+
+      await mapClient.disconnect();
+      expect(mapClient.getMeshPeer()).toBeNull();
+    });
+  });
+
+  describe("DeliveryBridge via setDeliveryHandler", () => {
+    it("should install delivery bridge on MapServer", async () => {
+      await mapClient.connectViaMesh(meshPeer);
+
+      // Install the delivery bridge
+      const bridge = new DeliveryBridge(storage, events, "default");
+      meshPeer.server.setDeliveryHandler(bridge);
+
+      // Simulate MapServer routing a message through the delivery handler
+      const delivered = await meshPeer.server.simulateDeliveryToAgent("agent-bob", {
+        id: "map-msg-2",
+        from: "agent-alice",
+        to: { agent: "agent-bob" },
+        timestamp: Date.now(),
+        payload: "hello from delivery bridge",
+        meta: { priority: "normal" },
+      });
+
+      expect(delivered).toBe(true);
+
+      // Verify message is in bob's inbox
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox).toHaveLength(1);
+      expect(inbox[0].sender_id).toBe("agent-alice");
+      expect(inbox[0].content).toEqual({ type: "text", text: "hello from delivery bridge" });
+    });
+
+    it("should preserve _meta fields through delivery", async () => {
+      await mapClient.connectViaMesh(meshPeer);
+
+      const bridge = new DeliveryBridge(storage, events, "default");
+      meshPeer.server.setDeliveryHandler(bridge);
+
+      await meshPeer.server.simulateDeliveryToAgent("agent-bob", {
+        id: "map-msg-3",
+        from: "agent-alice",
+        to: { agent: "agent-bob" },
+        timestamp: Date.now(),
+        payload: { type: "text", text: "review this" },
+        meta: { priority: "high" },
+        _meta: {
+          subject: "PR Review",
+          threadTag: "pr-42",
+          inReplyTo: "prev-msg-1",
+        },
+      });
+
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox[0].subject).toBe("PR Review");
+      expect(inbox[0].thread_tag).toBe("pr-42");
+      expect(inbox[0].in_reply_to).toBe("prev-msg-1");
+      expect(inbox[0].importance).toBe("high");
+    });
+  });
+
+  describe("ConnectionManager with MeshPeer federation gateway", () => {
+    it("should use federateWith() when meshPeer is provided", async () => {
+      const cm = new ConnectionManager(
+        events,
+        {
+          systemId: "local-system",
+          trust: { allowedServers: [], scopePermissions: {}, requireAuth: false },
+        },
+        { meshPeer: meshPeer as unknown as MeshPeerLike }
+      );
+
+      const link = await cm.federate({
+        systemId: "remote-system",
+        meshPeerId: "remote-peer",
+      });
+
+      expect(link.transport).toBe("mesh");
+      expect(link.status).toBe("connected");
+      expect(cm.hasGateway("remote-system")).toBe(true);
+
+      await cm.destroy();
+    });
+
+    it("should route messages through FederationGateway", async () => {
+      const cm = new ConnectionManager(
+        events,
+        {
+          systemId: "local-system",
+          trust: { allowedServers: [], scopePermissions: {}, requireAuth: false },
+        },
+        { meshPeer: meshPeer as unknown as MeshPeerLike }
+      );
+
+      await cm.federate({
+        systemId: "remote-system",
+        meshPeerId: "remote-peer",
+      });
+
+      const msg: Message = {
+        id: "msg-1",
+        scope: "default",
+        sender_id: "local-agent",
+        recipients: [{ agent_id: "bob@remote-system", kind: "to" }],
+        content: { type: "text", text: "hello via gateway" },
+        importance: "normal",
+        metadata: {},
+        created_at: new Date().toISOString(),
+      };
+
+      const result = await cm.route(msg);
+      expect(result.delivered).toBe(true);
+
+      // Verify the gateway received the route call
+      const gateway = meshPeer.getFederationGateway("remote-system");
+      expect(gateway).toBeDefined();
+      expect(gateway!.routedMessages).toHaveLength(1);
+      expect(gateway!.routedMessages[0].targetAgentIds).toEqual(["bob"]);
+
+      await cm.destroy();
+    });
+
+    it("should fall back to Phase 1 when meshPeer is not provided", async () => {
+      // Import mock mesh for Phase 1 fallback
+      const { createLinkedMeshPair } = await import("./mock-mesh.js");
+      const { MeshConnector } = await import("../../src/mesh/mesh-connector.js");
+
+      const [meshA, meshB] = createLinkedMeshPair("system-a", "system-b");
+      const meshConnector = new MeshConnector(meshA, "system-a");
+
+      const cm = new ConnectionManager(
+        events,
+        {
+          systemId: "system-a",
+          trust: { allowedServers: [], scopePermissions: {}, requireAuth: false },
+        },
+        { meshConnector }
+      );
+
+      const link = await cm.federate({
+        systemId: "system-b",
+        meshPeerId: "system-b",
+      });
+
+      expect(link.transport).toBe("mesh");
+      expect(cm.hasTransport("system-b")).toBe(true);
+      // No gateway in Phase 1
+      expect(cm.hasGateway("system-b")).toBe(false);
+
+      await cm.destroy();
+    });
+  });
+
+  describe("_meta roundtrip", () => {
+    it("should preserve inbox fields through MAP message roundtrip", async () => {
+      const { mapMessageToInbox, inboxMessageToMap } = await import(
+        "../../src/mesh/type-mapper.js"
+      );
+
+      // Create an inbox message with all fields
+      const original: Message = {
+        id: "roundtrip-1",
+        scope: "default",
+        sender_id: "alice",
+        recipients: [{ agent_id: "bob", kind: "to" }],
+        content: { type: "text", text: "roundtrip test" },
+        subject: "Test Subject",
+        thread_tag: "thread-99",
+        in_reply_to: "prev-msg",
+        conversation_id: "conv-5",
+        importance: "high",
+        metadata: { customField: "keep" },
+        created_at: new Date().toISOString(),
+      };
+
+      // Convert inbox → MAP
+      const mapData = inboxMessageToMap(original);
+
+      // Simulate sending through MAP (construct a full MapMessage)
+      const mapMsg = {
+        id: "map-roundtrip-1",
+        from: original.sender_id,
+        to: mapData.to,
+        timestamp: Date.now(),
+        payload: mapData.payload,
+        meta: mapData.meta,
+        _meta: mapData.meta._meta,
+      };
+
+      // Convert MAP → inbox
+      const recovered = mapMessageToInbox(mapMsg as any, "default");
+
+      // Verify all inbox-specific fields survived the roundtrip
+      expect(recovered.sender_id).toBe(original.sender_id);
+      expect(recovered.content).toEqual(original.content);
+      expect(recovered.subject).toBe(original.subject);
+      expect(recovered.thread_tag).toBe(original.thread_tag);
+      expect(recovered.in_reply_to).toBe(original.in_reply_to);
+      expect(recovered.conversation_id).toBe(original.conversation_id);
+      expect(recovered.importance).toBe(original.importance);
+      expect(recovered.id).toBe(original.id); // inboxMessageId preserved
+      expect(recovered.metadata.customField).toBe("keep");
+    });
+  });
+});

package/test/mesh/mock-mesh.ts

@@ -0,0 +1,125 @@
+/**
+ * Mock MeshContext and MessageChannel for testing MeshTransport
+ * without any real agentic-mesh networking.
+ *
+ * Two MockMeshContext instances can be "linked" so that messages
+ * sent from one arrive at the other — simulating a mesh connection.
+ */
+
+import { EventEmitter } from "node:events";
+import type {
+  MeshContextLike,
+  MeshChannel,
+  MeshPeerInfo,
+  InboxWireMessage,
+} from "../../src/mesh/mesh-transport.js";
+
+// ---------------------------------------------------------------------------
+// MockMessageChannel
+// ---------------------------------------------------------------------------
+
+export class MockMessageChannel<T> extends EventEmitter implements MeshChannel<T> {
+  readonly name: string;
+  private _open = false;
+
+  constructor(
+    name: string,
+    private mesh: MockMeshContext
+  ) {
+    super();
+    this.name = name;
+  }
+
+  get isOpen(): boolean {
+    return this._open;
+  }
+
+  async open(): Promise<void> {
+    this._open = true;
+  }
+
+  async close(): Promise<void> {
+    this._open = false;
+    this.removeAllListeners();
+  }
+
+  send(peerId: string, message: T): boolean {
+    if (!this._open) return false;
+
+    // Deliver to linked mesh peers
+    const target = this.mesh._getLinkedPeer(peerId);
+    if (!target) return false;
+
+    const targetChannel = target._getChannel(this.name);
+    if (!targetChannel || !targetChannel.isOpen) return false;
+
+    // Simulate async delivery (next tick)
+    const from: MeshPeerInfo = {
+      id: this.mesh._peerId,
+      groups: [],
+    };
+    process.nextTick(() => {
+      targetChannel.emit("message", message, from);
+    });
+    return true;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// MockMeshContext
+// ---------------------------------------------------------------------------
+
+export class MockMeshContext implements MeshContextLike {
+  readonly _peerId: string;
+  private channels = new Map<string, MockMessageChannel<unknown>>();
+  private linkedPeers = new Map<string, MockMeshContext>();
+
+  constructor(peerId: string) {
+    this._peerId = peerId;
+  }
+
+  _getPeerId(): string {
+    return this._peerId;
+  }
+
+  createChannel<T>(name: string): MeshChannel<T> {
+    let ch = this.channels.get(name);
+    if (!ch) {
+      ch = new MockMessageChannel<unknown>(name, this);
+      this.channels.set(name, ch);
+    }
+    return ch as unknown as MeshChannel<T>;
+  }
+
+  /** @internal Get a channel by name (for cross-mesh delivery). */
+  _getChannel(name: string): MockMessageChannel<unknown> | undefined {
+    return this.channels.get(name);
+  }
+
+  /** @internal Get a linked peer by ID (for cross-mesh delivery). */
+  _getLinkedPeer(peerId: string): MockMeshContext | undefined {
+    return this.linkedPeers.get(peerId);
+  }
+
+  /**
+   * Link two MockMeshContext instances so they can exchange messages.
+   * Must be called on both sides (or use the static helper).
+   */
+  linkPeer(other: MockMeshContext): void {
+    this.linkedPeers.set(other._peerId, other);
+    other.linkedPeers.set(this._peerId, this);
+  }
+}
+
+/**
+ * Create a pair of linked mock mesh contexts.
+ */
+export function createLinkedMeshPair(
+  peerA: string,
+  peerB: string
+): [MockMeshContext, MockMeshContext] {
+  const a = new MockMeshContext(peerA);
+  const b = new MockMeshContext(peerB);
+  a.linkPeer(b);
+  return [a, b];
+}