@openclaw/zalo 2026.5.2 → 2026.5.3-beta.2

package/src/session-route.ts

@@ -1,32 +0,0 @@
-import {
-  buildChannelOutboundSessionRoute,
-  stripChannelTargetPrefix,
-  stripTargetKindPrefix,
-  type ChannelOutboundSessionRouteParams,
-} from "openclaw/plugin-sdk/core";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-
-export function resolveZaloOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
-  const trimmed = stripChannelTargetPrefix(params.target, "zalo", "zl");
-  if (!trimmed) {
-    return null;
-  }
-  const isGroup = normalizeLowercaseStringOrEmpty(trimmed).startsWith("group:");
-  const peerId = stripTargetKindPrefix(trimmed);
-  if (!peerId) {
-    return null;
-  }
-  return buildChannelOutboundSessionRoute({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "zalo",
-    accountId: params.accountId,
-    peer: {
-      kind: isGroup ? "group" : "direct",
-      id: peerId,
-    },
-    chatType: isGroup ? "group" : "direct",
-    from: isGroup ? `zalo:group:${peerId}` : `zalo:${peerId}`,
-    to: `zalo:${peerId}`,
-  });
-}

package/src/setup-allow-from.ts

@@ -1,94 +0,0 @@
-import {
-  DEFAULT_ACCOUNT_ID,
-  formatDocsLink,
-  mergeAllowFromEntries,
-  type ChannelSetupDmPolicy,
-  type ChannelSetupWizard,
-  type OpenClawConfig,
-} from "openclaw/plugin-sdk/setup";
-import { resolveDefaultZaloAccountId, resolveZaloAccount } from "./accounts.js";
-
-type ZaloAccountSetupConfig = {
-  enabled?: boolean;
-};
-
-export async function noteZaloTokenHelp(
-  prompter: Parameters<NonNullable<ChannelSetupWizard["finalize"]>>[0]["prompter"],
-): Promise<void> {
-  await prompter.note(
-    [
-      "1) Open Zalo Bot Platform: https://bot.zaloplatforms.com",
-      "2) Create a bot and get the token",
-      "3) Token looks like 12345689:abc-xyz",
-      "Tip: you can also set ZALO_BOT_TOKEN in your env.",
-      `Docs: ${formatDocsLink("/channels/zalo", "zalo")}`,
-    ].join("\n"),
-    "Zalo bot token",
-  );
-}
-
-export async function promptZaloAllowFrom(params: {
-  cfg: OpenClawConfig;
-  prompter: Parameters<NonNullable<ChannelSetupDmPolicy["promptAllowFrom"]>>[0]["prompter"];
-  accountId?: string;
-}): Promise<OpenClawConfig> {
-  const { cfg, prompter } = params;
-  const accountId = params.accountId ?? resolveDefaultZaloAccountId(cfg);
-  const resolved = resolveZaloAccount({ cfg, accountId });
-  const existingAllowFrom = resolved.config.allowFrom ?? [];
-  const entry = await prompter.text({
-    message: "Zalo allowFrom (user id)",
-    placeholder: "123456789",
-    initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
-    validate: (value) => {
-      const raw = (value ?? "").trim();
-      if (!raw) {
-        return "Required";
-      }
-      if (!/^\d+$/.test(raw)) {
-        return "Use a numeric Zalo user id";
-      }
-      return undefined;
-    },
-  });
-  const normalized = entry.trim();
-  const unique = mergeAllowFromEntries(existingAllowFrom, [normalized]);
-
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        zalo: {
-          ...cfg.channels?.zalo,
-          enabled: true,
-          dmPolicy: "allowlist",
-          allowFrom: unique,
-        },
-      },
-    } as OpenClawConfig;
-  }
-
-  const currentAccount = cfg.channels?.zalo?.accounts?.[accountId] as
-    | ZaloAccountSetupConfig
-    | undefined;
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      zalo: {
-        ...cfg.channels?.zalo,
-        enabled: true,
-        accounts: {
-          ...cfg.channels?.zalo?.accounts,
-          [accountId]: {
-            ...currentAccount,
-            enabled: currentAccount?.enabled ?? true,
-            dmPolicy: "allowlist",
-            allowFrom: unique,
-          },
-        },
-      },
-    },
-  } as OpenClawConfig;
-}

