claude-code-swarm 0.3.3 → 0.3.5

package/references/agent-inbox/test/push-notifier.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+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 { PushNotifier, formatInboxMarkdown } from "../src/push/notifier.js";
+import type { InboxFileEntry } from "../src/push/notifier.js";
+
+describe("PushNotifier", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+  let notifier: PushNotifier;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "inbox-push-test-"));
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    notifier = new PushNotifier({ inboxDir: tmpDir }, storage, events);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should write to per-agent inbox file on message.created", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "hello bob",
+    });
+
+    const filePath = notifier.agentInboxPath("bob");
+    expect(fs.existsSync(filePath)).toBe(true);
+
+    const raw = fs.readFileSync(filePath, "utf-8").trim();
+    const entry = JSON.parse(raw) as InboxFileEntry;
+    expect(entry.from).toBe("alice");
+    expect(entry.to).toBe("bob");
+    expect(entry.content).toEqual({ type: "text", text: "hello bob" });
+  });
+
+  it("should write to multiple recipients", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: ["bob", "charlie"],
+      payload: "team update",
+    });
+
+    expect(fs.existsSync(notifier.agentInboxPath("bob"))).toBe(true);
+    expect(fs.existsSync(notifier.agentInboxPath("charlie"))).toBe(true);
+  });
+
+  it("should readAndClear inbox file", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "message 1",
+    });
+    await router.routeMessage({
+      from: "charlie",
+      to: "bob",
+      payload: "message 2",
+    });
+
+    const markdown = notifier.readAndClearAgentInbox("bob");
+    expect(markdown).toBeTruthy();
+    expect(markdown).toContain("2 new message(s)");
+    expect(markdown).toContain("From alice");
+    expect(markdown).toContain("From charlie");
+
+    // File should be cleared
+    const raw = fs.readFileSync(notifier.agentInboxPath("bob"), "utf-8");
+    expect(raw).toBe("");
+  });
+
+  it("should return null for empty inbox", () => {
+    const result = notifier.readAndClearAgentInbox("nonexistent");
+    expect(result).toBeNull();
+  });
+});
+
+describe("formatInboxMarkdown", () => {
+  it("should format text messages as markdown", () => {
+    const entries: InboxFileEntry[] = [
+      {
+        messageId: "m1",
+        from: "alice",
+        to: "bob",
+        content: { type: "text", text: "Fix the auth bug" },
+        importance: "high",
+        timestamp: new Date().toISOString(),
+      },
+    ];
+
+    const md = formatInboxMarkdown(entries);
+    expect(md).toContain("## [Inbox] 1 new message(s)");
+    expect(md).toContain("From alice");
+    expect(md).toContain("[high]");
+    expect(md).toContain("Fix the auth bug");
+  });
+
+  it("should show thread tags", () => {
+    const entries: InboxFileEntry[] = [
+      {
+        messageId: "m1",
+        from: "alice",
+        to: "bob",
+        content: { type: "text", text: "update" },
+        threadTag: "sprint-1",
+        importance: "normal",
+        timestamp: new Date().toISOString(),
+      },
+    ];
+
+    const md = formatInboxMarkdown(entries);
+    expect(md).toContain("thread: sprint-1");
+  });
+
+  it("should handle non-text content", () => {
+    const entries: InboxFileEntry[] = [
+      {
+        messageId: "m1",
+        from: "alice",
+        to: "bob",
+        content: { type: "data", data: { task: "deploy" } },
+        importance: "normal",
+        timestamp: new Date().toISOString(),
+      },
+    ];
+
+    const md = formatInboxMarkdown(entries);
+    expect(md).toContain("`");
+  });
+});

