@kodelyth/zalouser 2026.5.42 → 2026.6.2

package/src/setup-surface.ts

@@ -1,481 +0,0 @@
-import {
-  addWildcardAllowFrom,
-  DEFAULT_ACCOUNT_ID,
-  formatCliCommand,
-  formatDocsLink,
-  formatResolvedUnresolvedNote,
-  mergeAllowFromEntries,
-  normalizeAccountId,
-  patchScopedAccountConfig,
-  createSetupTranslator,
-  type ChannelSetupDmPolicy,
-  type ChannelSetupWizard,
-  type DmPolicy,
-  type KlawConfig,
-} from "klaw/plugin-sdk/setup";
-import {
-  checkZcaAuthenticated,
-  listZalouserAccountIds,
-  resolveDefaultZalouserAccountId,
-  resolveZalouserAccountSync,
-} from "./accounts.js";
-import { writeQrDataUrlToTempFile } from "./qr-temp-file.js";
-import {
-  logoutZaloProfile,
-  resolveZaloAllowFromEntries,
-  resolveZaloGroupsByEntries,
-  startZaloQrLogin,
-  waitForZaloQrLogin,
-} from "./zalo-js.js";
-
-const t = createSetupTranslator();
-
-const channel = "zalouser" as const;
-const ZALOUSER_ALLOW_FROM_PLACEHOLDER = t("wizard.zalouser.allowFromPlaceholder");
-const ZALOUSER_GROUPS_PLACEHOLDER = t("wizard.zalouser.groupsPlaceholder");
-const ZALOUSER_DM_ACCESS_TITLE = t("wizard.zalouser.dmAccessTitle");
-const ZALOUSER_ALLOWLIST_TITLE = t("wizard.zalouser.allowlistTitle");
-const ZALOUSER_GROUPS_TITLE = t("wizard.zalouser.groupsTitle");
-
-function parseZalouserEntries(raw: string): string[] {
-  return raw
-    .split(/[\n,;]+/g)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-function setZalouserAccountScopedConfig(
-  cfg: KlawConfig,
-  accountId: string,
-  defaultPatch: Record<string, unknown>,
-  accountPatch: Record<string, unknown> = defaultPatch,
-): KlawConfig {
-  return patchScopedAccountConfig({
-    cfg,
-    channelKey: channel,
-    accountId,
-    patch: defaultPatch,
-    accountPatch,
-  });
-}
-
-function setZalouserDmPolicy(cfg: KlawConfig, accountId: string, policy: DmPolicy): KlawConfig {
-  const resolvedAccountId = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
-  const resolved = resolveZalouserAccountSync({ cfg, accountId: resolvedAccountId });
-  return setZalouserAccountScopedConfig(
-    cfg,
-    resolvedAccountId,
-    {
-      dmPolicy: policy,
-      ...(policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}),
-    },
-    {
-      dmPolicy: policy,
-      ...(policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}),
-    },
-  );
-}
-
-function setZalouserGroupPolicy(
-  cfg: KlawConfig,
-  accountId: string,
-  groupPolicy: "open" | "allowlist" | "disabled",
-): KlawConfig {
-  return setZalouserAccountScopedConfig(cfg, accountId, {
-    groupPolicy,
-  });
-}
-
-function setZalouserGroupAllowlist(
-  cfg: KlawConfig,
-  accountId: string,
-  groupKeys: string[],
-): KlawConfig {
-  const groups = Object.fromEntries(
-    groupKeys.map((key) => [key, { enabled: true, requireMention: true }]),
-  );
-  return setZalouserAccountScopedConfig(cfg, accountId, {
-    groups,
-  });
-}
-
-function ensureZalouserPluginEnabled(cfg: KlawConfig): KlawConfig {
-  const next: KlawConfig = {
-    ...cfg,
-    plugins: {
-      ...cfg.plugins,
-      entries: {
-        ...cfg.plugins?.entries,
-        zalouser: {
-          ...cfg.plugins?.entries?.zalouser,
-          enabled: true,
-        },
-      },
-    },
-  };
-  const allow = next.plugins?.allow;
-  if (!Array.isArray(allow) || allow.includes(channel)) {
-    return next;
-  }
-  return {
-    ...next,
-    plugins: {
-      ...next.plugins,
-      allow: [...allow, channel],
-    },
-  };
-}
-
-async function noteZalouserHelp(
-  prompter: Parameters<NonNullable<ChannelSetupWizard["prepare"]>>[0]["prompter"],
-): Promise<void> {
-  await prompter.note(
-    [
-      t("wizard.zalouser.helpQrLogin"),
-      "",
-      t("wizard.zalouser.helpZcaJs"),
-      "",
-      `Docs: ${formatDocsLink("/channels/zalouser", "zalouser")}`,
-    ].join("\n"),
-    t("wizard.zalouser.setupTitle"),
-  );
-}
-
-async function promptZalouserAllowFrom(params: {
-  cfg: KlawConfig;
-  prompter: Parameters<NonNullable<ChannelSetupDmPolicy["promptAllowFrom"]>>[0]["prompter"];
-  accountId: string;
-}): Promise<KlawConfig> {
-  const { cfg, prompter, accountId } = params;
-  const resolved = resolveZalouserAccountSync({ cfg, accountId });
-  const existingAllowFrom = resolved.config.allowFrom ?? [];
-
-  while (true) {
-    const entry = await prompter.text({
-      message: t("wizard.zalouser.allowFromPrompt"),
-      placeholder: ZALOUSER_ALLOW_FROM_PLACEHOLDER,
-      initialValue: existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : undefined,
-    });
-    const parts = parseZalouserEntries(entry);
-    if (parts.length === 0) {
-      await prompter.note(
-        [
-          t("wizard.zalouser.noDmAllowlist"),
-          t("wizard.zalouser.directChatsBlocked"),
-          t("wizard.zalouser.peersLookupTip", {
-            command: formatCliCommand("klaw directory peers list --channel zalouser"),
-          }),
-        ].join("\n"),
-        ZALOUSER_ALLOWLIST_TITLE,
-      );
-      return setZalouserAccountScopedConfig(cfg, accountId, {
-        dmPolicy: "allowlist",
-        allowFrom: [],
-      });
-    }
-    const resolvedEntries = await resolveZaloAllowFromEntries({
-      profile: resolved.profile,
-      entries: parts,
-    });
-
-    const unresolved = resolvedEntries.filter((item) => !item.resolved).map((item) => item.input);
-    if (unresolved.length > 0) {
-      await prompter.note(
-        t("wizard.zalouser.couldNotResolve", { entries: unresolved.join(", ") }),
-        ZALOUSER_ALLOWLIST_TITLE,
-      );
-      continue;
-    }
-
-    const resolvedIds = resolvedEntries
-      .filter((item) => item.resolved && item.id)
-      .map((item) => item.id as string);
-    const unique = mergeAllowFromEntries(existingAllowFrom, resolvedIds);
-
-    const notes = resolvedEntries
-      .filter((item) => item.note)
-      .map((item) => `${item.input} -> ${item.id} (${item.note})`);
-    if (notes.length > 0) {
-      await prompter.note(notes.join("\n"), ZALOUSER_ALLOWLIST_TITLE);
-    }
-
-    return setZalouserAccountScopedConfig(cfg, accountId, {
-      dmPolicy: "allowlist",
-      allowFrom: unique,
-    });
-  }
-}
-
-const zalouserDmPolicy: ChannelSetupDmPolicy = {
-  label: "Zalo Personal",
-  channel,
-  policyKey: "channels.zalouser.dmPolicy",
-  allowFromKey: "channels.zalouser.allowFrom",
-  resolveConfigKeys: (cfg, accountId) =>
-    (accountId ?? resolveDefaultZalouserAccountId(cfg)) !== DEFAULT_ACCOUNT_ID
-      ? {
-          policyKey: `channels.zalouser.accounts.${accountId ?? resolveDefaultZalouserAccountId(cfg)}.dmPolicy`,
-          allowFromKey: `channels.zalouser.accounts.${accountId ?? resolveDefaultZalouserAccountId(cfg)}.allowFrom`,
-        }
-      : {
-          policyKey: "channels.zalouser.dmPolicy",
-          allowFromKey: "channels.zalouser.allowFrom",
-        },
-  getCurrent: (cfg, accountId) =>
-    resolveZalouserAccountSync({
-      cfg,
-      accountId: accountId ?? resolveDefaultZalouserAccountId(cfg),
-    }).config.dmPolicy ?? "pairing",
-  setPolicy: (cfg, policy, accountId) =>
-    setZalouserDmPolicy(cfg, accountId ?? resolveDefaultZalouserAccountId(cfg), policy),
-  promptAllowFrom: async ({ cfg, prompter, accountId }) => {
-    const id =
-      accountId && normalizeAccountId(accountId)
-        ? (normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID)
-        : resolveDefaultZalouserAccountId(cfg);
-    return await promptZalouserAllowFrom({
-      cfg: cfg,
-      prompter,
-      accountId: id,
-    });
-  },
-};
-
-async function promptZalouserQuickstartDmPolicy(params: {
-  cfg: KlawConfig;
-  prompter: Parameters<NonNullable<ChannelSetupWizard["prepare"]>>[0]["prompter"];
-  accountId: string;
-}): Promise<KlawConfig> {
-  const { cfg, prompter, accountId } = params;
-  const resolved = resolveZalouserAccountSync({ cfg, accountId });
-  const existingPolicy = resolved.config.dmPolicy ?? "pairing";
-  const existingAllowFrom = resolved.config.allowFrom ?? [];
-  const existingLabel = existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : "unset";
-
-  await prompter.note(
-    [
-      t("wizard.zalouser.dmHelpSeparate"),
-      t("wizard.zalouser.dmHelpPairing"),
-      t("wizard.zalouser.dmHelpAllowlist"),
-      t("wizard.zalouser.dmHelpOpen"),
-      t("wizard.zalouser.dmHelpDisabled"),
-      "",
-      `Current: dmPolicy=${existingPolicy}, allowFrom=${existingLabel}`,
-      t("wizard.zalouser.dmHelpAllowlistEmpty"),
-    ].join("\n"),
-    ZALOUSER_DM_ACCESS_TITLE,
-  );
-
-  const policy = (await prompter.select({
-    message: t("wizard.zalouser.dmPolicyPrompt"),
-    options: [
-      { value: "pairing", label: t("wizard.channels.dmPolicyPairing") },
-      { value: "allowlist", label: t("wizard.channels.dmPolicyAllowlistOption") },
-      { value: "open", label: t("wizard.channels.dmPolicyOpenOption") },
-      { value: "disabled", label: t("wizard.channels.dmPolicyDisabledOption") },
-    ],
-    initialValue: existingPolicy,
-  })) as DmPolicy;
-
-  if (policy === "allowlist") {
-    return await promptZalouserAllowFrom({
-      cfg,
-      prompter,
-      accountId,
-    });
-  }
-  return setZalouserDmPolicy(cfg, accountId, policy);
-}
-
-export { zalouserSetupAdapter } from "./setup-core.js";
-
-export const zalouserSetupWizard: ChannelSetupWizard = {
-  channel,
-  status: {
-    configuredLabel: t("wizard.channels.statusLoggedIn"),
-    unconfiguredLabel: t("wizard.channels.statusNeedsQrLogin"),
-    configuredHint: t("wizard.channels.statusRecommendedLoggedIn"),
-    unconfiguredHint: t("wizard.channels.statusRecommendedQrLogin"),
-    configuredScore: 1,
-    unconfiguredScore: 15,
-    resolveConfigured: async ({ cfg, accountId }) => {
-      const ids = accountId ? [accountId] : listZalouserAccountIds(cfg);
-      for (const resolvedAccountId of ids) {
-        const account = resolveZalouserAccountSync({ cfg, accountId: resolvedAccountId });
-        if (await checkZcaAuthenticated(account.profile)) {
-          return true;
-        }
-      }
-      return false;
-    },
-    resolveStatusLines: async ({ cfg, accountId, configured }) => {
-      void cfg;
-      const label =
-        accountId && accountId !== DEFAULT_ACCOUNT_ID
-          ? `Zalo Personal (${accountId})`
-          : "Zalo Personal";
-      return [`${label}: ${configured ? "logged in" : "needs QR login"}`];
-    },
-  },
-  prepare: async ({ cfg, accountId, prompter, options }) => {
-    let next = cfg;
-    const account = resolveZalouserAccountSync({ cfg: next, accountId });
-    const alreadyAuthenticated = await checkZcaAuthenticated(account.profile);
-
-    if (!alreadyAuthenticated) {
-      await noteZalouserHelp(prompter);
-      const wantsLogin = await prompter.confirm({
-        message: t("wizard.zalouser.loginQrPrompt"),
-        initialValue: true,
-      });
-
-      if (wantsLogin) {
-        const start = await startZaloQrLogin({ profile: account.profile, timeoutMs: 35_000 });
-        if (start.qrDataUrl) {
-          const qrPath = await writeQrDataUrlToTempFile(start.qrDataUrl, account.profile);
-          await prompter.note(
-            [
-              start.message,
-              qrPath
-                ? t("wizard.zalouser.qrImageSaved", { path: qrPath })
-                : t("wizard.zalouser.qrImageWriteFailed"),
-              t("wizard.zalouser.scanApproveContinue"),
-            ].join("\n"),
-            t("wizard.zalouser.qrLoginTitle"),
-          );
-          const scanned = await prompter.confirm({
-            message: t("wizard.zalouser.qrScannedPrompt"),
-            initialValue: true,
-          });
-          if (scanned) {
-            const waited = await waitForZaloQrLogin({
-              profile: account.profile,
-              timeoutMs: 120_000,
-            });
-            await prompter.note(
-              waited.message,
-              waited.connected ? t("common.done") : t("wizard.zalouser.loginPendingTitle"),
-            );
-          }
-        } else {
-          await prompter.note(start.message, t("wizard.zalouser.loginPendingTitle"));
-        }
-      }
-    } else {
-      const keepSession = await prompter.confirm({
-        message: t("wizard.zalouser.keepSessionPrompt"),
-        initialValue: true,
-      });
-      if (!keepSession) {
-        await logoutZaloProfile(account.profile);
-        const start = await startZaloQrLogin({
-          profile: account.profile,
-          force: true,
-          timeoutMs: 35_000,
-        });
-        if (start.qrDataUrl) {
-          const qrPath = await writeQrDataUrlToTempFile(start.qrDataUrl, account.profile);
-          await prompter.note(
-            [
-              start.message,
-              qrPath ? t("wizard.zalouser.qrImageSaved", { path: qrPath }) : undefined,
-            ]
-              .filter(Boolean)
-              .join("\n"),
-            t("wizard.zalouser.qrLoginTitle"),
-          );
-          const waited = await waitForZaloQrLogin({ profile: account.profile, timeoutMs: 120_000 });
-          await prompter.note(
-            waited.message,
-            waited.connected ? t("common.done") : t("wizard.zalouser.loginPendingTitle"),
-          );
-        }
-      }
-    }
-
-    next = setZalouserAccountScopedConfig(
-      next,
-      accountId,
-      { profile: account.profile !== "default" ? account.profile : undefined },
-      { profile: account.profile, enabled: true },
-    );
-
-    if (options?.quickstartDefaults) {
-      next = await promptZalouserQuickstartDmPolicy({
-        cfg: next,
-        prompter,
-        accountId,
-      });
-    }
-
-    return { cfg: next };
-  },
-  credentials: [],
-  groupAccess: {
-    label: "Zalo groups",
-    placeholder: ZALOUSER_GROUPS_PLACEHOLDER,
-    currentPolicy: ({ cfg, accountId }) =>
-      resolveZalouserAccountSync({ cfg, accountId }).config.groupPolicy ?? "allowlist",
-    currentEntries: ({ cfg, accountId }) =>
-      Object.keys(resolveZalouserAccountSync({ cfg, accountId }).config.groups ?? {}),
-    updatePrompt: ({ cfg, accountId }) =>
-      Boolean(resolveZalouserAccountSync({ cfg, accountId }).config.groups),
-    setPolicy: ({ cfg, accountId, policy }) => setZalouserGroupPolicy(cfg, accountId, policy),
-    resolveAllowlist: async ({ cfg, accountId, entries, prompter }) => {
-      if (entries.length === 0) {
-        await prompter.note(
-          [
-            t("wizard.zalouser.noGroupAllowlist"),
-            t("wizard.zalouser.groupChatsBlocked"),
-            t("wizard.zalouser.groupsLookupTip", {
-              command: formatCliCommand("klaw directory groups list --channel zalouser"),
-            }),
-            t("wizard.zalouser.groupMentionRequirement"),
-          ].join("\n"),
-          ZALOUSER_GROUPS_TITLE,
-        );
-        return [];
-      }
-      const updatedAccount = resolveZalouserAccountSync({ cfg: cfg, accountId });
-      try {
-        const resolved = await resolveZaloGroupsByEntries({
-          profile: updatedAccount.profile,
-          entries,
-        });
-        const resolvedIds = resolved
-          .filter((entry) => entry.resolved && entry.id)
-          .map((entry) => entry.id as string);
-        const unresolved = resolved.filter((entry) => !entry.resolved).map((entry) => entry.input);
-        const keys = [...resolvedIds, ...unresolved.map((entry) => entry.trim()).filter(Boolean)];
-        const resolution = formatResolvedUnresolvedNote({
-          resolved: resolvedIds,
-          unresolved,
-        });
-        if (resolution) {
-          await prompter.note(resolution, ZALOUSER_GROUPS_TITLE);
-        }
-        return keys;
-      } catch (err) {
-        await prompter.note(
-          t("wizard.zalouser.groupLookupFailed", { error: String(err) }),
-          ZALOUSER_GROUPS_TITLE,
-        );
-        return entries.map((entry) => entry.trim()).filter(Boolean);
-      }
-    },
-    applyAllowlist: ({ cfg, accountId, resolved }) =>
-      setZalouserGroupAllowlist(cfg, accountId, resolved as string[]),
-  },
-  finalize: async ({ cfg, accountId, forceAllowFrom, options, prompter }) => {
-    let next = cfg;
-    if (forceAllowFrom && !options?.quickstartDefaults) {
-      next = await promptZalouserAllowFrom({
-        cfg: next,
-        prompter,
-        accountId,
-      });
-    }
-    return { cfg: ensureZalouserPluginEnabled(next) };
-  },
-  dmPolicy: zalouserDmPolicy,
-};

