@kodelyth/zalo 2026.5.42 → 2026.6.2

package/src/setup-surface.test.ts

@@ -1,193 +0,0 @@
-import { adaptScopedAccountAccessor } from "klaw/plugin-sdk/channel-config-helpers";
-import {
-  createPluginSetupWizardConfigure,
-  createTestWizardPrompter,
-  runSetupWizardConfigure,
-} from "klaw/plugin-sdk/plugin-test-runtime";
-import type { WizardPrompter } from "klaw/plugin-sdk/plugin-test-runtime";
-import { describe, expect, it, vi } from "vitest";
-import type { KlawConfig } from "../runtime-api.js";
-import { listZaloAccountIds, resolveDefaultZaloAccountId, resolveZaloAccount } from "./accounts.js";
-import { zaloDmPolicy } from "./setup-core.js";
-import { zaloSetupAdapter, zaloSetupWizard } from "./setup-surface.js";
-
-const zaloSetupPlugin = {
-  id: "zalo",
-  meta: {
-    id: "zalo",
-    label: "Zalo",
-    selectionLabel: "Zalo (Bot API)",
-    docsPath: "/channels/zalo",
-    blurb: "Vietnam-focused messaging platform with Bot API.",
-  },
-  capabilities: {
-    chatTypes: ["direct", "group"] as Array<"direct" | "group">,
-  },
-  config: {
-    listAccountIds: (cfg: unknown) => listZaloAccountIds(cfg as never),
-    defaultAccountId: (cfg: unknown) => resolveDefaultZaloAccountId(cfg as never),
-    resolveAccount: adaptScopedAccountAccessor(resolveZaloAccount),
-  },
-  setup: zaloSetupAdapter,
-  setupWizard: zaloSetupWizard,
-} as const;
-
-const zaloConfigure = createPluginSetupWizardConfigure(zaloSetupPlugin);
-
-describe("zalo setup wizard", () => {
-  it("configures a polling token flow", async () => {
-    const prompter = createTestWizardPrompter({
-      select: vi.fn(async () => "plaintext") as WizardPrompter["select"],
-      text: vi.fn(async ({ message }: { message: string }) => {
-        if (message === "Enter Zalo bot token") {
-          return "12345689:abc-xyz";
-        }
-        throw new Error(`Unexpected prompt: ${message}`);
-      }) as WizardPrompter["text"],
-      confirm: vi.fn(async ({ message }: { message: string }) => {
-        if (message === "Use webhook mode for Zalo?") {
-          return false;
-        }
-        return false;
-      }),
-    });
-
-    const result = await runSetupWizardConfigure({
-      configure: zaloConfigure,
-      cfg: {} as KlawConfig,
-      prompter,
-      options: { secretInputMode: "plaintext" as const },
-    });
-
-    expect(result.accountId).toBe("default");
-    const zaloConfig = result.cfg.channels?.zalo;
-    if (!zaloConfig) {
-      throw new Error("expected Zalo config");
-    }
-    expect(zaloConfig.enabled).toBe(true);
-    expect(zaloConfig.botToken).toBe("12345689:abc-xyz");
-    expect(zaloConfig.webhookUrl).toBeUndefined();
-  });
-
-  it("reads the named-account DM policy instead of the channel root", () => {
-    expect(
-      zaloDmPolicy.getCurrent(
-        {
-          channels: {
-            zalo: {
-              dmPolicy: "disabled",
-              accounts: {
-                work: {
-                  botToken: "12345689:abc-xyz",
-                  dmPolicy: "allowlist",
-                },
-              },
-            },
-          },
-        } as KlawConfig,
-        "work",
-      ),
-    ).toBe("allowlist");
-  });
-
-  it("reports account-scoped config keys for named accounts", () => {
-    expect(zaloDmPolicy.resolveConfigKeys?.({} as KlawConfig, "work")).toEqual({
-      policyKey: "channels.zalo.accounts.work.dmPolicy",
-      allowFromKey: "channels.zalo.accounts.work.allowFrom",
-    });
-  });
-
-  it("uses configured defaultAccount for omitted DM policy account context", () => {
-    const cfg = {
-      channels: {
-        zalo: {
-          defaultAccount: "work",
-          dmPolicy: "disabled",
-          allowFrom: ["123456789"],
-          accounts: {
-            work: {
-              botToken: "12345689:abc-xyz",
-              dmPolicy: "allowlist",
-            },
-          },
-        },
-      },
-    } as KlawConfig;
-
-    expect(zaloDmPolicy.getCurrent(cfg)).toBe("allowlist");
-    expect(zaloDmPolicy.resolveConfigKeys?.(cfg)).toEqual({
-      policyKey: "channels.zalo.accounts.work.dmPolicy",
-      allowFromKey: "channels.zalo.accounts.work.allowFrom",
-    });
-
-    const next = zaloDmPolicy.setPolicy(cfg, "open");
-    const zaloConfig = next.channels?.zalo;
-    if (!zaloConfig) {
-      throw new Error("expected Zalo config");
-    }
-    expect(zaloConfig.dmPolicy).toBe("disabled");
-    const workAccount = next.channels?.zalo?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    if (!workAccount) {
-      throw new Error("expected Zalo work account");
-    }
-    expect(workAccount.dmPolicy).toBe("open");
-  });
-
-  it('writes open policy state to the named account and preserves inherited allowFrom with "*"', () => {
-    const next = zaloDmPolicy.setPolicy(
-      {
-        channels: {
-          zalo: {
-            allowFrom: ["123456789"],
-            accounts: {
-              work: {
-                botToken: "12345689:abc-xyz",
-              },
-            },
-          },
-        },
-      } as KlawConfig,
-      "open",
-      "work",
-    );
-
-    const zaloConfig = next.channels?.zalo;
-    if (!zaloConfig) {
-      throw new Error("expected Zalo config");
-    }
-    expect(zaloConfig.dmPolicy).toBeUndefined();
-    const workAccount = next.channels?.zalo?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    if (!workAccount) {
-      throw new Error("expected Zalo work account");
-    }
-    expect(workAccount.dmPolicy).toBe("open");
-    expect(workAccount.allowFrom).toEqual(["123456789", "*"]);
-  });
-
-  it("uses configured defaultAccount for omitted setup configured state", async () => {
-    const configured = await zaloSetupWizard.status.resolveConfigured({
-      cfg: {
-        channels: {
-          zalo: {
-            defaultAccount: "work",
-            botToken: "root-token",
-            accounts: {
-              alerts: {
-                botToken: "alerts-token",
-              },
-              work: {
-                botToken: "",
-              },
-            },
-          },
-        },
-      } as KlawConfig,
-    });
-
-    expect(configured).toBe(false);
-  });
-});

