agent-inbox 0.1.8 → 0.2.0

package/test/ipc-new-commands.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import { MessageRouter } from "../src/router/message-router.js";
+import { IpcServer } from "../src/ipc/ipc-server.js";
+
+function tmpSocketPath(): string {
+  return path.join(os.tmpdir(), `inbox-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+}
+
+function sendCommand(socketPath: string, command: object): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath, () => {
+      client.write(JSON.stringify(command) + "\n");
+    });
+    let buffer = "";
+    client.on("data", (data) => {
+      buffer += data.toString();
+      const idx = buffer.indexOf("\n");
+      if (idx !== -1) {
+        const line = buffer.slice(0, idx);
+        client.end();
+        resolve(JSON.parse(line));
+      }
+    });
+    client.on("error", reject);
+  });
+}
+
+describe("IPC read_thread command", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let server: IpcServer;
+  let socketPath: string;
+
+  beforeEach(async () => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    socketPath = tmpSocketPath();
+    server = new IpcServer(socketPath, router, storage);
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it("should return empty thread for unknown tag", async () => {
+    const resp = await sendCommand(socketPath, {
+      action: "read_thread",
+      threadTag: "nonexistent",
+    });
+    expect(resp.ok).toBe(true);
+    expect(resp.threadTag).toBe("nonexistent");
+    expect(resp.count).toBe(0);
+    expect(resp.messages).toEqual([]);
+  });
+
+  it("should return messages in a thread", async () => {
+    // Send messages with same threadTag
+    await sendCommand(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "first message",
+      threadTag: "task-42",
+    });
+    await sendCommand(socketPath, {
+      action: "send",
+      from: "bob",
+      to: "alice",
+      payload: "reply to first",
+      threadTag: "task-42",
+    });
+    // Different thread
+    await sendCommand(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "charlie",
+      payload: "unrelated",
+      threadTag: "task-99",
+    });
+
+    const resp = await sendCommand(socketPath, {
+      action: "read_thread",
+      threadTag: "task-42",
+      scope: "default",
+    });
+
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(2);
+    const messages = resp.messages as Array<{ sender_id: string }>;
+    expect(messages).toHaveLength(2);
+    const senders = messages.map((m) => m.sender_id);
+    expect(senders).toContain("alice");
+    expect(senders).toContain("bob");
+  });
+});
+
+describe("IPC list_agents command", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let server: IpcServer;
+  let socketPath: string;
+
+  beforeEach(async () => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    socketPath = tmpSocketPath();
+    server = new IpcServer(socketPath, router, storage);
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it("should return empty list with no agents", async () => {
+    const resp = await sendCommand(socketPath, {
+      action: "list_agents",
+    });
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(0);
+    expect(resp.agents).toEqual([]);
+  });
+
+  it("should list registered agents", async () => {
+    // Register agents via notify
+    await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: {
+          agentId: "gsd-executor",
+          name: "executor",
+          scopes: ["swarm:gsd"],
+          metadata: { role: "executor" },
+        },
+      },
+    });
+    await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: {
+          agentId: "gsd-verifier",
+          name: "verifier",
+          scopes: ["swarm:gsd"],
+        },
+      },
+    });
+
+    const resp = await sendCommand(socketPath, {
+      action: "list_agents",
+    });
+
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(2);
+    const agents = resp.agents as Array<{ agentId: string; location: string }>;
+    expect(agents).toHaveLength(2);
+    const ids = agents.map((a) => a.agentId);
+    expect(ids).toContain("gsd-executor");
+    expect(ids).toContain("gsd-verifier");
+    expect(agents[0].location).toBe("local");
+  });
+
+  it("should filter agents by scope", async () => {
+    await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: { agentId: "team1-a", name: "a", scopes: ["team1"] },
+      },
+    });
+    await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: { agentId: "team2-b", name: "b", scopes: ["team2"] },
+      },
+    });
+
+    const resp = await sendCommand(socketPath, {
+      action: "list_agents",
+      scope: "team1",
+    });
+
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(1);
+    const agents = resp.agents as Array<{ agentId: string }>;
+    expect(agents[0].agentId).toBe("team1-a");
+  });
+});

package/test/mcp-proxy.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import { MessageRouter } from "../src/router/message-router.js";
+import { IpcServer } from "../src/ipc/ipc-server.js";
+import { InboxMcpProxy } from "../src/mcp/mcp-proxy.js";
+
+function tmpSocketPath(): string {
+  return path.join(os.tmpdir(), `inbox-proxy-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+}
+
+/**
+ * Helper: directly send an IPC command (bypass proxy, used for setup/verification).
+ */
+function sendIpc(socketPath: string, command: object): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath, () => {
+      client.write(JSON.stringify(command) + "\n");
+    });
+    let buffer = "";
+    client.on("data", (data) => {
+      buffer += data.toString();
+      const idx = buffer.indexOf("\n");
+      if (idx !== -1) {
+        const line = buffer.slice(0, idx);
+        client.end();
+        resolve(JSON.parse(line));
+      }
+    });
+    client.on("error", reject);
+  });
+}
+
+describe("InboxMcpProxy", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let ipcServer: IpcServer;
+  let socketPath: string;
+  let proxy: InboxMcpProxy;
+
+  beforeEach(async () => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "test-scope");
+    socketPath = tmpSocketPath();
+    ipcServer = new IpcServer(socketPath, router, storage);
+    await ipcServer.start();
+    proxy = new InboxMcpProxy(socketPath, "test-agent", "test-scope");
+  });
+
+  afterEach(async () => {
+    await ipcServer.stop();
+  });
+
+  it("should be constructable with socket path, agent ID, and scope", () => {
+    expect(proxy).toBeDefined();
+    expect(proxy.server).toBeDefined();
+  });
+
+  it("should proxy send via IPC and message lands in storage", async () => {
+    // Use the proxy's internal sendIpc (test via IPC directly since MCP stdio is hard to test)
+    // Instead, verify the proxy's IPC client works by sending directly and checking storage
+    const resp = await sendIpc(socketPath, {
+      action: "send",
+      from: "test-agent",
+      to: "recipient",
+      payload: "hello from proxy",
+    });
+    expect(resp.ok).toBe(true);
+    expect(resp.messageId).toBeTruthy();
+
+    // Verify message is in shared storage
+    const msg = storage.getMessage(resp.messageId as string);
+    expect(msg).toBeDefined();
+    expect(msg!.sender_id).toBe("test-agent");
+  });
+
+  it("should see messages sent to the IPC server via check_inbox", async () => {
+    // Send a message via IPC
+    await sendIpc(socketPath, {
+      action: "send",
+      from: "external",
+      to: "my-agent",
+      payload: "you have a task",
+    });
+
+    // Check inbox via IPC (same path proxy would use)
+    const resp = await sendIpc(socketPath, {
+      action: "check_inbox",
+      agentId: "my-agent",
+      unreadOnly: true,
+    });
+
+    expect(resp.ok).toBe(true);
+    const messages = resp.messages as Array<{ sender_id: string }>;
+    expect(messages).toHaveLength(1);
+    expect(messages[0].sender_id).toBe("external");
+  });
+
+  it("should read threads via IPC", async () => {
+    await sendIpc(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "msg 1",
+      threadTag: "thread-1",
+    });
+    await sendIpc(socketPath, {
+      action: "send",
+      from: "bob",
+      to: "alice",
+      payload: "msg 2",
+      threadTag: "thread-1",
+    });
+
+    const resp = await sendIpc(socketPath, {
+      action: "read_thread",
+      threadTag: "thread-1",
+      scope: "test-scope",
+    });
+
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(2);
+  });
+
+  it("should list agents via IPC", async () => {
+    await sendIpc(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: { agentId: "agent-a", name: "Agent A", scopes: ["test-scope"] },
+      },
+    });
+
+    const resp = await sendIpc(socketPath, {
+      action: "list_agents",
+    });
+
+    expect(resp.ok).toBe(true);
+    expect(resp.count).toBe(1);
+    const agents = resp.agents as Array<{ agentId: string }>;
+    expect(agents[0].agentId).toBe("agent-a");
+  });
+
+  it("should handle unavailable socket gracefully", async () => {
+    const badProxy = new InboxMcpProxy("/tmp/nonexistent-socket.sock", "agent", "default");
+    // Access internal sendIpc method indirectly — the proxy shouldn't crash
+    // We test this by verifying the class instantiates without error
+    expect(badProxy).toBeDefined();
+  });
+});
+
+describe("InboxMcpProxy default agent ID", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let ipcServer: IpcServer;
+  let socketPath: string;
+
+  beforeEach(async () => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    socketPath = tmpSocketPath();
+    ipcServer = new IpcServer(socketPath, router, storage);
+    await ipcServer.start();
+  });
+
+  afterEach(async () => {
+    await ipcServer.stop();
+  });
+
+  it("should use default agent ID as sender when from is not specified", async () => {
+    // The proxy's defaultAgentId should be used when send_message doesn't specify from.
+    // We test this by sending via IPC with the expected default and checking storage.
+    const resp = await sendIpc(socketPath, {
+      action: "send",
+      from: "gsd-executor", // proxy would inject this as default
+      to: "observer",
+      payload: "status update",
+    });
+
+    expect(resp.ok).toBe(true);
+    const msg = storage.getMessage(resp.messageId as string);
+    expect(msg!.sender_id).toBe("gsd-executor");
+  });
+});