package/src/setup-test-helpers.ts

@@ -1,42 +0,0 @@
-import { createScopedDmSecurityResolver } from "klaw/plugin-sdk/channel-config-helpers";
-import type { KlawConfig } from "../runtime-api.js";
-import {
-  listZalouserAccountIds,
-  resolveDefaultZalouserAccountId,
-  resolveZalouserAccountSync,
-} from "./accounts.js";
-import { zalouserSetupAdapter } from "./setup-core.js";
-import { zalouserSetupWizard } from "./setup-surface.js";
-
-export const zalouserSetupPlugin = {
-  id: "zalouser",
-  meta: {
-    id: "zalouser",
-    label: "ZaloUser",
-    selectionLabel: "ZaloUser",
-    docsPath: "/channels/zalouser",
-    blurb: "Unofficial Zalo personal account connector.",
-  },
-  capabilities: {
-    chatTypes: ["direct", "group"] as Array<"direct" | "group">,
-  },
-  config: {
-    listAccountIds: (cfg: unknown) => listZalouserAccountIds(cfg as never),
-    defaultAccountId: (cfg: unknown) => resolveDefaultZalouserAccountId(cfg as never),
-    resolveAccount: (cfg: KlawConfig, accountId?: string | null) =>
-      resolveZalouserAccountSync({ cfg, accountId }),
-  },
-  security: {
-    resolveDmPolicy: createScopedDmSecurityResolver({
-      channelKey: "zalouser",
-      resolvePolicy: (account: ReturnType<typeof resolveZalouserAccountSync>) =>
-        account.config.dmPolicy,
-      resolveAllowFrom: (account: ReturnType<typeof resolveZalouserAccountSync>) =>
-        account.config.allowFrom,
-      policyPathSuffix: "dmPolicy",
-      normalizeEntry: (raw: string) => raw.trim().replace(/^(zalouser|zlu):/i, ""),
-    }),
-  },
-  setup: zalouserSetupAdapter,
-  setupWizard: zalouserSetupWizard,
-} as const;