package/src/setup-core.ts

@@ -1,149 +0,0 @@
-import {
-  addWildcardAllowFrom,
-  createDelegatedSetupWizardProxy,
-  createPatchedAccountSetupAdapter,
-  createSetupInputPresenceValidator,
-  DEFAULT_ACCOUNT_ID,
-  normalizeAccountId,
-  type ChannelSetupDmPolicy,
-  type ChannelSetupWizard,
-} from "openclaw/plugin-sdk/setup";
-import { resolveDefaultZaloAccountId, resolveZaloAccount } from "./accounts.js";
-import { promptZaloAllowFrom } from "./setup-allow-from.js";
-
-const channel = "zalo" as const;
-
-type ZaloAccountSetupConfig = {
-  enabled?: boolean;
-  dmPolicy?: string;
-  allowFrom?: Array<string | number> | ReadonlyArray<string | number>;
-};
-
-export const zaloSetupAdapter = createPatchedAccountSetupAdapter({
-  channelKey: channel,
-  validateInput: createSetupInputPresenceValidator({
-    defaultAccountOnlyEnvError: "ZALO_BOT_TOKEN can only be used for the default account.",
-    whenNotUseEnv: [
-      {
-        someOf: ["token", "tokenFile"],
-        message: "Zalo requires token or --token-file (or --use-env).",
-      },
-    ],
-  }),
-  buildPatch: (input) =>
-    input.useEnv
-      ? {}
-      : input.tokenFile
-        ? { tokenFile: input.tokenFile }
-        : input.token
-          ? { botToken: input.token }
-          : {},
-});
-
-export const zaloDmPolicy: ChannelSetupDmPolicy = {
-  label: "Zalo",
-  channel,
-  policyKey: "channels.zalo.dmPolicy",
-  allowFromKey: "channels.zalo.allowFrom",
-  resolveConfigKeys: (cfg, accountId) =>
-    (accountId ?? resolveDefaultZaloAccountId(cfg)) !== DEFAULT_ACCOUNT_ID
-      ? {
-          policyKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.dmPolicy`,
-          allowFromKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.allowFrom`,
-        }
-      : {
-          policyKey: "channels.zalo.dmPolicy",
-          allowFromKey: "channels.zalo.allowFrom",
-        },
-  getCurrent: (cfg, accountId) =>
-    resolveZaloAccount({
-      cfg: cfg,
-      accountId: accountId ?? resolveDefaultZaloAccountId(cfg),
-    }).config.dmPolicy ?? "pairing",
-  setPolicy: (cfg, policy, accountId) => {
-    const resolvedAccountId =
-      accountId && normalizeAccountId(accountId)
-        ? (normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID)
-        : resolveDefaultZaloAccountId(cfg);
-    const resolved = resolveZaloAccount({
-      cfg: cfg,
-      accountId: resolvedAccountId,
-    });
-    if (resolvedAccountId === DEFAULT_ACCOUNT_ID) {
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          zalo: {
-            ...cfg.channels?.zalo,
-            enabled: true,
-            dmPolicy: policy,
-            ...(policy === "open"
-              ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) }
-              : {}),
-          },
-        },
-      };
-    }
-    const currentAccount = cfg.channels?.zalo?.accounts?.[resolvedAccountId] as
-      | ZaloAccountSetupConfig
-      | undefined;
-    return {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        zalo: {
-          ...cfg.channels?.zalo,
-          enabled: true,
-          accounts: {
-            ...cfg.channels?.zalo?.accounts,
-            [resolvedAccountId]: {
-              ...currentAccount,
-              enabled: currentAccount?.enabled ?? true,
-              dmPolicy: policy,
-              ...(policy === "open"
-                ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) }
-                : {}),
-            },
-          },
-        },
-      },
-    };
-  },
-  promptAllowFrom: async ({ cfg, prompter, accountId }) =>
-    promptZaloAllowFrom({
-      cfg,
-      prompter,
-      accountId: accountId ?? resolveDefaultZaloAccountId(cfg),
-    }),
-};
-
-export function createZaloSetupWizardProxy(
-  loadWizard: () => Promise<ChannelSetupWizard>,
-): ChannelSetupWizard {
-  return createDelegatedSetupWizardProxy({
-    channel,
-    loadWizard,
-    status: {
-      configuredLabel: "configured",
-      unconfiguredLabel: "needs token",
-      configuredHint: "recommended · configured",
-      unconfiguredHint: "recommended · newcomer-friendly",
-      configuredScore: 1,
-      unconfiguredScore: 10,
-    },
-    credentials: [],
-    delegateFinalize: true,
-    dmPolicy: zaloDmPolicy,
-    disable: (cfg) => ({
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        zalo: {
-          ...cfg.channels?.zalo,
-          enabled: false,
-        },
-      },
-    }),
-  });
-}