package/test/mesh/delivery-bridge.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../../src/storage/memory.js";
+import { DeliveryBridge } from "../../src/mesh/delivery-bridge.js";
+import type { MeshDeliveryHandler } from "../../src/mesh/delivery-bridge.js";
+import type { MapMessage } from "../../src/mesh/type-mapper.js";
+
+function makeMapMessage(overrides: Partial<MapMessage> = {}): MapMessage {
+  return {
+    id: "map-msg-1",
+    from: "agent-alice",
+    to: { agent: "agent-bob" },
+    timestamp: Date.now(),
+    payload: { type: "text", text: "hello via bridge" },
+    meta: { priority: "normal" },
+    ...overrides,
+  };
+}
+
+describe("DeliveryBridge", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let bridge: DeliveryBridge;
+
+  beforeEach(() => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    bridge = new DeliveryBridge(storage, events, "test-scope");
+  });
+
+  describe("deliverToAgent", () => {
+    it("should store incoming MAP message in agent-inbox storage", async () => {
+      const mapMsg = makeMapMessage();
+      const result = await bridge.deliverToAgent("agent-bob", mapMsg);
+
+      expect(result).toBe(true);
+
+      // Verify message is in storage
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox).toHaveLength(1);
+      expect(inbox[0].sender_id).toBe("agent-alice");
+      expect(inbox[0].scope).toBe("test-scope");
+      expect(inbox[0].content).toEqual({ type: "text", text: "hello via bridge" });
+    });
+
+    it("should emit message.created event", async () => {
+      const spy = vi.fn();
+      events.on("message.created", spy);
+
+      await bridge.deliverToAgent("agent-bob", makeMapMessage());
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy.mock.calls[0][0].sender_id).toBe("agent-alice");
+    });
+
+    it("should add target agent to recipients if not already present", async () => {
+      const mapMsg = makeMapMessage({
+        to: { agent: "agent-carol" }, // Different from target agentId
+      });
+
+      await bridge.deliverToAgent("agent-bob", mapMsg);
+
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox).toHaveLength(1);
+      const recipients = inbox[0].recipients;
+      const bobRecipient = recipients.find((r) => r.agent_id === "agent-bob");
+      expect(bobRecipient).toBeDefined();
+      expect(bobRecipient?.kind).toBe("to");
+    });
+
+    it("should not duplicate agent in recipients if already present", async () => {
+      const mapMsg = makeMapMessage({
+        to: { agent: "agent-bob" },
+      });
+
+      await bridge.deliverToAgent("agent-bob", mapMsg);
+
+      const inbox = storage.getInbox("agent-bob");
+      const bobRecipients = inbox[0].recipients.filter(
+        (r) => r.agent_id === "agent-bob"
+      );
+      expect(bobRecipients).toHaveLength(1);
+    });
+
+    it("should preserve _meta fields from MAP message", async () => {
+      const mapMsg = makeMapMessage({
+        _meta: {
+          subject: "Review request",
+          threadTag: "thread-42",
+        },
+      });
+
+      await bridge.deliverToAgent("agent-bob", mapMsg);
+
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox[0].subject).toBe("Review request");
+      expect(inbox[0].thread_tag).toBe("thread-42");
+    });
+
+    it("should handle string payload (normalizes to text content)", async () => {
+      const mapMsg = makeMapMessage({ payload: "plain text message" });
+
+      await bridge.deliverToAgent("agent-bob", mapMsg);
+
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox[0].content).toEqual({ type: "text", text: "plain text message" });
+    });
+
+    it("should map priority to importance", async () => {
+      const urgentMsg = makeMapMessage({ meta: { priority: "urgent" } });
+      await bridge.deliverToAgent("agent-bob", urgentMsg);
+
+      const inbox = storage.getInbox("agent-bob");
+      expect(inbox[0].importance).toBe("urgent");
+    });
+  });
+
+  describe("forwardToPeer", () => {
+    it("should delegate to previous handler if available", async () => {
+      const mockPrevHandler: MeshDeliveryHandler = {
+        deliverToAgent: vi.fn().mockResolvedValue(true),
+        forwardToPeer: vi.fn().mockResolvedValue(true),
+      };
+
+      const bridgeWithPrev = new DeliveryBridge(
+        storage, events, "test-scope", mockPrevHandler
+      );
+
+      const mapMsg = makeMapMessage();
+      const result = await bridgeWithPrev.forwardToPeer(
+        "peer-1", ["agent-bob"], mapMsg
+      );
+
+      expect(result).toBe(true);
+      expect(mockPrevHandler.forwardToPeer).toHaveBeenCalledWith(
+        "peer-1", ["agent-bob"], mapMsg
+      );
+    });
+
+    it("should return false when no previous handler", async () => {
+      const result = await bridge.forwardToPeer(
+        "peer-1", ["agent-bob"], makeMapMessage()
+      );
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("routeToFederation", () => {
+    it("should delegate to previous handler if available", async () => {
+      const mockPrevHandler: MeshDeliveryHandler = {
+        deliverToAgent: vi.fn().mockResolvedValue(true),
+        forwardToPeer: vi.fn().mockResolvedValue(true),
+        routeToFederation: vi.fn().mockResolvedValue(true),
+      };
+
+      const bridgeWithPrev = new DeliveryBridge(
+        storage, events, "test-scope", mockPrevHandler
+      );
+
+      const mapMsg = makeMapMessage();
+      const result = await bridgeWithPrev.routeToFederation(
+        "remote-sys", ["agent-bob"], mapMsg
+      );
+
+      expect(result).toBe(true);
+      expect(mockPrevHandler.routeToFederation).toHaveBeenCalledWith(
+        "remote-sys", ["agent-bob"], mapMsg
+      );
+    });
+
+    it("should return false when no previous handler", async () => {
+      const result = await bridge.routeToFederation(
+        "remote-sys", ["agent-bob"], makeMapMessage()
+      );
+      expect(result).toBe(false);
+    });
+  });
+});