@aria-cli/tools 1.0.0

package/tests/definitions/messaging-inbox-scope.test.ts

@@ -0,0 +1,229 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MessageStore } from "@aria/memoria/storage";
+import { NodeIdSchema } from "@aria/tools";
+import { MESSAGING_TOOL_DEFINITIONS } from "../../src/definitions/messaging.js";
+import type { ToolContext } from "../../src/types.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const memoriaDir = join(__dirname, "../../node_modules/@aria/memoria");
+const memoriaRequire = createRequire(join(memoriaDir, "package.json"));
+const Database = memoriaRequire("better-sqlite3");
+type DatabaseType = InstanceType<typeof Database>;
+
+function createTestDb(): DatabaseType {
+  const db = new Database(":memory:");
+  db.exec(`CREATE TABLE IF NOT EXISTS messages (
+    id                  TEXT PRIMARY KEY,
+    sender_id           TEXT NOT NULL,
+    sender_name         TEXT NOT NULL,
+    sender_type         TEXT NOT NULL CHECK (sender_type IN ('arion', 'worker', 'leader')),
+    recipient_id        TEXT NOT NULL,
+    recipient_name      TEXT NOT NULL,
+    reply_to            TEXT,
+    correlation_id      TEXT,
+    quest_id            TEXT,
+    type                TEXT NOT NULL,
+    content             TEXT NOT NULL,
+    metadata            TEXT,
+    priority            INTEGER DEFAULT 2 CHECK (priority >= 0 AND priority <= 4),
+    direction           TEXT NOT NULL CHECK (direction IN ('sent', 'received')),
+    read_at             INTEGER,
+    signature           TEXT,
+    created_at          INTEGER NOT NULL,
+    inbox_address_kind  TEXT,
+    inbox_address_id    TEXT
+  )`);
+  return db;
+}
+
+function findTool(name: string) {
+  const tool = MESSAGING_TOOL_DEFINITIONS.find((candidate) => candidate.name === name);
+  if (!tool) throw new Error(`Tool ${name} not found`);
+  return tool;
+}
+
+function createContext(nodeId: string, store: MessageStore): ToolContext {
+  return {
+    workingDir: "/tmp",
+    env: {},
+    confirm: async () => true,
+    messageStore: store,
+    nodeId: NodeIdSchema.parse(nodeId),
+    inboxAddress: { kind: "node", nodeId: NodeIdSchema.parse(nodeId) },
+  };
+}
+
+describe("messaging tool inbox scoping", () => {
+  afterEach(() => {
+    // no-op; dbs are closed in each test
+  });
+
+  it("check_messages only returns and marks messages from the caller inbox", async () => {
+    const db = createTestDb();
+    const store = new MessageStore(db);
+
+    store.store(
+      {
+        id: "alpha-msg",
+        sender: { id: "peer-alpha", name: "Alpha", type: "arion" },
+        recipient: { id: "node-alpha", name: "ARIA" },
+        type: "finding",
+        content: "alpha only",
+        timestamp: 1,
+      },
+      "received",
+      { kind: "node", nodeId: NodeIdSchema.parse("node-alpha") },
+    );
+    store.store(
+      {
+        id: "beta-msg",
+        sender: { id: "peer-beta", name: "Beta", type: "arion" },
+        recipient: { id: "node-beta", name: "ARIA" },
+        type: "finding",
+        content: "beta only",
+        timestamp: 2,
+      },
+      "received",
+      { kind: "node", nodeId: NodeIdSchema.parse("node-beta") },
+    );
+
+    const tool = findTool("check_messages");
+    const result = await tool.execute({ unreadOnly: true }, createContext("node-alpha", store));
+
+    expect(result.success).toBe(true);
+    expect(result.data).toMatchObject({
+      messages: [expect.objectContaining({ id: "alpha-msg", content: "alpha only" })],
+    });
+    expect(
+      store.unreadCountForInbox({ kind: "node", nodeId: NodeIdSchema.parse("node-alpha") }),
+    ).toBe(0);
+    expect(
+      store.unreadCountForInbox({ kind: "node", nodeId: NodeIdSchema.parse("node-beta") }),
+    ).toBe(1);
+
+    db.close();
+  });
+
+  it("check_messages merges node + client inbox when running as attached client", async () => {
+    const db = createTestDb();
+    const store = new MessageStore(db);
+    const nodeId = NodeIdSchema.parse("node-main");
+
+    // Message in the node inbox (from a remote peer)
+    store.store(
+      {
+        id: "peer-msg",
+        sender: { id: "remote-peer", name: "Peer", type: "arion" },
+        recipient: { id: "node-main", name: "ARIA" },
+        type: "finding",
+        content: "from remote peer",
+        timestamp: 1,
+      },
+      "received",
+      { kind: "node", nodeId },
+    );
+
+    // Message in the client inbox (from daemon to attached client)
+    store.store(
+      {
+        id: "client-msg",
+        sender: { id: "daemon", name: "ARIA", type: "leader" },
+        recipient: { id: "cli-abc", name: "CLI" },
+        type: "directive",
+        content: "from daemon",
+        timestamp: 2,
+      },
+      "received",
+      { kind: "client", clientId: "cli-abc" as unknown as import("@aria/tools").ClientId },
+    );
+
+    // Context simulates an attached client: inboxAddress is client, but nodeId also present
+    const ctx: ToolContext = {
+      workingDir: "/tmp",
+      env: {},
+      confirm: async () => true,
+      messageStore: store,
+      nodeId,
+      inboxAddress: {
+        kind: "client",
+        clientId: "cli-abc" as unknown as import("@aria/tools").ClientId,
+      },
+    };
+
+    const tool = findTool("check_messages");
+    const result = await tool.execute({ unreadOnly: true }, ctx);
+
+    expect(result.success).toBe(true);
+    const ids = (result.data as { messages: { id: string }[] }).messages.map((m) => m.id);
+    expect(ids).toContain("client-msg");
+    expect(ids).toContain("peer-msg");
+    expect(ids).toHaveLength(2);
+
+    // Both marked as read
+    expect(store.unreadCountForInbox({ kind: "node", nodeId })).toBe(0);
+    expect(
+      store.unreadCountForInbox({
+        kind: "client",
+        clientId: "cli-abc" as unknown as import("@aria/tools").ClientId,
+      }),
+    ).toBe(0);
+
+    db.close();
+  });
+
+  it("search_messages merges results from node + client inbox for attached clients", async () => {
+    const db = createTestDb();
+    const store = new MessageStore(db);
+    const nodeId = NodeIdSchema.parse("node-search");
+
+    store.store(
+      {
+        id: "node-search-msg",
+        sender: { id: "peer-x", name: "PeerX", type: "arion" },
+        recipient: { id: "node-search", name: "ARIA" },
+        type: "finding",
+        content: "hello from peer",
+        timestamp: 1,
+      },
+      "received",
+      { kind: "node", nodeId },
+    );
+    store.store(
+      {
+        id: "client-search-msg",
+        sender: { id: "daemon", name: "ARIA", type: "leader" },
+        recipient: { id: "cli-search", name: "CLI" },
+        type: "directive",
+        content: "hello from daemon",
+        timestamp: 2,
+      },
+      "received",
+      { kind: "client", clientId: "cli-search" as unknown as import("@aria/tools").ClientId },
+    );
+
+    const ctx: ToolContext = {
+      workingDir: "/tmp",
+      env: {},
+      confirm: async () => true,
+      messageStore: store,
+      nodeId,
+      inboxAddress: {
+        kind: "client",
+        clientId: "cli-search" as unknown as import("@aria/tools").ClientId,
+      },
+    };
+
+    const tool = findTool("search_messages");
+    const result = await tool.execute({ query: "hello" }, ctx);
+
+    expect(result.success).toBe(true);
+    const ids = (result.data as { messages: { id: string }[] }).messages.map((m) => m.id);
+    expect(ids).toContain("node-search-msg");
+    expect(ids).toContain("client-search-msg");
+
+    db.close();
+  });
+});