package/src/setup-surface.ts

@@ -1,294 +0,0 @@
-import {
-  buildSingleChannelSecretPromptState,
-  createStandardChannelSetupStatus,
-  DEFAULT_ACCOUNT_ID,
-  hasConfiguredSecretInput,
-  promptSingleChannelSecretInput,
-  runSingleChannelSecretStep,
-  type ChannelSetupWizard,
-  type KlawConfig,
-  type SecretInput,
-  createSetupTranslator,
-} from "klaw/plugin-sdk/setup";
-import { resolveZaloAccount } from "./accounts.js";
-import { noteZaloTokenHelp, promptZaloAllowFrom } from "./setup-allow-from.js";
-import { zaloDmPolicy } from "./setup-core.js";
-
-const t = createSetupTranslator();
-
-const channel = "zalo" as const;
-
-type UpdateMode = "polling" | "webhook";
-
-function setZaloUpdateMode(
-  cfg: KlawConfig,
-  accountId: string,
-  mode: UpdateMode,
-  webhookUrl?: string,
-  webhookSecret?: SecretInput,
-  webhookPath?: string,
-): KlawConfig {
-  const isDefault = accountId === DEFAULT_ACCOUNT_ID;
-  if (mode === "polling") {
-    if (isDefault) {
-      const {
-        webhookUrl: _url,
-        webhookSecret: _secret,
-        webhookPath: _path,
-        ...rest
-      } = cfg.channels?.zalo ?? {};
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          zalo: rest,
-        },
-      } as KlawConfig;
-    }
-    const accounts = { ...cfg.channels?.zalo?.accounts } as Record<string, Record<string, unknown>>;
-    const existing = accounts[accountId] ?? {};
-    const { webhookUrl: _url, webhookSecret: _secret, webhookPath: _path, ...rest } = existing;
-    accounts[accountId] = rest;
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        zalo: {
-          ...cfg.channels?.zalo,
-          accounts,
-        },
-      },
-    } as KlawConfig;
-  }
-
-  if (isDefault) {
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        zalo: {
-          ...cfg.channels?.zalo,
-          webhookUrl,
-          webhookSecret,
-          webhookPath,
-        },
-      },
-    } as KlawConfig;
-  }
-
-  const accounts = { ...cfg.channels?.zalo?.accounts } as Record<string, Record<string, unknown>>;
-  accounts[accountId] = {
-    ...accounts[accountId],
-    webhookUrl,
-    webhookSecret,
-    webhookPath,
-  };
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      zalo: {
-        ...cfg.channels?.zalo,
-        accounts,
-      },
-    },
-  } as KlawConfig;
-}
-
-export { zaloSetupAdapter } from "./setup-core.js";
-
-export const zaloSetupWizard: ChannelSetupWizard = {
-  channel,
-  status: createStandardChannelSetupStatus({
-    channelLabel: "Zalo",
-    configuredLabel: t("wizard.channels.statusConfigured"),
-    unconfiguredLabel: t("wizard.channels.statusNeedsToken"),
-    configuredHint: t("wizard.channels.statusRecommendedConfigured"),
-    unconfiguredHint: t("wizard.channels.statusRecommendedNewcomerFriendly"),
-    configuredScore: 1,
-    unconfiguredScore: 10,
-    includeStatusLine: true,
-    resolveConfigured: ({ cfg, accountId }) => {
-      const account = resolveZaloAccount({
-        cfg,
-        accountId,
-        allowUnresolvedSecretRef: true,
-      });
-      return (
-        Boolean(account.token) ||
-        hasConfiguredSecretInput(account.config.botToken) ||
-        Boolean(account.config.tokenFile?.trim())
-      );
-    },
-  }),
-  credentials: [],
-  finalize: async ({ cfg, accountId, forceAllowFrom, options, prompter }) => {
-    let next = cfg;
-    const resolvedAccount = resolveZaloAccount({
-      cfg: next,
-      accountId,
-      allowUnresolvedSecretRef: true,
-    });
-    const accountConfigured = Boolean(resolvedAccount.token);
-    const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-    const hasConfigToken = Boolean(
-      hasConfiguredSecretInput(resolvedAccount.config.botToken) || resolvedAccount.config.tokenFile,
-    );
-    const tokenStep = await runSingleChannelSecretStep({
-      cfg: next,
-      prompter,
-      providerHint: "zalo",
-      credentialLabel: t("wizard.zalo.botToken"),
-      secretInputMode: options?.secretInputMode,
-      accountConfigured,
-      hasConfigToken,
-      allowEnv,
-      envValue: process.env.ZALO_BOT_TOKEN,
-      envPrompt: t("wizard.zalo.tokenEnvPrompt"),
-      keepPrompt: t("wizard.zalo.tokenKeep"),
-      inputPrompt: t("wizard.zalo.tokenInput"),
-      preferredEnvVar: "ZALO_BOT_TOKEN",
-      onMissingConfigured: async () => await noteZaloTokenHelp(prompter),
-      applyUseEnv: async (currentCfg) =>
-        accountId === DEFAULT_ACCOUNT_ID
-          ? ({
-              ...currentCfg,
-              channels: {
-                ...currentCfg.channels,
-                zalo: {
-                  ...currentCfg.channels?.zalo,
-                  enabled: true,
-                },
-              },
-            } as KlawConfig)
-          : currentCfg,
-      applySet: async (currentCfg, value) =>
-        accountId === DEFAULT_ACCOUNT_ID
-          ? ({
-              ...currentCfg,
-              channels: {
-                ...currentCfg.channels,
-                zalo: {
-                  ...currentCfg.channels?.zalo,
-                  enabled: true,
-                  botToken: value,
-                },
-              },
-            } as KlawConfig)
-          : ({
-              ...currentCfg,
-              channels: {
-                ...currentCfg.channels,
-                zalo: {
-                  ...currentCfg.channels?.zalo,
-                  enabled: true,
-                  accounts: {
-                    ...currentCfg.channels?.zalo?.accounts,
-                    [accountId]: {
-                      ...(currentCfg.channels?.zalo?.accounts?.[accountId] as
-                        | Record<string, unknown>
-                        | undefined),
-                      enabled: true,
-                      botToken: value,
-                    },
-                  },
-                },
-              },
-            } as KlawConfig),
-    });
-    next = tokenStep.cfg;
-
-    const wantsWebhook = await prompter.confirm({
-      message: t("wizard.zalo.webhookModePrompt"),
-      initialValue: Boolean(resolvedAccount.config.webhookUrl),
-    });
-    if (wantsWebhook) {
-      const webhookUrl = (
-        await prompter.text({
-          message: t("wizard.zalo.webhookUrlPrompt"),
-          initialValue: resolvedAccount.config.webhookUrl,
-          validate: (value) =>
-            value?.trim()?.startsWith("https://") ? undefined : "HTTPS URL required",
-        })
-      ).trim();
-      const defaultPath = (() => {
-        try {
-          return new URL(webhookUrl).pathname || "/zalo-webhook";
-        } catch {
-          return "/zalo-webhook";
-        }
-      })();
-
-      let webhookSecretResult = await promptSingleChannelSecretInput({
-        cfg: next,
-        prompter,
-        providerHint: "zalo-webhook",
-        credentialLabel: t("wizard.zalo.webhookSecret"),
-        secretInputMode: options?.secretInputMode,
-        ...buildSingleChannelSecretPromptState({
-          accountConfigured: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
-          hasConfigToken: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
-          allowEnv: false,
-        }),
-        envPrompt: "",
-        keepPrompt: t("wizard.zalo.webhookSecretKeep"),
-        inputPrompt: t("wizard.zalo.webhookSecretInput"),
-        preferredEnvVar: "ZALO_WEBHOOK_SECRET",
-      });
-      while (
-        webhookSecretResult.action === "set" &&
-        typeof webhookSecretResult.value === "string" &&
-        (webhookSecretResult.value.length < 8 || webhookSecretResult.value.length > 256)
-      ) {
-        await prompter.note(t("wizard.zalo.webhookSecretLength"), t("wizard.zalo.webhookTitle"));
-        webhookSecretResult = await promptSingleChannelSecretInput({
-          cfg: next,
-          prompter,
-          providerHint: "zalo-webhook",
-          credentialLabel: t("wizard.zalo.webhookSecret"),
-          secretInputMode: options?.secretInputMode,
-          ...buildSingleChannelSecretPromptState({
-            accountConfigured: false,
-            hasConfigToken: false,
-            allowEnv: false,
-          }),
-          envPrompt: "",
-          keepPrompt: t("wizard.zalo.webhookSecretKeep"),
-          inputPrompt: t("wizard.zalo.webhookSecretInput"),
-          preferredEnvVar: "ZALO_WEBHOOK_SECRET",
-        });
-      }
-      const webhookSecret =
-        webhookSecretResult.action === "set"
-          ? webhookSecretResult.value
-          : resolvedAccount.config.webhookSecret;
-      const webhookPath = (
-        await prompter.text({
-          message: t("wizard.zalo.webhookPathPrompt"),
-          initialValue: resolvedAccount.config.webhookPath ?? defaultPath,
-        })
-      ).trim();
-      next = setZaloUpdateMode(
-        next,
-        accountId,
-        "webhook",
-        webhookUrl,
-        webhookSecret,
-        webhookPath || undefined,
-      );
-    } else {
-      next = setZaloUpdateMode(next, accountId, "polling");
-    }
-
-    if (forceAllowFrom) {
-      next = await promptZaloAllowFrom({
-        cfg: next,
-        prompter,
-        accountId,
-      });
-    }
-
-    return { cfg: next };
-  },
-  dmPolicy: zaloDmPolicy,
-};

package/src/status-issues.test.ts

@@ -1,17 +0,0 @@
-import { expectOpenDmPolicyConfigIssue } from "klaw/plugin-sdk/channel-test-helpers";
-import { describe, it } from "vitest";
-import { collectZaloStatusIssues } from "./status-issues.js";
-
-describe("collectZaloStatusIssues", () => {
-  it("warns when dmPolicy is open", () => {
-    expectOpenDmPolicyConfigIssue({
-      collectIssues: collectZaloStatusIssues,
-      account: {
-        accountId: "default",
-        enabled: true,
-        configured: true,
-        dmPolicy: "open",
-      },
-    });
-  });
-});

package/src/status-issues.ts

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