@vama/openclaw 2026.5.5-4 → 2026.5.5-6

package/src/bot.test.ts

@@ -0,0 +1,520 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/vama";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { handleVamaMessage } from "./bot.js";
+import type { VamaMessageEvent } from "./types.js";
+
+// --- Module mocks ---
+
+vi.mock("./dedup.js", () => ({
+  tryRecordMessagePersistent: vi.fn().mockResolvedValue(true),
+}));
+
+vi.mock("./reply-dispatcher.js", () => ({
+  createVamaReplyDispatcher: vi.fn(),
+}));
+
+vi.mock("./send.js", () => ({
+  sendMessageVama: vi.fn().mockResolvedValue({ messageId: "msg-1", channelId: "ch-1" }),
+}));
+
+vi.mock("./runtime.js", () => ({
+  getVamaRuntime: vi.fn(),
+}));
+
+import { tryRecordMessagePersistent } from "./dedup.js";
+import { createVamaReplyDispatcher } from "./reply-dispatcher.js";
+import { getVamaRuntime } from "./runtime.js";
+import { sendMessageVama } from "./send.js";
+
+// --- Helpers ---
+
+function makeCfg(overrides?: Record<string, unknown>): ClawdbotConfig {
+  return {
+    channels: {
+      vama: {
+        enabled: true,
+        botToken: "tok-test",
+        bothubUrl: "https://bothub.example.com",
+        dmPolicy: "open",
+        ...overrides,
+      },
+    },
+  } as ClawdbotConfig;
+}
+
+function makeEvent(overrides?: Partial<VamaMessageEvent>): VamaMessageEvent {
+  return {
+    message_id: "msg-abc",
+    channel_id: "ch-xyz",
+    sender_id: "user-1",
+    sender_name: "Test User",
+    text: "hello world",
+    created_at: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeDispatcher() {
+  const markDispatchIdle = vi.fn();
+  const dispatcher = {};
+  const replyOptions = {};
+  return { dispatcher, replyOptions, markDispatchIdle };
+}
+
+function makeRuntime() {
+  const enqueueSystemEvent = vi.fn();
+  const withReplyDispatcher = vi
+    .fn()
+    .mockResolvedValue({ queuedFinal: false, counts: { final: 1 } });
+  const dispatchReplyFromConfig = vi.fn().mockResolvedValue(undefined);
+  // Default media stubs: produce a deterministic local path per attachment
+  // so tests can assert MediaPaths/MediaUrls were threaded through.
+  // Tests that exercise failure paths replace these per-call.
+  const fetchRemoteMedia = vi.fn().mockImplementation(async ({ url }: { url: string }) => ({
+    buffer: Buffer.from(`bytes:${url}`),
+    contentType: "image/png",
+  }));
+  let savedCount = 0;
+  const saveMediaBuffer = vi
+    .fn()
+    .mockImplementation(async (_buffer: Buffer, contentType: string | undefined) => {
+      const idx = savedCount++;
+      return { id: `id-${idx}`, path: `/tmp/inbound-${idx}.bin`, size: 0, contentType };
+    });
+
+  return {
+    channel: {
+      routing: {
+        resolveAgentRoute: vi.fn().mockReturnValue({
+          sessionKey: "session-key-1",
+          agentId: "agent-1",
+          accountId: DEFAULT_ACCOUNT_ID,
+        }),
+      },
+      reply: {
+        resolveEnvelopeFormatOptions: vi.fn().mockReturnValue({}),
+        formatAgentEnvelope: vi.fn().mockReturnValue("formatted body"),
+        finalizeInboundContext: vi.fn().mockImplementation((payload) => payload),
+        resolveHumanDelayConfig: vi.fn().mockReturnValue(undefined),
+        withReplyDispatcher,
+        dispatchReplyFromConfig,
+      },
+      commands: {
+        shouldComputeCommandAuthorized: vi.fn().mockReturnValue(false),
+        resolveCommandAuthorizedFromAuthorizers: vi.fn().mockReturnValue(true),
+      },
+      pairing: {
+        buildPairingReply: vi.fn().mockReturnValue("Pairing request received."),
+      },
+      text: {
+        resolveTextChunkLimit: vi.fn().mockReturnValue(10000),
+        resolveChunkMode: vi.fn().mockReturnValue("word"),
+        chunkTextWithMode: vi.fn().mockReturnValue(["reply text"]),
+      },
+      media: {
+        fetchRemoteMedia,
+        saveMediaBuffer,
+      },
+    },
+    system: {
+      enqueueSystemEvent,
+    },
+  };
+}
+
+// --- Tests ---
+
+describe("handleVamaMessage", () => {
+  let mockRuntime: ReturnType<typeof makeRuntime>;
+
+  beforeEach(() => {
+    mockRuntime = makeRuntime();
+    vi.mocked(getVamaRuntime).mockReturnValue(mockRuntime as any);
+    vi.mocked(tryRecordMessagePersistent).mockResolvedValue(true);
+    vi.mocked(createVamaReplyDispatcher).mockReturnValue(makeDispatcher() as any);
+    vi.mocked(sendMessageVama).mockResolvedValue({ messageId: "msg-1", channelId: "ch-1" });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("skips duplicate messages", async () => {
+    vi.mocked(tryRecordMessagePersistent).mockResolvedValueOnce(false);
+    const log = vi.fn();
+
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent(),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(log).toHaveBeenCalledWith(expect.stringContaining("duplicate"));
+    expect(mockRuntime.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("bypasses dedup when replayId is set (post-payment replay)", async () => {
+    // Even if the dedup store says "already seen", a replay must re-dispatch.
+    vi.mocked(tryRecordMessagePersistent).mockResolvedValueOnce(false);
+    const log = vi.fn();
+
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent(),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+      replayId: "pi_test_123",
+    });
+
+    expect(log).toHaveBeenCalledWith(
+      expect.stringContaining("replay (pi_test_123) — bypassing dedup"),
+    );
+    // Dedup record was NOT consulted (we short-circuited the gate).
+    expect(vi.mocked(tryRecordMessagePersistent)).not.toHaveBeenCalled();
+    // And the message did dispatch.
+    expect(mockRuntime.system.enqueueSystemEvent).toHaveBeenCalledOnce();
+  });
+
+  it("suffixes MessageSid on replay so the SDK inbound-dedupe cache misses", async () => {
+    // The openclaw SDK's dispatchReplyFromConfig has its own in-process
+    // inbound-dedupe (auto-reply/reply/inbound-dedupe.ts, 20-min TTL) keyed
+    // partly on MessageSid. Without a replay-distinct sid the second dispatch
+    // would early-bail with queuedFinal=false, leaving the user's prompt
+    // unanswered after top-up. See bot.ts for the full rationale.
+    const log = vi.fn();
+    const replayId = "pi_AAAAAAAAAAAAAAAAA123456789ABC";
+    const expectedSuffix = replayId.slice(-12);
+
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({ message_id: "uuid-original" }),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+      replayId,
+    });
+
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        MessageSid: `uuid-original#replay-${expectedSuffix}`,
+      }),
+    );
+  });
+
+  it("does not suffix MessageSid on a normal (non-replay) inbound", async () => {
+    const log = vi.fn();
+    // Defensive: an earlier test may have queued a mockResolvedValueOnce
+    // that vitest's clearAllMocks does not drain. Reset and reassert.
+    vi.mocked(tryRecordMessagePersistent).mockReset();
+    vi.mocked(tryRecordMessagePersistent).mockResolvedValue(true);
+
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({ message_id: "uuid-original" }),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({ MessageSid: "uuid-original" }),
+    );
+  });
+
+  it("maps parent message summary into reply context", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({
+        parent_id: "parent-1",
+        parent_sender_id: "bot-1",
+        parent_sender_name: "Atlas",
+        parent_text: "Pretty good - chilling in the digital ether.",
+      }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ReplyToId: "parent-1",
+        ReplyToBody: "Pretty good - chilling in the digital ether.",
+        ReplyToSender: "Atlas",
+        ReplyToIsQuote: true,
+      }),
+    );
+  });
+
+  it("fetches parent attachments and appends them as reply-target media inputs", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({
+        text: "what is that?",
+        attachments: [{ type: "media_image", url: "https://example.invalid/current.png" }],
+        parent_id: "parent-1",
+        parent_sender_name: "Atlas",
+        parent_text: "[attachments]\n- type=image url=https://example.invalid/parent.png",
+        parent_attachments: [
+          { type: "image", url: "https://example.invalid/parent.png", caption: "parent image" },
+        ],
+      }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ url: "https://example.invalid/current.png" }),
+    );
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ url: "https://example.invalid/parent.png" }),
+    );
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ReplyToId: "parent-1",
+        ReplyToSender: "Atlas",
+        ReplyToBody: expect.stringContaining(
+          "[reply target media attachments included as additional media inputs: 1]",
+        ),
+        MediaPaths: ["/tmp/inbound-0.bin", "/tmp/inbound-1.bin"],
+        MediaUrls: ["/tmp/inbound-0.bin", "/tmp/inbound-1.bin"],
+        MediaTypes: ["image/png", "image/png"],
+      }),
+    );
+  });
+
+  it("ignores empty-text messages with no attachments", async () => {
+    const log = vi.fn();
+
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({ text: "   " }),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(log).toHaveBeenCalledWith(expect.stringContaining("empty message"));
+    expect(mockRuntime.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("dispatches attachments-only messages and threads MediaPath/MediaUrls into ctx", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "open" }),
+      event: makeEvent({
+        text: "",
+        attachments: [{ type: "media_image", url: "https://example.invalid/cat.png" }],
+      }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenCalledWith(
+      expect.objectContaining({ url: "https://example.invalid/cat.png" }),
+    );
+    expect(mockRuntime.channel.media.saveMediaBuffer).toHaveBeenCalledWith(
+      expect.any(Buffer),
+      "image/png",
+      "inbound",
+      expect.any(Number),
+    );
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        MediaPath: "/tmp/inbound-0.bin",
+        MediaUrl: "/tmp/inbound-0.bin",
+        MediaType: "image/png",
+        MediaPaths: ["/tmp/inbound-0.bin"],
+        MediaUrls: ["/tmp/inbound-0.bin"],
+        MediaTypes: ["image/png"],
+      }),
+    );
+    expect(mockRuntime.system.enqueueSystemEvent).toHaveBeenCalledOnce();
+  });
+
+  it("threads multiple attachments into MediaPaths/MediaUrls in order", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "open" }),
+      event: makeEvent({
+        text: "look at these",
+        attachments: [
+          { type: "media_image", url: "https://example.invalid/a.png" },
+          { type: "media_image", url: "https://example.invalid/b.png" },
+        ],
+      }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenCalledTimes(2);
+    expect(mockRuntime.channel.media.saveMediaBuffer).toHaveBeenCalledTimes(2);
+    expect(mockRuntime.channel.reply.finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        MediaPaths: ["/tmp/inbound-0.bin", "/tmp/inbound-1.bin"],
+        MediaUrls: ["/tmp/inbound-0.bin", "/tmp/inbound-1.bin"],
+        MediaTypes: ["image/png", "image/png"],
+        // singular keys mirror the first item.
+        MediaPath: "/tmp/inbound-0.bin",
+        MediaUrl: "/tmp/inbound-0.bin",
+        MediaType: "image/png",
+      }),
+    );
+  });
+
+  it("dispatches without media when every attachment fetch fails", async () => {
+    const error = vi.fn();
+    vi.mocked(mockRuntime.channel.media.fetchRemoteMedia).mockRejectedValue(
+      new Error("HTTP 403 RBAC"),
+    );
+
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "open" }),
+      event: makeEvent({
+        text: "what is this",
+        attachments: [{ type: "media_image", url: "https://example.invalid/x.png" }],
+      }),
+      runtime: { error } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("failed to fetch attachment"));
+    // Text-only fallback: dispatch still happens, but no Media* keys.
+    expect(mockRuntime.channel.media.saveMediaBuffer).not.toHaveBeenCalled();
+    const ctxCall = mockRuntime.channel.reply.finalizeInboundContext.mock.calls.at(-1);
+    expect(ctxCall).toBeDefined();
+    const ctx = ctxCall?.[0] as Record<string, unknown>;
+    expect(ctx.MediaPaths).toBeUndefined();
+    expect(ctx.MediaUrls).toBeUndefined();
+    expect(ctx.MediaTypes).toBeUndefined();
+    expect(ctx.MediaPath).toBeUndefined();
+    expect(mockRuntime.channel.reply.withReplyDispatcher).toHaveBeenCalledOnce();
+  });
+
+  it("ignores attachments with empty/missing URLs", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "open" }),
+      event: makeEvent({
+        text: "hi",
+        attachments: [
+          { type: "media_image", url: "" },
+          // Cast — runtime payloads from BotHub can carry malformed entries.
+          { type: "media_image" } as any,
+          { type: "media_image", url: "https://example.invalid/ok.png" },
+        ],
+      }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenCalledTimes(1);
+    expect(mockRuntime.channel.media.fetchRemoteMedia).toHaveBeenCalledWith(
+      expect.objectContaining({ url: "https://example.invalid/ok.png" }),
+    );
+  });
+
+  it("dispatches a message to the agent in open policy", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "open" }),
+      event: makeEvent(),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.system.enqueueSystemEvent).toHaveBeenCalledOnce();
+    expect(mockRuntime.channel.reply.withReplyDispatcher).toHaveBeenCalledOnce();
+  });
+
+  it("enqueues a system event with sender name and message preview", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({ sender_name: "Alice", text: "hi there" }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.system.enqueueSystemEvent).toHaveBeenCalledWith(
+      expect.stringContaining("Alice"),
+      expect.objectContaining({ sessionKey: "session-key-1" }),
+    );
+  });
+
+  it("blocks unauthorized sender in allowlist policy", async () => {
+    const log = vi.fn();
+
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "allowlist", allowFrom: ["user-allowed"] }),
+      event: makeEvent({ sender_id: "user-blocked" }),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(log).toHaveBeenCalledWith(expect.stringContaining("blocked"));
+    expect(mockRuntime.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("allows a sender in the allowFrom list under allowlist policy", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "allowlist", allowFrom: ["user-1"] }),
+      event: makeEvent({ sender_id: "user-1" }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.system.enqueueSystemEvent).toHaveBeenCalledOnce();
+  });
+
+  it("sends a pairing reply in pairing policy for unknown sender", async () => {
+    // Mock pairing runtime
+    const upsertPairingRequest = vi.fn().mockResolvedValue({ code: "CODE-1234", created: true });
+    const readAllowFromStore = vi.fn().mockResolvedValue([]);
+
+    // patch createScopedPairingAccess
+    vi.doMock("openclaw/plugin-sdk/vama", async (importOriginal) => {
+      const mod = await importOriginal<typeof import("openclaw/plugin-sdk/vama")>();
+      return {
+        ...mod,
+        createScopedPairingAccess: vi.fn().mockReturnValue({
+          upsertPairingRequest,
+          readAllowFromStore,
+        }),
+      };
+    });
+
+    const log = vi.fn();
+
+    await handleVamaMessage({
+      cfg: makeCfg({ dmPolicy: "pairing" }),
+      event: makeEvent({ sender_id: "user-unknown" }),
+      runtime: { log } as any,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    // Whether pairing triggers depends on createScopedPairingAccess stub loading;
+    // at minimum the agent should NOT have received the message
+    expect(mockRuntime.system.enqueueSystemEvent).not.toHaveBeenCalled();
+  });
+
+  it("resolves agent route using channel and accountId", async () => {
+    await handleVamaMessage({
+      cfg: makeCfg(),
+      event: makeEvent({ sender_id: "user-1", channel_id: "ch-99" }),
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(mockRuntime.channel.routing.resolveAgentRoute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel: "vama",
+        accountId: DEFAULT_ACCOUNT_ID,
+        peer: expect.objectContaining({ id: "user-1" }),
+      }),
+    );
+  });
+
+  it("logs error and does not throw on runtime failure", async () => {
+    const error = vi.fn();
+    vi.mocked(mockRuntime.channel.reply.withReplyDispatcher).mockRejectedValueOnce(
+      new Error("dispatch error"),
+    );
+
+    await expect(
+      handleVamaMessage({
+        cfg: makeCfg(),
+        event: makeEvent(),
+        runtime: { error } as any,
+        accountId: DEFAULT_ACCOUNT_ID,
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("dispatch error"));
+  });
+});