@kodelyth/zalouser 2026.5.42 → 2026.6.1

package/src/channel.test.ts

@@ -1,424 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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);