package/references/agent-inbox/test/registry/warm-registry.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../../src/storage/memory.js";
+import { WarmRegistry } from "../../src/registry/warm-registry.js";
+import type { Agent } from "../../src/types.js";
+
+function makeAgent(id: string, scope = "default"): Agent {
+  const now = new Date().toISOString();
+  return {
+    agent_id: id,
+    display_name: id,
+    scope,
+    status: "active",
+    metadata: {},
+    registered_at: now,
+    last_active_at: now,
+  };
+}
+
+describe("WarmRegistry", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let registry: WarmRegistry;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    registry = new WarmRegistry(storage, events, {
+      gracePeriodMs: 5000,
+      retainExpiredMs: 10000,
+      requeueOnReconnect: true,
+    });
+  });
+
+  afterEach(() => {
+    registry.destroy();
+    vi.useRealTimers();
+  });
+
+  describe("register", () => {
+    it("should register a new agent", () => {
+      const ok = registry.register(makeAgent("agent-1"));
+      expect(ok).toBe(true);
+      expect(registry.getStatus("agent-1")).toBe("active");
+      expect(registry.isRoutable("agent-1")).toBe(true);
+    });
+
+    it("should reject duplicate active agent ID (first-wins)", () => {
+      registry.register(makeAgent("agent-1"));
+      const ok = registry.register(makeAgent("agent-1"));
+      expect(ok).toBe(false);
+    });
+
+    it("should reject duplicate away agent ID", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      const ok = registry.register(makeAgent("agent-1"));
+      expect(ok).toBe(false);
+    });
+
+    it("should allow re-registering an expired agent ID", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      vi.advanceTimersByTime(6000); // past grace period
+      expect(registry.getStatus("agent-1")).toBe("expired");
+      const ok = registry.register(makeAgent("agent-1"));
+      expect(ok).toBe(true);
+      expect(registry.getStatus("agent-1")).toBe("active");
+    });
+
+    it("should store the agent in storage", () => {
+      registry.register(makeAgent("agent-1"));
+      const stored = storage.getAgent("agent-1");
+      expect(stored).toBeDefined();
+      expect(stored!.status).toBe("active");
+    });
+  });
+
+  describe("disconnect", () => {
+    it("should transition agent to away", () => {
+      registry.register(makeAgent("agent-1"));
+      const ok = registry.disconnect("agent-1");
+      expect(ok).toBe(true);
+      expect(registry.getStatus("agent-1")).toBe("away");
+      expect(registry.isRoutable("agent-1")).toBe(true); // Still routable during grace
+    });
+
+    it("should return false for non-active agent", () => {
+      expect(registry.disconnect("unknown")).toBe(false);
+    });
+
+    it("should expire after grace period", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      vi.advanceTimersByTime(5001);
+      expect(registry.getStatus("agent-1")).toBe("expired");
+      expect(registry.isRoutable("agent-1")).toBe(false);
+    });
+  });
+
+  describe("reconnect", () => {
+    it("should restore away agent to active", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      expect(registry.getStatus("agent-1")).toBe("away");
+      const ok = registry.reconnect("agent-1");
+      expect(ok).toBe(true);
+      expect(registry.getStatus("agent-1")).toBe("active");
+    });
+
+    it("should cancel grace period timer", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      registry.reconnect("agent-1");
+      vi.advanceTimersByTime(6000); // Would have expired
+      expect(registry.getStatus("agent-1")).toBe("active");
+    });
+
+    it("should return false for non-away agent", () => {
+      registry.register(makeAgent("agent-1"));
+      expect(registry.reconnect("agent-1")).toBe(false); // Active, not away
+    });
+
+    it("should emit reconnected event", () => {
+      const spy = vi.fn();
+      events.on("registry.reconnected", spy);
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      registry.reconnect("agent-1");
+      expect(spy).toHaveBeenCalledWith("agent-1");
+    });
+  });
+
+  describe("expire", () => {
+    it("should transition to expired and update storage", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      vi.advanceTimersByTime(5001);
+      expect(registry.getStatus("agent-1")).toBe("expired");
+      const stored = storage.getAgent("agent-1");
+      expect(stored?.status).toBe("offline");
+    });
+
+    it("should auto-remove after retainExpiredMs", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      vi.advanceTimersByTime(5001); // grace → expired
+      vi.advanceTimersByTime(10001); // retain → removed
+      expect(registry.getStatus("agent-1")).toBe("unknown");
+    });
+  });
+
+  describe("listRoutable", () => {
+    it("should list active and away agents", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.register(makeAgent("agent-2"));
+      registry.disconnect("agent-2");
+      const routable = registry.listRoutable();
+      expect(routable).toContain("agent-1");
+      expect(routable).toContain("agent-2");
+    });
+
+    it("should not list expired agents", () => {
+      registry.register(makeAgent("agent-1"));
+      registry.disconnect("agent-1");
+      vi.advanceTimersByTime(5001);
+      expect(registry.listRoutable()).not.toContain("agent-1");
+    });
+  });
+});