package/src/shared.ts

@@ -1,92 +0,0 @@
-import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
-import {
-  adaptScopedAccountAccessor,
-  createScopedChannelConfigAdapter,
-} from "klaw/plugin-sdk/channel-config-helpers";
-import {
-  listZalouserAccountIds,
-  resolveDefaultZalouserAccountId,
-  resolveZalouserAccountSync,
-  checkZcaAuthenticated,
-  type ResolvedZalouserAccount,
-} from "./accounts.js";
-import type { ChannelPlugin } from "./channel-api.js";
-import { buildChannelConfigSchema, formatAllowFromLowercase } from "./channel-api.js";
-import { ZalouserConfigSchema } from "./config-schema.js";
-import { zalouserDoctor } from "./doctor.js";
-
-const zalouserMeta: ChannelPlugin<ResolvedZalouserAccount>["meta"] = {
-  id: "zalouser",
-  label: "Zalo Personal",
-  selectionLabel: "Zalo (Personal Account)",
-  docsPath: "/channels/zalouser",
-  docsLabel: "zalouser",
-  blurb: "Zalo personal account via QR code login.",
-  aliases: ["zlu"],
-  order: 85,
-  quickstartAllowFrom: false,
-};
-
-const zalouserConfigAdapter = createScopedChannelConfigAdapter<ResolvedZalouserAccount>({
-  sectionKey: "zalouser",
-  listAccountIds: listZalouserAccountIds,
-  resolveAccount: adaptScopedAccountAccessor(resolveZalouserAccountSync),
-  defaultAccountId: resolveDefaultZalouserAccountId,
-  clearBaseFields: [
-    "profile",
-    "name",
-    "dmPolicy",
-    "allowFrom",
-    "historyLimit",
-    "groupAllowFrom",
-    "groupPolicy",
-    "groups",
-    "messagePrefix",
-  ],
-  resolveAllowFrom: (account) => account.config.allowFrom,
-  formatAllowFrom: (allowFrom) =>
-    formatAllowFromLowercase({ allowFrom, stripPrefixRe: /^(zalouser|zlu):/i }),
-});
-
-export function createZalouserPluginBase(params: {
-  setupWizard: NonNullable<ChannelPlugin<ResolvedZalouserAccount>["setupWizard"]>;
-  setup: NonNullable<ChannelPlugin<ResolvedZalouserAccount>["setup"]>;
-}): Pick<
-  ChannelPlugin<ResolvedZalouserAccount>,
-  | "id"
-  | "meta"
-  | "setupWizard"
-  | "capabilities"
-  | "doctor"
-  | "reload"
-  | "configSchema"
-  | "config"
-  | "setup"
-> {
-  return {
-    id: "zalouser",
-    meta: zalouserMeta,
-    setupWizard: params.setupWizard,
-    capabilities: {
-      chatTypes: ["direct", "group"],
-      media: true,
-      reactions: true,
-      threads: false,
-      polls: false,
-      nativeCommands: false,
-      blockStreaming: true,
-    },
-    doctor: zalouserDoctor,
-    reload: { configPrefixes: ["channels.zalouser"] },
-    configSchema: buildChannelConfigSchema(ZalouserConfigSchema),
-    config: {
-      ...zalouserConfigAdapter,
-      isConfigured: async (account) => await checkZcaAuthenticated(account.profile),
-      describeAccount: (account) =>
-        describeAccountSnapshot({
-          account,
-        }),
-    },
-    setup: params.setup,
-  };
-}

