@kodelyth/zalouser 2026.5.39 → 2026.5.42

package/src/channel.test.ts

@@ -0,0 +1,424 @@
+import { createNonExitingRuntimeEnv } from "klaw/plugin-sdk/plugin-test-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import "./zalo-js.test-mocks.js";
+import {
+  zalouserAuthAdapter,
+  zalouserGroupsAdapter,
+  zalouserMessageActions,
+  zalouserOutboundAdapter,
+  zalouserPairingTextAdapter,
+  zalouserResolverAdapter,
+  zalouserSecurityAdapter,
+} from "./channel.adapters.js";
+import { setZalouserRuntime } from "./runtime.js";
+import { sendMessageZalouser, sendReactionZalouser } from "./send.js";
+import {
+  listZaloFriendsMatchingMock,
+  startZaloQrLoginMock,
+  waitForZaloQrLoginMock,
+} from "./zalo-js.test-mocks.js";
+
+vi.mock("./qr-temp-file.js", () => ({
+  writeQrDataUrlToTempFile: vi.fn(async () => null),
+}));
+
+vi.mock("./send.js", async () => {
+  const actual = (await vi.importActual("./send.js")) as Record<string, unknown>;
+  return {
+    ...actual,
+    sendMessageZalouser: vi.fn(async () => ({ ok: true, messageId: "mid-1" })),
+    sendReactionZalouser: vi.fn(async () => ({ ok: true })),
+  };
+});
+
+const mockSendMessage = vi.mocked(sendMessageZalouser);
+const mockSendReaction = vi.mocked(sendReactionZalouser);
+
+function requireZalouserSendText() {
+  const sendText = zalouserOutboundAdapter.sendText;
+  if (!sendText) {
+    throw new Error("zalouser outbound.sendText unavailable");
+  }
+  return sendText;
+}
+
+function getResolveToolPolicy() {
+  const resolveToolPolicy = zalouserGroupsAdapter.resolveToolPolicy;
+  if (!resolveToolPolicy) {
+    throw new Error("resolveToolPolicy unavailable");
+  }
+  return resolveToolPolicy;
+}
+
+function requireZalouserResolveRequireMention() {
+  const resolveRequireMention = zalouserGroupsAdapter.resolveRequireMention;
+  if (!resolveRequireMention) {
+    throw new Error("resolveRequireMention unavailable");
+  }
+  return resolveRequireMention;
+}
+
+function requireZalouserPairingNormalizer() {
+  const normalizeAllowEntry = zalouserPairingTextAdapter.normalizeAllowEntry;
+  if (!normalizeAllowEntry) {
+    throw new Error("pairing.normalizeAllowEntry unavailable");
+  }
+  return normalizeAllowEntry;
+}
+
+function resolveGroupToolPolicy(
+  groups: Record<string, { tools: { allow?: string[]; deny?: string[] } }>,
+  groupId: string,
+) {
+  return getResolveToolPolicy()({
+    cfg: {
+      channels: {
+        zalouser: {
+          groups,
+        },
+      },
+    },
+    accountId: "default",
+    groupId,
+    groupChannel: groupId,
+  });
+}
+
+describe("zalouser outbound", () => {
+  beforeEach(() => {
+    mockSendMessage.mockClear();
+    setZalouserRuntime({
+      channel: {
+        text: {
+          resolveChunkMode: vi.fn(() => "newline"),
+          resolveTextChunkLimit: vi.fn(() => 10),
+        },
+      },
+    } as never);
+  });
+
+  it("passes markdown chunk settings through sendText", async () => {
+    const sendText = requireZalouserSendText();
+
+    const result = await sendText({
+      cfg: { channels: { zalouser: { enabled: true } } } as never,
+      to: "group:123456",
+      text: "hello world\nthis is a test",
+      accountId: "default",
+    } as never);
+
+    expect(mockSendMessage).toHaveBeenCalledWith("123456", "hello world\nthis is a test", {
+      profile: "default",
+      isGroup: true,
+      textMode: "markdown",
+      textChunkMode: "newline",
+      textChunkLimit: 10,
+    });
+    expect(result).toEqual({
+      channel: "zalouser",
+      messageId: "mid-1",
+      ok: true,
+    });
+  });
+
+  it("uses the selected account profile for direct outbound messages", async () => {
+    const sendText = requireZalouserSendText();
+
+    const result = await sendText({
+      cfg: {
+        channels: {
+          zalouser: {
+            accounts: {
+              work: {
+                profile: "work-profile",
+              },
+            },
+          },
+        },
+      } as never,
+      to: "user:987654",
+      text: "hello user",
+      accountId: "work",
+    } as never);
+
+    expect(mockSendMessage).toHaveBeenCalledWith("987654", "hello user", {
+      profile: "work-profile",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkMode: "newline",
+      textChunkLimit: 10,
+    });
+    expect(result).toEqual({
+      channel: "zalouser",
+      messageId: "mid-1",
+      ok: true,
+    });
+  });
+
+  it("keeps the default account profile for unscoped outbound messages", async () => {
+    const sendText = requireZalouserSendText();
+
+    await sendText({
+      cfg: { channels: { zalouser: { enabled: true } } } as never,
+      to: "user:111222",
+      text: "hello default",
+    } as never);
+
+    expect(mockSendMessage).toHaveBeenCalledWith("111222", "hello default", {
+      profile: "default",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkMode: "newline",
+      textChunkLimit: 10,
+    });
+  });
+});
+
+describe("zalouser outbound chunking", () => {
+  it("chunks outbound text without requiring Zalouser runtime initialization", () => {
+    const chunker = zalouserOutboundAdapter.chunker;
+    if (!chunker) {
+      throw new Error("zalouser outbound.chunker unavailable");
+    }
+
+    expect(chunker("alpha beta", 5)).toEqual(["alpha", "beta"]);
+  });
+});
+
+describe("zalouser channel policies", () => {
+  beforeEach(() => {
+    mockSendReaction.mockClear();
+    mockSendReaction.mockResolvedValue({ ok: true } as never);
+  });
+
+  it("normalizes dm allowlist entries after trimming channel prefixes", () => {
+    const resolveDmPolicy = zalouserSecurityAdapter.resolveDmPolicy;
+    if (!resolveDmPolicy) {
+      throw new Error("resolveDmPolicy unavailable");
+    }
+
+    const cfg = {
+      channels: {
+        zalouser: {
+          dmPolicy: "allowlist",
+          allowFrom: ["  zlu:123456  "],
+        },
+      },
+    } as never;
+    const account = {
+      accountId: "default",
+      enabled: true,
+      authenticated: false,
+      profile: "default",
+      config: {
+        dmPolicy: "allowlist",
+        allowFrom: ["  zlu:123456  "],
+      },
+    } as never;
+
+    const result = resolveDmPolicy({ cfg, account });
+    if (!result) {
+      throw new Error("zalouser resolveDmPolicy returned null");
+    }
+
+    expect(result.policy).toBe("allowlist");
+    expect(result.allowFrom).toEqual(["  zlu:123456  "]);
+    expect(result.normalizeEntry?.("  zlu:123456  ")).toBe("123456");
+  });
+
+  it("normalizes pairing allowlist entries after trimming channel prefixes", () => {
+    const normalizeAllowEntry = requireZalouserPairingNormalizer();
+
+    expect(normalizeAllowEntry("  zlu:123456  ")).toBe("123456");
+    expect(normalizeAllowEntry("  zalouser:654321  ")).toBe("654321");
+  });
+
+  it("resolves requireMention from group config", () => {
+    const resolveRequireMention = requireZalouserResolveRequireMention();
+    const requireMention = resolveRequireMention({
+      cfg: {
+        channels: {
+          zalouser: {
+            groups: {
+              "123": { requireMention: false },
+            },
+          },
+        },
+      },
+      accountId: "default",
+      groupId: "123",
+      groupChannel: "123",
+    });
+    expect(requireMention).toBe(false);
+  });
+
+  it("resolves group tool policy by explicit group id", () => {
+    const policy = resolveGroupToolPolicy({ "123": { tools: { allow: ["search"] } } }, "123");
+    expect(policy).toEqual({ allow: ["search"] });
+  });
+
+  it("falls back to wildcard group policy", () => {
+    const policy = resolveGroupToolPolicy({ "*": { tools: { deny: ["system.run"] } } }, "missing");
+    expect(policy).toEqual({ deny: ["system.run"] });
+  });
+
+  it("handles react action", async () => {
+    const actions = zalouserMessageActions;
+    expect(
+      actions?.describeMessageTool?.({ cfg: { channels: { zalouser: { enabled: true } } } })
+        ?.actions,
+    ).toEqual(["react"]);
+    const result = await actions?.handleAction?.({
+      channel: "zalouser",
+      action: "react",
+      params: {
+        threadId: "123456",
+        messageId: "111",
+        cliMsgId: "222",
+        emoji: "👍",
+      },
+      cfg: {
+        channels: {
+          zalouser: {
+            enabled: true,
+            profile: "default",
+          },
+        },
+      },
+    });
+    expect(mockSendReaction).toHaveBeenCalledWith({
+      profile: "default",
+      threadId: "123456",
+      isGroup: false,
+      msgId: "111",
+      cliMsgId: "222",
+      emoji: "👍",
+      remove: false,
+    });
+    expect(result).toEqual({
+      content: [{ type: "text", text: "Reacted 👍 on 111" }],
+      details: {
+        messageId: "111",
+        cliMsgId: "222",
+        threadId: "123456",
+      },
+    });
+  });
+
+  it("honors the selected Zalouser account during discovery", () => {
+    const actions = zalouserMessageActions;
+    const cfg = {
+      channels: {
+        zalouser: {
+          enabled: true,
+          profile: "default",
+          accounts: {
+            default: {
+              enabled: false,
+              profile: "default",
+            },
+            work: {
+              enabled: true,
+              profile: "work",
+            },
+          },
+        },
+      },
+    };
+
+    expect(actions?.describeMessageTool?.({ cfg, accountId: "default" })).toBeNull();
+    expect(actions?.describeMessageTool?.({ cfg, accountId: "work" })?.actions).toEqual(["react"]);
+  });
+});
+
+describe("zalouser account resolution", () => {
+  beforeEach(() => {
+    listZaloFriendsMatchingMock.mockReset();
+    startZaloQrLoginMock.mockReset();
+    waitForZaloQrLoginMock.mockReset();
+  });
+
+  it("uses the configured default account for omitted target lookup", async () => {
+    const resolveTargets = zalouserResolverAdapter.resolveTargets;
+    if (!resolveTargets) {
+      throw new Error("zalouser resolver.resolveTargets unavailable");
+    }
+
+    listZaloFriendsMatchingMock.mockResolvedValue([
+      { userId: "42", displayName: "Work User" } as never,
+    ]);
+
+    const result = await resolveTargets({
+      cfg: {
+        channels: {
+          zalouser: {
+            defaultAccount: "work",
+            accounts: {
+              work: {
+                profile: "work-profile",
+              },
+            },
+          },
+        },
+      } as never,
+      inputs: ["Work User"],
+      kind: "user",
+      runtime: createNonExitingRuntimeEnv(),
+    });
+
+    expect(listZaloFriendsMatchingMock).toHaveBeenCalledWith("work-profile", "Work User");
+    expect(result).toEqual([
+      {
+        input: "Work User",
+        resolved: true,
+        id: "42",
+        name: "Work User",
+        note: undefined,
+      },
+    ]);
+  });
+
+  it("uses the configured default account for omitted qr login", async () => {
+    const login = zalouserAuthAdapter.login;
+    if (!login) {
+      throw new Error("zalouser auth.login unavailable");
+    }
+
+    startZaloQrLoginMock.mockResolvedValue({
+      message: "qr ready",
+      qrDataUrl: "data:image/png;base64,abc",
+    } as never);
+    waitForZaloQrLoginMock.mockResolvedValue({
+      connected: true,
+      userId: "u-1",
+      displayName: "Work User",
+    } as never);
+
+    const runtime = createNonExitingRuntimeEnv();
+
+    await login({
+      cfg: {
+        channels: {
+          zalouser: {
+            defaultAccount: "work",
+            accounts: {
+              work: {
+                profile: "work-profile",
+              },
+            },
+          },
+        },
+      } as never,
+      runtime,
+    });
+
+    expect(startZaloQrLoginMock).toHaveBeenCalledWith({
+      profile: "work-profile",
+      timeoutMs: 35_000,
+    });
+    expect(waitForZaloQrLoginMock).toHaveBeenCalledWith({
+      profile: "work-profile",
+      timeoutMs: 180_000,
+    });
+  });
+});

