@openclaw/zalo 2026.5.2 → 2026.5.3-beta.2

package/src/monitor.group-policy.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { __testing } from "./monitor.js";
-
-describe("zalo group policy access", () => {
-  it("blocks all group messages when policy is disabled", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "disabled",
-      defaultGroupPolicy: "open",
-      groupAllowFrom: ["zalo:123"],
-      senderId: "123",
-    });
-    expect(decision).toMatchObject({
-      allowed: false,
-      groupPolicy: "disabled",
-      reason: "disabled",
-    });
-  });
-
-  it("blocks group messages on allowlist policy with empty allowlist", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "allowlist",
-      defaultGroupPolicy: "open",
-      groupAllowFrom: [],
-      senderId: "attacker",
-    });
-    expect(decision).toMatchObject({
-      allowed: false,
-      groupPolicy: "allowlist",
-      reason: "empty_allowlist",
-    });
-  });
-
-  it("blocks sender not in group allowlist", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "allowlist",
-      defaultGroupPolicy: "open",
-      groupAllowFrom: ["zalo:victim-user-001"],
-      senderId: "attacker-user-999",
-    });
-    expect(decision).toMatchObject({
-      allowed: false,
-      groupPolicy: "allowlist",
-      reason: "sender_not_allowlisted",
-    });
-  });
-
-  it("allows sender in group allowlist", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "allowlist",
-      defaultGroupPolicy: "open",
-      groupAllowFrom: ["zl:12345"],
-      senderId: "12345",
-    });
-    expect(decision).toMatchObject({
-      allowed: true,
-      groupPolicy: "allowlist",
-      reason: "allowed",
-    });
-  });
-
-  it("allows any sender with wildcard allowlist", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "allowlist",
-      defaultGroupPolicy: "open",
-      groupAllowFrom: ["*"],
-      senderId: "random-user",
-    });
-    expect(decision).toMatchObject({
-      allowed: true,
-      groupPolicy: "allowlist",
-      reason: "allowed",
-    });
-  });
-
-  it("allows all group senders on open policy", () => {
-    const decision = __testing.evaluateZaloGroupAccess({
-      providerConfigPresent: true,
-      configuredGroupPolicy: "open",
-      defaultGroupPolicy: "allowlist",
-      groupAllowFrom: [],
-      senderId: "attacker-user-999",
-    });
-    expect(decision).toMatchObject({
-      allowed: true,
-      groupPolicy: "open",
-      reason: "allowed",
-    });
-  });
-});

package/src/monitor.image.polling.test.ts

@@ -1,110 +0,0 @@
-import { createRuntimeEnv } from "openclaw/plugin-sdk/plugin-test-runtime";
-import { afterAll, beforeEach, describe, expect, it } from "vitest";
-import {
-  createImageLifecycleCore,
-  createImageUpdate,
-  createLifecycleMonitorSetup,
-  expectImageLifecycleDelivery,
-  settleAsyncWork,
-} from "./test-support/lifecycle-test-support.js";
-import {
-  getUpdatesMock,
-  getZaloRuntimeMock,
-  loadCachedLifecycleMonitorModule,
-  resetLifecycleTestState,
-  sendMessageMock,
-} from "./test-support/monitor-mocks-test-support.js";
-
-describe("Zalo polling image handling", () => {
-  const {
-    core,
-    finalizeInboundContextMock,
-    recordInboundSessionMock,
-    fetchRemoteMediaMock,
-    saveMediaBufferMock,
-  } = createImageLifecycleCore();
-
-  beforeEach(async () => {
-    await resetLifecycleTestState();
-    getZaloRuntimeMock.mockReturnValue(core);
-  });
-
-  afterAll(async () => {
-    await resetLifecycleTestState();
-  });
-
-  it("downloads inbound image media from photo_url and preserves display_name", async () => {
-    getUpdatesMock
-      .mockResolvedValueOnce({
-        ok: true,
-        result: createImageUpdate({ date: 1774084566880 }),
-      })
-      .mockImplementation(() => new Promise(() => {}));
-
-    const { monitorZaloProvider } = await loadCachedLifecycleMonitorModule("zalo-image-polling");
-    const abort = new AbortController();
-    const runtime = createRuntimeEnv();
-    const { account, config } = createLifecycleMonitorSetup({
-      accountId: "default",
-      dmPolicy: "open",
-    });
-    const run = monitorZaloProvider({
-      token: "zalo-token", // pragma: allowlist secret
-      account,
-      config,
-      runtime,
-      abortSignal: abort.signal,
-    });
-
-    await settleAsyncWork();
-    expect(fetchRemoteMediaMock).toHaveBeenCalledTimes(1);
-    expectImageLifecycleDelivery({
-      fetchRemoteMediaMock,
-      saveMediaBufferMock,
-      finalizeInboundContextMock,
-      recordInboundSessionMock,
-    });
-
-    abort.abort();
-    await run;
-  });
-
-  it("rejects unauthorized DM images before downloading media", async () => {
-    getUpdatesMock
-      .mockResolvedValueOnce({
-        ok: true,
-        result: createImageUpdate({
-          messageId: "msg-unauthorized-1",
-          userId: "user-unauthorized-1",
-          chatId: "chat-unauthorized-1",
-        }),
-      })
-      .mockImplementation(() => new Promise(() => {}));
-
-    const { monitorZaloProvider } = await loadCachedLifecycleMonitorModule("zalo-image-polling");
-    const abort = new AbortController();
-    const runtime = createRuntimeEnv();
-    const { account, config } = createLifecycleMonitorSetup({
-      accountId: "default",
-      dmPolicy: "pairing",
-      allowFrom: ["allowed-user"],
-    });
-    const run = monitorZaloProvider({
-      token: "zalo-token", // pragma: allowlist secret
-      account,
-      config,
-      runtime,
-      abortSignal: abort.signal,
-    });
-
-    await settleAsyncWork();
-    expect(sendMessageMock).toHaveBeenCalledTimes(1);
-    expect(fetchRemoteMediaMock).not.toHaveBeenCalled();
-    expect(saveMediaBufferMock).not.toHaveBeenCalled();
-    expect(finalizeInboundContextMock).not.toHaveBeenCalled();
-    expect(recordInboundSessionMock).not.toHaveBeenCalled();
-
-    abort.abort();
-    await run;
-  });
-});