package/src/setup-status.test.ts

@@ -1,33 +0,0 @@
-import { createPluginSetupWizardStatus } from "openclaw/plugin-sdk/plugin-test-runtime";
-import { describe, expect, it } from "vitest";
-import type { OpenClawConfig } from "../runtime-api.js";
-import { zaloSetupWizard } from "./setup-surface.js";
-
-const zaloGetStatus = createPluginSetupWizardStatus({
-  id: "zalo",
-  meta: {
-    label: "Zalo",
-  },
-  setupWizard: zaloSetupWizard,
-} as never);
-
-describe("zalo setup wizard status", () => {
-  it("treats SecretRef botToken as configured", async () => {
-    const status = await zaloGetStatus({
-      cfg: {
-        channels: {
-          zalo: {
-            botToken: {
-              source: "env",
-              provider: "default",
-              id: "ZALO_BOT_TOKEN",
-            },
-          },
-        },
-      } as OpenClawConfig,
-      accountOverrides: {},
-    });
-
-    expect(status.configured).toBe(true);
-  });
-});

package/src/setup-surface.test.ts

@@ -1,175 +0,0 @@
-import { adaptScopedAccountAccessor } from "openclaw/plugin-sdk/channel-config-helpers";
-import {
-  createPluginSetupWizardConfigure,
-  createTestWizardPrompter,
-  runSetupWizardConfigure,
-} from "openclaw/plugin-sdk/plugin-test-runtime";
-import type { WizardPrompter } from "openclaw/plugin-sdk/plugin-test-runtime";
-import { describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig } 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 OpenClawConfig,
-      prompter,
-      options: { secretInputMode: "plaintext" as const },
-    });
-
-    expect(result.accountId).toBe("default");
-    expect(result.cfg.channels?.zalo?.enabled).toBe(true);
-    expect(result.cfg.channels?.zalo?.botToken).toBe("12345689:abc-xyz");
-    expect(result.cfg.channels?.zalo?.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 OpenClawConfig,
-        "work",
-      ),
-    ).toBe("allowlist");
-  });
-
-  it("reports account-scoped config keys for named accounts", () => {
-    expect(zaloDmPolicy.resolveConfigKeys?.({} as OpenClawConfig, "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 OpenClawConfig;
-
-    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");
-    expect(next.channels?.zalo?.dmPolicy).toBe("disabled");
-    const workAccount = next.channels?.zalo?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    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 OpenClawConfig,
-      "open",
-      "work",
-    );
-
-    expect(next.channels?.zalo?.dmPolicy).toBeUndefined();
-    const workAccount = next.channels?.zalo?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    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 OpenClawConfig,
-    });
-
-    expect(configured).toBe(false);
-  });
-});