package/src/channel.ts

@@ -0,0 +1,221 @@
+import { createChatChannelPlugin } from "klaw/plugin-sdk/channel-core";
+import { createAccountStatusSink } from "klaw/plugin-sdk/channel-lifecycle";
+import { buildPassiveProbedChannelStatusSummary } from "klaw/plugin-sdk/extension-shared";
+import { createLazyRuntimeModule } from "klaw/plugin-sdk/lazy-runtime";
+import {
+  createAsyncComputedAccountStatusAdapter,
+  createDefaultChannelRuntimeState,
+} from "klaw/plugin-sdk/status-helpers";
+import {
+  checkZcaAuthenticated,
+  resolveZalouserAccountSync,
+  type ResolvedZalouserAccount,
+} from "./accounts.js";
+import type { ChannelDirectoryEntry, ChannelPlugin } from "./channel-api.js";
+import { DEFAULT_ACCOUNT_ID } from "./channel-api.js";
+import {
+  zalouserAuthAdapter,
+  zalouserGroupsAdapter,
+  zalouserMessageAdapter,
+  zalouserMessageActions,
+  zalouserMessagingAdapter,
+  zalouserOutboundAdapter,
+  zalouserPairingTextAdapter,
+  resolveZalouserQrProfile,
+  zalouserResolverAdapter,
+  zalouserSecurityAdapter,
+  zalouserThreadingAdapter,
+} from "./channel.adapters.js";
+import { listZalouserDirectoryGroupMembers } from "./directory.js";
+import type { ZalouserProbeResult } from "./probe.js";
+import { createZalouserSetupWizardProxy, zalouserSetupAdapter } from "./setup-core.js";
+import { createZalouserPluginBase } from "./shared.js";
+import { collectZalouserStatusIssues } from "./status-issues.js";
+
+const loadZalouserChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime.js"));
+const zalouserSetupWizardProxy = createZalouserSetupWizardProxy(
+  async () => (await import("./setup-surface.js")).zalouserSetupWizard,
+);
+
+function mapUser(params: {
+  id: string;
+  name?: string | null;
+  avatarUrl?: string | null;
+  raw?: unknown;
+}): ChannelDirectoryEntry {
+  return {
+    kind: "user",
+    id: params.id,
+    name: params.name ?? undefined,
+    avatarUrl: params.avatarUrl ?? undefined,
+    raw: params.raw,
+  };
+}
+
+function mapGroup(params: {
+  id: string;
+  name?: string | null;
+  raw?: unknown;
+}): ChannelDirectoryEntry {
+  return {
+    kind: "group",
+    id: params.id,
+    name: params.name ?? undefined,
+    raw: params.raw,
+  };
+}
+
+export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount, ZalouserProbeResult> =
+  createChatChannelPlugin({
+    base: {
+      ...createZalouserPluginBase({
+        setupWizard: zalouserSetupWizardProxy,
+        setup: zalouserSetupAdapter,
+      }),
+      groups: zalouserGroupsAdapter,
+      actions: zalouserMessageActions,
+      messaging: zalouserMessagingAdapter,
+      directory: {
+        self: async ({ cfg, accountId }) => {
+          const { getZaloUserInfo } = await loadZalouserChannelRuntime();
+          const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
+          const parsed = await getZaloUserInfo(account.profile);
+          if (!parsed?.userId) {
+            return null;
+          }
+          return mapUser({
+            id: parsed.userId,
+            name: parsed.displayName ?? null,
+            avatarUrl: parsed.avatar ?? null,
+            raw: parsed,
+          });
+        },
+        listPeers: async ({ cfg, accountId, query, limit }) => {
+          const { listZaloFriendsMatching } = await loadZalouserChannelRuntime();
+          const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
+          const friends = await listZaloFriendsMatching(account.profile, query);
+          const rows = friends.map((friend) =>
+            mapUser({
+              id: friend.userId,
+              name: friend.displayName ?? null,
+              avatarUrl: friend.avatar ?? null,
+              raw: friend,
+            }),
+          );
+          return typeof limit === "number" && limit > 0 ? rows.slice(0, limit) : rows;
+        },
+        listGroups: async ({ cfg, accountId, query, limit }) => {
+          const { listZaloGroupsMatching } = await loadZalouserChannelRuntime();
+          const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
+          const groups = await listZaloGroupsMatching(account.profile, query);
+          const rows = groups.map((group) =>
+            mapGroup({
+              id: `group:${group.groupId}`,
+              name: group.name ?? null,
+              raw: group,
+            }),
+          );
+          return typeof limit === "number" && limit > 0 ? rows.slice(0, limit) : rows;
+        },
+        listGroupMembers: async ({ cfg, accountId, groupId, limit }) => {
+          const { listZaloGroupMembers } = await loadZalouserChannelRuntime();
+          return await listZalouserDirectoryGroupMembers(
+            {
+              cfg,
+              accountId: accountId ?? undefined,
+              groupId,
+              limit: limit ?? undefined,
+            },
+            { listZaloGroupMembers },
+          );
+        },
+      },
+      resolver: zalouserResolverAdapter,
+      auth: zalouserAuthAdapter,
+      message: zalouserMessageAdapter,
+      status: createAsyncComputedAccountStatusAdapter<ResolvedZalouserAccount, ZalouserProbeResult>(
+        {
+          defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+          collectStatusIssues: collectZalouserStatusIssues,
+          buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot),
+          probeAccount: async ({ account, timeoutMs }) =>
+            (await loadZalouserChannelRuntime()).probeZalouser(account.profile, timeoutMs),
+          resolveAccountSnapshot: async ({ account, runtime }) => {
+            const configured = await checkZcaAuthenticated(account.profile);
+            const configError = "not authenticated";
+            return {
+              accountId: account.accountId,
+              name: account.name,
+              enabled: account.enabled,
+              configured,
+              extra: {
+                dmPolicy: account.config.dmPolicy ?? "pairing",
+                lastError: configured
+                  ? (runtime?.lastError ?? null)
+                  : (runtime?.lastError ?? configError),
+              },
+            };
+          },
+        },
+      ),
+      gateway: {
+        startAccount: async (ctx) => {
+          const { getZaloUserInfo } = await loadZalouserChannelRuntime();
+          const account = ctx.account;
+          let userLabel = "";
+          try {
+            const userInfo = await getZaloUserInfo(account.profile);
+            if (userInfo?.displayName) {
+              userLabel = ` (${userInfo.displayName})`;
+            }
+            ctx.setStatus({
+              accountId: account.accountId,
+              profile: userInfo,
+            });
+          } catch {
+            // ignore probe errors
+          }
+          const statusSink = createAccountStatusSink({
+            accountId: ctx.accountId,
+            setStatus: ctx.setStatus,
+          });
+          ctx.log?.info(`[${account.accountId}] starting zalouser provider${userLabel}`);
+          const { monitorZalouserProvider } = await import("./monitor.js");
+          return monitorZalouserProvider({
+            account,
+            config: ctx.cfg,
+            runtime: ctx.runtime,
+            abortSignal: ctx.abortSignal,
+            statusSink,
+          });
+        },
+        loginWithQrStart: async (params) => {
+          const { startZaloQrLogin } = await loadZalouserChannelRuntime();
+          const profile = resolveZalouserQrProfile(params.accountId);
+          return await startZaloQrLogin({
+            profile,
+            force: params.force,
+            timeoutMs: params.timeoutMs,
+          });
+        },
+        loginWithQrWait: async (params) => {
+          const { waitForZaloQrLogin } = await loadZalouserChannelRuntime();
+          const profile = resolveZalouserQrProfile(params.accountId);
+          return await waitForZaloQrLogin({
+            profile,
+            timeoutMs: params.timeoutMs,
+          });
+        },
+        logoutAccount: async (ctx) =>
+          await (
+            await loadZalouserChannelRuntime()
+          ).logoutZaloProfile(ctx.account.profile || resolveZalouserQrProfile(ctx.accountId)),
+      },
+    },
+    security: zalouserSecurityAdapter,
+    threading: zalouserThreadingAdapter,
+    pairing: {
+      text: zalouserPairingTextAdapter,
+    },
+    outbound: zalouserOutboundAdapter,
+  });

package/src/config-schema.ts

@@ -0,0 +1,33 @@
+import {
+  AllowFromListSchema,
+  buildCatchallMultiAccountChannelSchema,
+  DmPolicySchema,
+  GroupPolicySchema,
+  MarkdownConfigSchema,
+  ToolPolicySchema,
+} from "klaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+
+const groupConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  requireMention: z.boolean().optional(),
+  tools: ToolPolicySchema,
+});
+
+const zalouserAccountSchema = z.object({
+  name: z.string().optional(),
+  enabled: z.boolean().optional(),
+  markdown: MarkdownConfigSchema,
+  profile: z.string().optional(),
+  dangerouslyAllowNameMatching: z.boolean().optional(),
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: AllowFromListSchema,
+  historyLimit: z.number().int().min(0).optional(),
+  groupAllowFrom: AllowFromListSchema,
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  groups: z.object({}).catchall(groupConfigSchema).optional(),
+  messagePrefix: z.string().optional(),
+  responsePrefix: z.string().optional(),
+});
+
+export const ZalouserConfigSchema = buildCatchallMultiAccountChannelSchema(zalouserAccountSchema);