package/src/monitor.lifecycle.test.ts

@@ -1,198 +0,0 @@
-import {
-  createEmptyPluginRegistry,
-  createRuntimeEnv,
-  setActivePluginRegistry,
-} from "openclaw/plugin-sdk/plugin-test-runtime";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig } from "../runtime-api.js";
-import type { ResolvedZaloAccount } from "./accounts.js";
-
-const getWebhookInfoMock = vi.fn(async () => ({ ok: true, result: { url: "" } }));
-const deleteWebhookMock = vi.fn(async () => ({ ok: true, result: { url: "" } }));
-const getUpdatesMock = vi.fn(() => new Promise(() => {}));
-const setWebhookMock = vi.fn(async () => ({ ok: true, result: { url: "" } }));
-
-vi.mock("./api.js", async () => {
-  const actual = await vi.importActual<typeof import("./api.js")>("./api.js");
-  return {
-    ...actual,
-    deleteWebhook: deleteWebhookMock,
-    getWebhookInfo: getWebhookInfoMock,
-    getUpdates: getUpdatesMock,
-    setWebhook: setWebhookMock,
-  };
-});
-
-vi.mock("./runtime.js", () => ({
-  getZaloRuntime: () => ({
-    logging: {
-      shouldLogVerbose: () => false,
-    },
-  }),
-}));
-
-const TEST_ACCOUNT = {
-  accountId: "default",
-  config: {},
-} as unknown as ResolvedZaloAccount;
-
-const TEST_CONFIG = {} as OpenClawConfig;
-
-async function settleLifecycleWork(): Promise<void> {
-  for (let i = 0; i < 6; i += 1) {
-    await Promise.resolve();
-    await new Promise((resolve) => setImmediate(resolve));
-  }
-}
-
-async function startLifecycleMonitor(
-  options: {
-    useWebhook?: boolean;
-    webhookSecret?: string;
-    webhookUrl?: string;
-  } = {},
-) {
-  const { monitorZaloProvider } = await import("./monitor.js");
-  const abort = new AbortController();
-  const runtime = createRuntimeEnv();
-  const run = monitorZaloProvider({
-    token: "test-token",
-    account: TEST_ACCOUNT,
-    config: TEST_CONFIG,
-    runtime,
-    abortSignal: abort.signal,
-    ...options,
-  });
-  return { abort, runtime, run };
-}
-
-describe("monitorZaloProvider lifecycle", () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-    setActivePluginRegistry(createEmptyPluginRegistry());
-  });
-
-  it("stays alive in polling mode until abort", async () => {
-    let settled = false;
-    const { abort, runtime, run } = await startLifecycleMonitor();
-    const monitoredRun = run.then(() => {
-      settled = true;
-    });
-
-    await settleLifecycleWork();
-    expect(getUpdatesMock).toHaveBeenCalledTimes(1);
-
-    expect(getWebhookInfoMock).toHaveBeenCalledTimes(1);
-    expect(deleteWebhookMock).not.toHaveBeenCalled();
-    expect(getUpdatesMock).toHaveBeenCalledTimes(1);
-    expect(settled).toBe(false);
-
-    abort.abort();
-    await monitoredRun;
-
-    expect(settled).toBe(true);
-    expect(runtime.log).toHaveBeenCalledWith(
-      expect.stringContaining("Zalo provider stopped mode=polling"),
-    );
-  });
-
-  it("deletes an existing webhook before polling", async () => {
-    getWebhookInfoMock.mockResolvedValueOnce({
-      ok: true,
-      result: { url: "https://example.com/hooks/zalo" },
-    });
-
-    const { abort, runtime, run } = await startLifecycleMonitor();
-
-    await settleLifecycleWork();
-    expect(getUpdatesMock).toHaveBeenCalledTimes(1);
-
-    expect(getWebhookInfoMock).toHaveBeenCalledTimes(1);
-    expect(deleteWebhookMock).toHaveBeenCalledTimes(1);
-    expect(runtime.log).toHaveBeenCalledWith(
-      expect.stringContaining("Zalo polling mode ready (webhook disabled)"),
-    );
-
-    abort.abort();
-    await run;
-  });
-
-  it("continues polling when webhook inspection returns 404", async () => {
-    const { ZaloApiError } = await import("./api.js");
-    getWebhookInfoMock.mockRejectedValueOnce(new ZaloApiError("Not Found", 404, "Not Found"));
-
-    const { abort, runtime, run } = await startLifecycleMonitor();
-
-    await settleLifecycleWork();
-    expect(getUpdatesMock).toHaveBeenCalledTimes(1);
-
-    expect(getWebhookInfoMock).toHaveBeenCalledTimes(1);
-    expect(deleteWebhookMock).not.toHaveBeenCalled();
-    expect(runtime.log).toHaveBeenCalledWith(
-      expect.stringContaining("webhook inspection unavailable; continuing without webhook cleanup"),
-    );
-    expect(runtime.error).not.toHaveBeenCalled();
-
-    abort.abort();
-    await run;
-  });
-
-  it("waits for webhook deletion before finishing webhook shutdown", async () => {
-    const registry = createEmptyPluginRegistry();
-    setActivePluginRegistry(registry);
-
-    let resolveSetWebhookCalled: (() => void) | undefined;
-    const setWebhookCalled = new Promise<void>((resolve) => {
-      resolveSetWebhookCalled = resolve;
-    });
-    setWebhookMock.mockImplementationOnce(async () => {
-      resolveSetWebhookCalled?.();
-      return { ok: true, result: { url: "" } };
-    });
-
-    let resolveDeleteWebhookCalled: (() => void) | undefined;
-    const deleteWebhookCalled = new Promise<void>((resolve) => {
-      resolveDeleteWebhookCalled = resolve;
-    });
-    let resolveDeleteWebhook: (() => void) | undefined;
-    deleteWebhookMock.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          resolveDeleteWebhookCalled?.();
-          resolveDeleteWebhook = () => resolve({ ok: true, result: { url: "" } });
-        }),
-    );
-
-    let settled = false;
-    const { abort, runtime, run } = await startLifecycleMonitor({
-      useWebhook: true,
-      webhookUrl: "https://example.com/hooks/zalo",
-      webhookSecret: "supersecret", // pragma: allowlist secret
-    });
-    const monitoredRun = run.then(() => {
-      settled = true;
-    });
-
-    await setWebhookCalled;
-    await settleLifecycleWork();
-    expect(setWebhookMock).toHaveBeenCalledTimes(1);
-    expect(registry.httpRoutes).toHaveLength(2);
-
-    abort.abort();
-
-    await deleteWebhookCalled;
-    expect(deleteWebhookMock).toHaveBeenCalledTimes(1);
-    expect(deleteWebhookMock).toHaveBeenCalledWith("test-token", undefined, 5000);
-    expect(settled).toBe(false);
-    expect(registry.httpRoutes).toHaveLength(2);
-
-    resolveDeleteWebhook?.();
-    await monitoredRun;
-
-    expect(settled).toBe(true);
-    expect(registry.httpRoutes).toHaveLength(0);
-    expect(runtime.log).toHaveBeenCalledWith(
-      expect.stringContaining("Zalo provider stopped mode=webhook"),
-    );
-  });
-});

