agent-inbox 0.0.1 → 0.1.1

package/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/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/test/sqlite-storage.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { SqliteStorage } from "../src/storage/sqlite.js";
+import type { Agent, Message, Conversation, Turn } 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", () => {
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    storage = new SqliteStorage({ path: ":memory:" });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe("Agents", () => {
+    it("should put and get an agent", () => {
+      const agent = makeAgent();
+      storage.putAgent(agent);
+      const result = storage.getAgent("agent-1");
+      expect(result).toBeDefined();
+      expect(result!.agent_id).toBe("agent-1");
+      expect(result!.status).toBe("active");
+    });
+
+    it("should list agents by scope", () => {
+      storage.putAgent(makeAgent({ agent_id: "a1", scope: "team-a" }));
+      storage.putAgent(makeAgent({ agent_id: "a2", scope: "team-b" }));
+      storage.putAgent(makeAgent({ agent_id: "a3", scope: "team-a" }));
+
+      expect(storage.listAgents("team-a")).toHaveLength(2);
+      expect(storage.listAgents("team-b")).toHaveLength(1);
+      expect(storage.listAgents()).toHaveLength(3);
+    });
+
+    it("should remove an agent", () => {
+      storage.putAgent(makeAgent());
+      expect(storage.removeAgent("agent-1")).toBe(true);
+      expect(storage.getAgent("agent-1")).toBeUndefined();
+    });
+
+    it("should update agent on re-put", () => {
+      storage.putAgent(makeAgent({ status: "active" }));
+      storage.putAgent(makeAgent({ status: "offline" }));
+      expect(storage.getAgent("agent-1")!.status).toBe("offline");
+    });
+  });
+
+  describe("Messages", () => {
+    it("should store and retrieve message with recipients", () => {
+      const msg = makeMessage();
+      storage.putMessage(msg);
+      const result = storage.getMessage("msg-1");
+      expect(result).toBeDefined();
+      expect(result!.sender_id).toBe("agent-1");
+      expect(result!.recipients).toHaveLength(1);
+      expect(result!.recipients[0].agent_id).toBe("agent-2");
+      expect(result!.content).toEqual({ type: "text", text: "hello" });
+    });
+
+    it("should get inbox for agent", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", recipients: [{ agent_id: "bob", kind: "to" }], created_at: "2025-01-01T00:00:01Z" })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", recipients: [{ agent_id: "bob", kind: "to" }], created_at: "2025-01-01T00:00:02Z" })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m3", recipients: [{ agent_id: "alice", kind: "to" }] })
+      );
+
+      const inbox = storage.getInbox("bob");
+      expect(inbox).toHaveLength(2);
+    });
+
+    it("should filter unread only", () => {
+      storage.putMessage(
+        makeMessage({
+          id: "m1",
+          recipients: [{ agent_id: "bob", kind: "to", read_at: "2025-01-01T00:00:05Z" }],
+        })
+      );
+      storage.putMessage(
+        makeMessage({
+          id: "m2",
+          recipients: [{ agent_id: "bob", kind: "to" }],
+        })
+      );
+
+      const unread = storage.getInbox("bob", { unreadOnly: true });
+      expect(unread).toHaveLength(1);
+      expect(unread[0].id).toBe("m2");
+    });
+
+    it("should get thread by tag", () => {
+      storage.putMessage(makeMessage({ id: "m1", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m2", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m3", thread_tag: "sprint-2", scope: "default" }));
+
+      const thread = storage.getThread({ threadTag: "sprint-1", scope: "default" });
+      expect(thread).toHaveLength(2);
+    });
+
+    it("should update message recipients on re-put", () => {
+      const msg = makeMessage({
+        recipients: [{ agent_id: "bob", kind: "to" }],
+      });
+      storage.putMessage(msg);
+
+      msg.recipients[0].read_at = "2025-01-01T01:00:00Z";
+      storage.putMessage(msg);
+
+      const result = storage.getMessage("msg-1")!;
+      expect(result.recipients[0].read_at).toBe("2025-01-01T01:00:00Z");
+    });
+  });
+
+  describe("Full-text search", () => {
+    it("should find messages by text content", () => {
+      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 find messages by subject", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", subject: "auth issue", content: { type: "text", text: "details" } })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", subject: "deploy plan", content: { type: "text", text: "steps" } })
+      );
+
+      const results = storage.searchMessages("auth");
+      expect(results).toHaveLength(1);
+    });
+
+    it("should filter search by scope", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", scope: "team-a", content: { type: "text", text: "auth fix" } })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", scope: "team-b", content: { type: "text", text: "auth fix" } })
+      );
+
+      const results = storage.searchMessages("auth", "team-a");
+      expect(results).toHaveLength(1);
+      expect(results[0].scope).toBe("team-a");
+    });
+  });
+
+  describe("Conversations", () => {
+    it("should store and retrieve with participants", () => {
+      const conv: Conversation = {
+        id: "conv-1",
+        scope: "default",
+        subject: "Test",
+        status: "active",
+        participants: [
+          { agent_id: "alice", joined_at: "2025-01-01T00:00:00Z" },
+          { agent_id: "bob", joined_at: "2025-01-01T00:00:00Z" },
+        ],
+        metadata: {},
+        created_at: "2025-01-01T00:00:00Z",
+        updated_at: "2025-01-01T00:00:00Z",
+      };
+      storage.putConversation(conv);
+      const result = storage.getConversation("conv-1")!;
+      expect(result.subject).toBe("Test");
+      expect(result.participants).toHaveLength(2);
+    });
+  });
+
+  describe("Turns & Threads", () => {
+    it("should add and retrieve turns", () => {
+      const turn: Turn = {
+        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",
+      };
+      // Need conversation first for FK
+      storage.putConversation({
+        id: "conv-1", scope: "default", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+      storage.addTurn(turn);
+      const turns = storage.getTurns("conv-1");
+      expect(turns).toHaveLength(1);
+      expect(turns[0].participant_id).toBe("alice");
+    });
+
+    it("should store and retrieve threads", () => {
+      storage.putConversation({
+        id: "conv-1", scope: "default", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+      storage.putThread({
+        id: "thread-1",
+        conversation_id: "conv-1",
+        root_turn_id: "turn-1",
+        created_at: "2025-01-01T00:00:00Z",
+      });
+      const threads = storage.getThreadsByConversation("conv-1");
+      expect(threads).toHaveLength(1);
+      expect(threads[0].root_turn_id).toBe("turn-1");
+    });
+  });
+});