claude-code-swarm 0.3.3 → 0.3.5

package/references/agent-inbox/test/federation/trust.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "vitest";
+import { TrustManager } from "../../src/federation/trust.js";
+
+describe("TrustManager", () => {
+  describe("canConnect", () => {
+    it("should allow all when allowedServers is empty (open federation)", () => {
+      const trust = new TrustManager({ allowedServers: [] });
+      expect(trust.canConnect("any-system")).toBe(true);
+    });
+
+    it("should allow servers in the allow-list", () => {
+      const trust = new TrustManager({
+        allowedServers: ["backend-team", "ml-team"],
+      });
+      expect(trust.canConnect("backend-team")).toBe(true);
+      expect(trust.canConnect("ml-team")).toBe(true);
+    });
+
+    it("should reject servers not in the allow-list", () => {
+      const trust = new TrustManager({
+        allowedServers: ["backend-team"],
+      });
+      expect(trust.canConnect("unknown-system")).toBe(false);
+    });
+  });
+
+  describe("canRoute", () => {
+    it("should allow all when no scope permissions defined", () => {
+      const trust = new TrustManager({});
+      expect(trust.canRoute("any-system", "any-scope")).toBe(true);
+    });
+
+    it("should allow permitted scope/system combinations", () => {
+      const trust = new TrustManager({
+        scopePermissions: { production: ["backend-team"] },
+      });
+      expect(trust.canRoute("backend-team", "production")).toBe(true);
+    });
+
+    it("should deny unpermitted scope/system combinations", () => {
+      const trust = new TrustManager({
+        scopePermissions: { production: ["backend-team"] },
+      });
+      expect(trust.canRoute("unknown-team", "production")).toBe(false);
+    });
+
+    it("should allow when scope has no restrictions", () => {
+      const trust = new TrustManager({
+        scopePermissions: { production: ["backend-team"] },
+      });
+      expect(trust.canRoute("any-system", "development")).toBe(true);
+    });
+  });
+
+  describe("validateAuth", () => {
+    it("should pass when requireAuth is false", () => {
+      const trust = new TrustManager({ requireAuth: false });
+      expect(trust.validateAuth("any-system")).toBe(true);
+    });
+
+    it("should pass when no token configured for system", () => {
+      const trust = new TrustManager({ requireAuth: true });
+      expect(trust.validateAuth("any-system")).toBe(true);
+    });
+
+    it("should validate token when configured", () => {
+      const trust = new TrustManager({
+        requireAuth: true,
+        authTokens: { "backend-team": "secret-123" },
+      });
+      expect(
+        trust.validateAuth("backend-team", { token: "secret-123" })
+      ).toBe(true);
+      expect(
+        trust.validateAuth("backend-team", { token: "wrong-token" })
+      ).toBe(false);
+    });
+  });
+
+  describe("updatePolicy", () => {
+    it("should update policy at runtime", () => {
+      const trust = new TrustManager({ allowedServers: [] });
+      expect(trust.canConnect("new-peer")).toBe(true);
+      trust.updatePolicy({ allowedServers: ["approved-only"] });
+      expect(trust.canConnect("new-peer")).toBe(false);
+      expect(trust.canConnect("approved-only")).toBe(true);
+    });
+  });
+});

package/references/agent-inbox/test/ipc-jsonrpc.test.ts