package/references/agent-inbox/test/sqlite-prefix.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import { SqliteStorage } from "../src/storage/sqlite.js";
+import type { Agent, Message } from "../src/types.js";
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    agent_id: "agent-1",
+    scope: "default",
+    status: "active",
+    metadata: {},
+    registered_at: "2025-01-01T00:00:00Z",
+    last_active_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "msg-1",
+    scope: "default",
+    sender_id: "agent-1",
+    recipients: [{ agent_id: "agent-2", kind: "to" }],
+    content: { type: "text", text: "hello" },
+    importance: "normal",
+    metadata: {},
+    created_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("SqliteStorage with prefix", () => {
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    storage = new SqliteStorage({ path: ":memory:", prefix: "inbox_" });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it("should create prefixed tables", () => {
+    storage.putAgent(makeAgent());
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+    expect(agent!.agent_id).toBe("agent-1");
+  });
+
+  it("should store and retrieve messages with prefix", () => {
+    storage.putMessage(makeMessage());
+    const msg = storage.getMessage("msg-1");
+    expect(msg).toBeDefined();
+    expect(msg!.recipients).toHaveLength(1);
+  });
+
+  it("should support full-text search with prefix", () => {
+    storage.putMessage(
+      makeMessage({ id: "m1", content: { type: "text", text: "fix the auth bug" } })
+    );
+    storage.putMessage(
+      makeMessage({ id: "m2", content: { type: "text", text: "deploy the app" } })
+    );
+    const results = storage.searchMessages("auth");
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("m1");
+  });
+
+  it("should support conversations and turns with prefix", () => {
+    storage.putConversation({
+      id: "conv-1",
+      scope: "default",
+      status: "active",
+      participants: [{ agent_id: "alice", joined_at: "2025-01-01T00:00:00Z" }],
+      metadata: {},
+      created_at: "2025-01-01T00:00:00Z",
+      updated_at: "2025-01-01T00:00:00Z",
+    });
+    storage.addTurn({
+      id: "turn-1",
+      conversation_id: "conv-1",
+      participant_id: "alice",
+      content_type: "text",
+      content: { type: "text", text: "hello" },
+      created_at: "2025-01-01T00:00:00Z",
+    });
+    const turns = storage.getTurns("conv-1");
+    expect(turns).toHaveLength(1);
+  });
+});
+
+describe("SqliteStorage with external DB handle", () => {
+  let externalDb: Database.Database;
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    externalDb = new Database(":memory:");
+    externalDb.pragma("journal_mode = WAL");
+    externalDb.pragma("foreign_keys = ON");
+    storage = new SqliteStorage({ db: externalDb, prefix: "inbox_" });
+  });
+
+  afterEach(() => {
+    storage.close(); // should NOT close the external DB
+    // Verify external DB is still usable
+    expect(() => externalDb.pragma("journal_mode")).not.toThrow();
+    externalDb.close();
+  });
+
+  it("should use the external DB handle", () => {
+    storage.putAgent(makeAgent());
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+  });
+
+  it("should create prefixed tables in external DB", () => {
+    storage.putAgent(makeAgent());
+    // Query the external DB directly to verify prefixed table exists
+    const rows = externalDb
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'inbox_%'")
+      .all() as { name: string }[];
+    const tableNames = rows.map((r) => r.name);
+    expect(tableNames).toContain("inbox_agents");
+    expect(tableNames).toContain("inbox_messages");
+    expect(tableNames).toContain("inbox_recipients");
+  });
+
+  it("should not close external DB on storage.close()", () => {
+    storage.close();
+    // External DB should still work
+    const result = externalDb.prepare("SELECT 1 as val").get() as { val: number };
+    expect(result.val).toBe(1);
+  });
+
+  it("should coexist with other tables in the same DB", () => {
+    // Create a non-inbox table in the same DB
+    externalDb.exec("CREATE TABLE IF NOT EXISTS hive_posts (id TEXT PRIMARY KEY, title TEXT)");
+    externalDb.prepare("INSERT INTO hive_posts (id, title) VALUES (?, ?)").run("p1", "Hello World");
+
+    // Inbox operations should work independently
+    storage.putAgent(makeAgent());
+    storage.putMessage(makeMessage());
+
+    // Both should be accessible
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+    const post = externalDb.prepare("SELECT title FROM hive_posts WHERE id = ?").get("p1") as { title: string };
+    expect(post.title).toBe("Hello World");
+  });
+});
+
+describe("Two SqliteStorage instances sharing one DB", () => {
+  let sharedDb: Database.Database;
+  let storageA: SqliteStorage;
+  let storageB: SqliteStorage;
+
+  beforeEach(() => {
+    sharedDb = new Database(":memory:");
+    sharedDb.pragma("journal_mode = WAL");
+    sharedDb.pragma("foreign_keys = ON");
+    storageA = new SqliteStorage({ db: sharedDb, prefix: "inbox_a_" });
+    storageB = new SqliteStorage({ db: sharedDb, prefix: "inbox_b_" });
+  });
+
+  afterEach(() => {
+    storageA.close();
+    storageB.close();
+    sharedDb.close();
+  });
+
+  it("should isolate data between prefixes", () => {
+    storageA.putAgent(makeAgent({ agent_id: "alice" }));
+    storageB.putAgent(makeAgent({ agent_id: "bob" }));
+
+    expect(storageA.getAgent("alice")).toBeDefined();
+    expect(storageA.getAgent("bob")).toBeUndefined();
+
+    expect(storageB.getAgent("bob")).toBeDefined();
+    expect(storageB.getAgent("alice")).toBeUndefined();
+  });
+
+  it("should isolate messages between prefixes", () => {
+    storageA.putMessage(makeMessage({ id: "m1", sender_id: "alice" }));
+    storageB.putMessage(makeMessage({ id: "m2", sender_id: "bob" }));
+
+    expect(storageA.getMessage("m1")).toBeDefined();
+    expect(storageA.getMessage("m2")).toBeUndefined();
+
+    expect(storageB.getMessage("m2")).toBeDefined();
+    expect(storageB.getMessage("m1")).toBeUndefined();
+  });
+});