package/src/status-issues.test.ts

@@ -1,31 +0,0 @@
-import { expectOpenDmPolicyConfigIssue } from "klaw/plugin-sdk/channel-test-helpers";
-import { describe, expect, it } from "vitest";
-import { collectZalouserStatusIssues } from "./status-issues.js";
-
-describe("collectZalouserStatusIssues", () => {
-  it("flags missing auth when configured is false", () => {
-    const issues = collectZalouserStatusIssues([
-      {
-        accountId: "default",
-        enabled: true,
-        configured: false,
-        lastError: "not authenticated",
-      },
-    ]);
-    expect(issues).toHaveLength(1);
-    expect(issues[0]?.kind).toBe("auth");
-    expect(issues[0]?.message).toMatch(/Not authenticated/i);
-  });
-
-  it("warns when dmPolicy is open", () => {
-    expectOpenDmPolicyConfigIssue({
-      collectIssues: collectZalouserStatusIssues,
-      account: {
-        accountId: "default",
-        enabled: true,
-        configured: true,
-        dmPolicy: "open",
-      },
-    });
-  });
-});

package/src/status-issues.ts

@@ -1,55 +0,0 @@
-import type { ChannelAccountSnapshot, ChannelStatusIssue } from "klaw/plugin-sdk/channel-contract";
-import {
-  coerceStatusIssueAccountId,
-  readStatusIssueFields,
-} from "klaw/plugin-sdk/extension-shared";
-
-const ZALOUSER_STATUS_FIELDS = [
-  "accountId",
-  "enabled",
-  "configured",
-  "dmPolicy",
-  "lastError",
-] as const;
-
-export function collectZalouserStatusIssues(
-  accounts: ChannelAccountSnapshot[],
-): ChannelStatusIssue[] {
-  const issues: ChannelStatusIssue[] = [];
-  for (const entry of accounts) {
-    const account = readStatusIssueFields(entry, ZALOUSER_STATUS_FIELDS);
-    if (!account) {
-      continue;
-    }
-    const accountId = coerceStatusIssueAccountId(account.accountId) ?? "default";
-    const enabled = account.enabled !== false;
-    if (!enabled) {
-      continue;
-    }
-
-    const configured = account.configured === true;
-
-    if (!configured) {
-      issues.push({
-        channel: "zalouser",
-        accountId,
-        kind: "auth",
-        message: "Not authenticated (no saved Zalo session).",
-        fix: "Run: klaw channels login --channel zalouser",
-      });
-      continue;
-    }
-
-    if (account.dmPolicy === "open") {
-      issues.push({
-        channel: "zalouser",
-        accountId,
-        kind: "config",
-        message:
-          'Zalo Personal dmPolicy is "open", allowing any user to message the bot without pairing.',
-        fix: 'Set channels.zalouser.dmPolicy to "pairing" or "allowlist" to restrict access.',
-      });
-    }
-  }
-  return issues;
-}