package/src/monitor.pairing.lifecycle.test.ts

@@ -1,141 +0,0 @@
-import { withServer } from "openclaw/plugin-sdk/test-env";
-import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  createLifecycleMonitorSetup,
-  createTextUpdate,
-  postWebhookReplay,
-  settleAsyncWork,
-} from "./test-support/lifecycle-test-support.js";
-import {
-  resetLifecycleTestState,
-  sendMessageMock,
-  setLifecycleRuntimeCore,
-  startWebhookLifecycleMonitor,
-} from "./test-support/monitor-mocks-test-support.js";
-
-describe("Zalo pairing lifecycle", () => {
-  const readAllowFromStoreMock = vi.fn(async () => [] as string[]);
-  const upsertPairingRequestMock = vi.fn(async () => ({ code: "PAIRCODE", created: true }));
-
-  beforeEach(async () => {
-    await resetLifecycleTestState();
-    setLifecycleRuntimeCore({
-      pairing: {
-        readAllowFromStore: readAllowFromStoreMock,
-        upsertPairingRequest: upsertPairingRequestMock,
-      },
-      commands: {
-        shouldComputeCommandAuthorized: vi.fn(() => false),
-        resolveCommandAuthorizedFromAuthorizers: vi.fn(() => false),
-      },
-    });
-  });
-
-  afterAll(async () => {
-    await resetLifecycleTestState();
-  });
-
-  function createPairingMonitorSetup() {
-    return createLifecycleMonitorSetup({
-      accountId: "acct-zalo-pairing",
-      dmPolicy: "pairing",
-      allowFrom: [],
-    });
-  }
-
-  it("emits one pairing reply across duplicate webhook replay and scopes reads and writes to accountId", async () => {
-    const monitor = await startWebhookLifecycleMonitor({
-      ...createPairingMonitorSetup(),
-      cacheKey: "zalo-pairing-lifecycle",
-    });
-
-    try {
-      await withServer(
-        (req, res) => monitor.route.handler(req, res),
-        async (baseUrl) => {
-          const { first, replay } = await postWebhookReplay({
-            baseUrl,
-            path: "/hooks/zalo",
-            secret: "supersecret",
-            payload: createTextUpdate({
-              messageId: `zalo-pairing-${Date.now()}`,
-              userId: "user-unauthorized",
-              userName: "Unauthorized User",
-              chatId: "dm-pairing-1",
-            }),
-          });
-
-          expect(first.status).toBe(200);
-          expect(replay.status).toBe(200);
-          await settleAsyncWork();
-        },
-      );
-
-      expect(readAllowFromStoreMock).toHaveBeenCalledTimes(1);
-      expect(readAllowFromStoreMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          channel: "zalo",
-          accountId: "acct-zalo-pairing",
-        }),
-      );
-      expect(upsertPairingRequestMock).toHaveBeenCalledTimes(1);
-      expect(upsertPairingRequestMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          channel: "zalo",
-          accountId: "acct-zalo-pairing",
-          id: "user-unauthorized",
-        }),
-      );
-      expect(sendMessageMock).toHaveBeenCalledTimes(1);
-      expect(sendMessageMock).toHaveBeenCalledWith(
-        "zalo-token",
-        expect.objectContaining({
-          chat_id: "dm-pairing-1",
-          text: expect.stringContaining("PAIRCODE"),
-        }),
-        undefined,
-      );
-    } finally {
-      await monitor.stop();
-    }
-  });
-
-  it("does not emit a second pairing reply when replay arrives after the first send fails", async () => {
-    sendMessageMock.mockRejectedValueOnce(new Error("pairing send failed"));
-
-    const monitor = await startWebhookLifecycleMonitor({
-      ...createPairingMonitorSetup(),
-      cacheKey: "zalo-pairing-lifecycle",
-    });
-
-    try {
-      await withServer(
-        (req, res) => monitor.route.handler(req, res),
-        async (baseUrl) => {
-          const { first, replay } = await postWebhookReplay({
-            baseUrl,
-            path: "/hooks/zalo",
-            secret: "supersecret",
-            payload: createTextUpdate({
-              messageId: `zalo-pairing-retry-${Date.now()}`,
-              userId: "user-unauthorized",
-              userName: "Unauthorized User",
-              chatId: "dm-pairing-1",
-            }),
-            settleBeforeReplay: true,
-          });
-
-          expect(first.status).toBe(200);
-          expect(replay.status).toBe(200);
-          await settleAsyncWork();
-        },
-      );
-
-      expect(upsertPairingRequestMock).toHaveBeenCalledTimes(1);
-      expect(sendMessageMock).toHaveBeenCalledTimes(1);
-      expect(monitor.runtime.error).not.toHaveBeenCalled();
-    } finally {
-      await monitor.stop();
-    }
-  });
-});