@@ -0,0 +1,113 @@
+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 { MailJsonRpcServer } from "../src/jsonrpc/mail-server.js";
+
+function tmpSocketPath(): string {
+  return path.join(os.tmpdir(), `inbox-rpc-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+}
+
+function sendRaw(socketPath: string, payload: object): Promise<object> {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath, () => {
+      client.write(JSON.stringify(payload) + "\n");
+    });
+    let buffer = "";
+    client.on("data", (data) => {
+      buffer += data.toString();
+      const idx = buffer.indexOf("\n");
+      if (idx !== -1) {
+        client.end();
+        resolve(JSON.parse(buffer.slice(0, idx)));
+      }
+    });
+    client.on("error", reject);
+  });
+}
+
+describe("IPC Server with JSON-RPC", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let jsonRpc: MailJsonRpcServer;
+  let server: IpcServer;
+  let socketPath: string;
+
+  beforeEach(async () => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    jsonRpc = new MailJsonRpcServer(storage, router, events);
+    socketPath = tmpSocketPath();
+    server = new IpcServer(socketPath, router, storage, jsonRpc);
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it("should handle IPC commands (action-based)", async () => {
+    const resp = await sendRaw(socketPath, { action: "ping" });
+    expect(resp).toMatchObject({ ok: true });
+  });
+
+  it("should handle JSON-RPC requests (jsonrpc-based)", async () => {
+    const resp = await sendRaw(socketPath, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "mail/create",
+      params: { subject: "Test" },
+    }) as { jsonrpc: string; id: number; result: { id: string; subject: string } };
+
+    expect(resp.jsonrpc).toBe("2.0");
+    expect(resp.id).toBe(1);
+    expect(resp.result.subject).toBe("Test");
+    expect(resp.result.id).toMatch(/^conv-/);
+  });
+
+  it("should create conversation via JSON-RPC then query via JSON-RPC", async () => {
+    // Create
+    const createResp = await sendRaw(socketPath, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "mail/create",
+      params: { subject: "Sprint Review" },
+    }) as { result: { id: string } };
+
+    // List
+    const listResp = await sendRaw(socketPath, {
+      jsonrpc: "2.0",
+      id: 2,
+      method: "mail/list",
+    }) as { result: { conversations: { id: string; subject: string }[] } };
+
+    expect(listResp.result.conversations).toHaveLength(1);
+    expect(listResp.result.conversations[0].subject).toBe("Sprint Review");
+  });
+
+  it("should handle both protocols in sequence", async () => {
+    // IPC: send a message
+    const ipcResp = await sendRaw(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "hello",
+    }) as { ok: boolean; messageId: string };
+    expect(ipcResp.ok).toBe(true);
+
+    // JSON-RPC: create a conversation
+    const rpcResp = await sendRaw(socketPath, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "mail/create",
+      params: { subject: "Test" },
+    }) as { result: { id: string } };
+    expect(rpcResp.result.id).toBeTruthy();
+  });
+});

package/references/agent-inbox/test/ipc-server.test.ts

@@ -0,0 +1,197 @@
+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 * as fs from "node:fs";
+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<object> {
+  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("IpcServer", () => {
+  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 respond to ping", async () => {
+    const resp = await sendCommand(socketPath, { action: "ping" });
+    expect(resp).toMatchObject({ ok: true, pid: process.pid });
+  });
+
+  it("should handle send command", async () => {
+    const resp = await sendCommand(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "hello bob",
+    }) as { ok: boolean; messageId: string };
+
+    expect(resp.ok).toBe(true);
+    expect(resp.messageId).toBeTruthy();
+
+    // Message should be stored
+    const msg = storage.getMessage(resp.messageId);
+    expect(msg).toBeDefined();
+    expect(msg!.sender_id).toBe("alice");
+    expect(msg!.content).toEqual({ type: "text", text: "hello bob" });
+  });
+
+  it("should handle notify spawn", async () => {
+    const resp = await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: {
+          agentId: "executor-1",
+          name: "Executor",
+          scopes: ["swarm:team"],
+          metadata: { template: "gsd" },
+        },
+      },
+    });
+
+    expect(resp).toMatchObject({ ok: true });
+    const agent = storage.getAgent("executor-1");
+    expect(agent).toBeDefined();
+    expect(agent!.display_name).toBe("Executor");
+    expect(agent!.scope).toBe("swarm:team");
+    expect(agent!.status).toBe("active");
+  });
+
+  it("should handle notify done", async () => {
+    // First spawn
+    await sendCommand(socketPath, {
+      action: "notify",
+      event: {
+        type: "agent.spawn",
+        agent: { agentId: "executor-1", name: "Executor", scopes: ["default"] },
+      },
+    });
+
+    // Then done
+    const resp = await sendCommand(socketPath, {
+      action: "notify",
+      event: { type: "agent.done", agentId: "executor-1" },
+    });
+
+    expect(resp).toMatchObject({ ok: true });
+    const agent = storage.getAgent("executor-1");
+    expect(agent!.status).toBe("offline");
+  });
+
+  it("should handle check_inbox command", async () => {
+    // Send a message first
+    await sendCommand(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "hello bob",
+    });
+
+    // Check inbox
+    const resp = await sendCommand(socketPath, {
+      action: "check_inbox",
+      agentId: "bob",
+    }) as { ok: boolean; messages: unknown[] };
+
+    expect(resp.ok).toBe(true);
+    expect(resp.messages).toHaveLength(1);
+    expect((resp.messages[0] as { sender_id: string }).sender_id).toBe("alice");
+  });
+
+  it("should handle check_inbox with clear", async () => {
+    await sendCommand(socketPath, {
+      action: "send",
+      from: "alice",
+      to: "bob",
+      payload: "msg 1",
+    });
+
+    // Check and clear
+    const resp1 = await sendCommand(socketPath, {
+      action: "check_inbox",
+      agentId: "bob",
+      clear: true,
+    }) as { ok: boolean; messages: unknown[] };
+
+    expect(resp1.ok).toBe(true);
+    expect(resp1.messages).toHaveLength(1);
+
+    // Check again with unreadOnly — should be empty since we cleared
+    const resp2 = await sendCommand(socketPath, {
+      action: "check_inbox",
+      agentId: "bob",
+      unreadOnly: true,
+    }) as { ok: boolean; messages: unknown[] };
+
+    expect(resp2.ok).toBe(true);
+    expect(resp2.messages).toHaveLength(0);
+  });
+
+  it("should return empty array for empty inbox", async () => {
+    const resp = await sendCommand(socketPath, {
+      action: "check_inbox",
+      agentId: "nobody",
+    }) as { ok: boolean; messages: unknown[] };
+
+    expect(resp.ok).toBe(true);
+    expect(resp.messages).toHaveLength(0);
+  });
+
+  it("should handle unknown actions gracefully", async () => {
+    const resp = await sendCommand(socketPath, { action: "unknown" }) as { ok: boolean; error: string };
+    expect(resp.ok).toBe(false);
+    expect(resp.error).toContain("Unknown action");
+  });
+
+  it("should handle concurrent clients", async () => {
+    const results = await Promise.all([
+      sendCommand(socketPath, { action: "send", from: "a1", to: "b1", payload: "m1" }),
+      sendCommand(socketPath, { action: "send", from: "a2", to: "b2", payload: "m2" }),
+      sendCommand(socketPath, { action: "ping" }),
+    ]);
+
+    expect(results).toHaveLength(3);
+    for (const r of results) {
+      expect((r as { ok: boolean }).ok).toBe(true);
+    }
+  });
+});

package/references/agent-inbox/test/mail-server.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import { MessageRouter } from "../src/router/message-router.js";
+import { MailJsonRpcServer } from "../src/jsonrpc/mail-server.js";
+
+describe("MailJsonRpcServer", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let server: MailJsonRpcServer;
+
+  beforeEach(() => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    server = new MailJsonRpcServer(storage, router, events);
+  });
+
+  function rpc(method: string, params: Record<string, unknown> = {}) {
+    return server.handleRequest({
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      params,
+    });
+  }
+
+  describe("mail/create", () => {
+    it("should create a conversation", async () => {
+      const resp = await rpc("mail/create", { subject: "Test conv", scope: "default" });
+      expect(resp.result).toBeDefined();
+      const conv = resp.result as { id: string; subject: string };
+      expect(conv.subject).toBe("Test conv");
+      expect(conv.id).toMatch(/^conv-/);
+    });
+  });
+
+  describe("mail/get", () => {
+    it("should get a conversation with turns", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      // Add a turn
+      await rpc("mail/turn", {
+        conversationId: convId,
+        participantId: "alice",
+        content: { type: "text", text: "hello" },
+      });
+
+      const getResp = await rpc("mail/get", { id: convId });
+      const result = getResp.result as { conversation: { id: string }; turns: unknown[] };
+      expect(result.conversation.id).toBe(convId);
+      expect(result.turns).toHaveLength(1);
+    });
+
+    it("should error for missing conversation", async () => {
+      const resp = await rpc("mail/get", { id: "nonexistent" });
+      expect(resp.error).toBeDefined();
+      expect(resp.error!.code).toBe(-32001);
+    });
+  });
+
+  describe("mail/list", () => {
+    it("should list conversations", async () => {
+      await rpc("mail/create", { subject: "Conv 1" });
+      await rpc("mail/create", { subject: "Conv 2" });
+
+      const resp = await rpc("mail/list");
+      const result = resp.result as { conversations: unknown[] };
+      expect(result.conversations).toHaveLength(2);
+    });
+
+    it("should filter by scope", async () => {
+      await rpc("mail/create", { subject: "A", scope: "team-a" });
+      await rpc("mail/create", { subject: "B", scope: "team-b" });
+
+      const resp = await rpc("mail/list", { scope: "team-a" });
+      const result = resp.result as { conversations: unknown[] };
+      expect(result.conversations).toHaveLength(1);
+    });
+  });
+
+  describe("mail/close", () => {
+    it("should close a conversation", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      const closeResp = await rpc("mail/close", { id: convId });
+      expect((closeResp.result as { ok: boolean }).ok).toBe(true);
+
+      const conv = storage.getConversation(convId)!;
+      expect(conv.status).toBe("completed");
+    });
+  });
+
+  describe("mail/join & mail/leave", () => {
+    it("should add and remove participants", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/join", { conversationId: convId, agentId: "alice" });
+      let conv = storage.getConversation(convId)!;
+      expect(conv.participants).toHaveLength(1);
+
+      await rpc("mail/leave", { conversationId: convId, agentId: "alice" });
+      conv = storage.getConversation(convId)!;
+      expect(conv.participants).toHaveLength(0);
+    });
+  });
+
+  describe("mail/invite", () => {
+    it("should invite an agent to a conversation", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/invite", { conversationId: convId, agentId: "bob", role: "reviewer" });
+      const conv = storage.getConversation(convId)!;
+      expect(conv.participants).toHaveLength(1);
+      expect(conv.participants[0].agent_id).toBe("bob");
+      expect(conv.participants[0].role).toBe("reviewer");
+    });
+  });
+
+  describe("mail/turn", () => {
+    it("should add a turn", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      const turnResp = await rpc("mail/turn", {
+        conversationId: convId,
+        participantId: "alice",
+        content: { type: "text", text: "hello world" },
+      });
+
+      const turn = turnResp.result as { id: string };
+      expect(turn.id).toMatch(/^turn-/);
+
+      const turns = storage.getTurns(convId);
+      expect(turns).toHaveLength(1);
+    });
+  });
+
+  describe("mail/turns/list", () => {
+    it("should list turns", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/turn", { conversationId: convId, participantId: "alice", content: { type: "text", text: "m1" } });
+      await rpc("mail/turn", { conversationId: convId, participantId: "bob", content: { type: "text", text: "m2" } });
+
+      const resp = await rpc("mail/turns/list", { conversationId: convId });
+      const result = resp.result as { turns: unknown[] };
+      expect(result.turns).toHaveLength(2);
+    });
+  });
+
+  describe("mail/thread/create & mail/thread/list", () => {
+    it("should create and list threads", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/thread/create", {
+        conversationId: convId,
+        rootTurnId: "turn-1",
+        subject: "Sub-discussion",
+      });
+
+      const resp = await rpc("mail/thread/list", { conversationId: convId });
+      const result = resp.result as { threads: { subject: string }[] };
+      expect(result.threads).toHaveLength(1);
+      expect(result.threads[0].subject).toBe("Sub-discussion");
+    });
+  });
+
+  describe("mail/replay", () => {
+    it("should replay full conversation history", async () => {
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/turn", { conversationId: convId, participantId: "alice", content: { type: "text", text: "msg 1" } });
+      await rpc("mail/turn", { conversationId: convId, participantId: "bob", content: { type: "text", text: "msg 2" } });
+
+      const resp = await rpc("mail/replay", { id: convId });
+      const result = resp.result as { conversation: { id: string }; turns: unknown[] };
+      expect(result.conversation.id).toBe(convId);
+      expect(result.turns).toHaveLength(2);
+    });
+  });
+
+  describe("event emissions", () => {
+    it("should emit mail.created on mail/create", async () => {
+      const listener = vi.fn();
+      events.on("mail.created", listener);
+
+      await rpc("mail/create", { subject: "Test" });
+
+      expect(listener).toHaveBeenCalledOnce();
+      expect(listener.mock.calls[0][0]).toMatchObject({ subject: "Test" });
+    });
+
+    it("should emit mail.turn.added on mail/turn", async () => {
+      const listener = vi.fn();
+      events.on("mail.turn.added", listener);
+
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/turn", {
+        conversationId: convId,
+        participantId: "alice",
+        content: { type: "text", text: "hello" },
+      });
+
+      expect(listener).toHaveBeenCalledOnce();
+      expect(listener.mock.calls[0][0]).toMatchObject({
+        conversation_id: convId,
+        participant_id: "alice",
+      });
+    });
+
+    it("should emit mail.participant.joined on mail/join", async () => {
+      const listener = vi.fn();
+      events.on("mail.participant.joined", listener);
+
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/join", { conversationId: convId, agentId: "bob" });
+
+      expect(listener).toHaveBeenCalledOnce();
+      expect(listener.mock.calls[0][0]).toEqual({
+        conversation_id: convId,
+        agent_id: "bob",
+      });
+    });
+
+    it("should not emit mail.participant.joined for duplicate join", async () => {
+      const listener = vi.fn();
+      events.on("mail.participant.joined", listener);
+
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/join", { conversationId: convId, agentId: "bob" });
+      await rpc("mail/join", { conversationId: convId, agentId: "bob" });
+
+      expect(listener).toHaveBeenCalledOnce();
+    });
+
+    it("should emit mail.closed on mail/close", async () => {
+      const listener = vi.fn();
+      events.on("mail.closed", listener);
+
+      const createResp = await rpc("mail/create", { subject: "Test" });
+      const convId = (createResp.result as { id: string }).id;
+
+      await rpc("mail/close", { id: convId });
+
+      expect(listener).toHaveBeenCalledOnce();
+      expect(listener.mock.calls[0][0]).toEqual({
+        conversation_id: convId,
+        status: "completed",
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("should reject non-2.0 jsonrpc", async () => {
+      const resp = await server.handleRequest({
+        jsonrpc: "1.0" as "2.0",
+        id: 1,
+        method: "mail/list",
+      });
+      expect(resp.error).toBeDefined();
+      expect(resp.error!.code).toBe(-32600);
+    });
+
+    it("should reject unknown methods", async () => {
+      const resp = await rpc("mail/unknown");
+      expect(resp.error).toBeDefined();
+      expect(resp.error!.code).toBe(-32601);
+    });
+  });
+});