@openclaw/zalo 2026.1.29 → 2026.2.2

package/CHANGELOG.md

@@ -1,58 +1,87 @@
 # Changelog
 
+## 2026.2.2
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.1.31
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.1.30
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.1.29
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.23
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.22
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.21
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.20
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.17-1
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.17
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.16
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.15
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 2026.1.14
 
 ### Changes
+
 - Version alignment with core OpenClaw release numbers.
 
 ## 0.1.0
 
 ### Features
+
 - Zalo Bot API channel plugin with token-based auth (env/config/file).
 - Direct message support (DMs only) with pairing/allowlist/open/disabled policies.
 - Polling and webhook delivery modes.

package/README.md

@@ -25,9 +25,9 @@ Onboarding: select Zalo and confirm the install prompt to fetch the plugin autom
       enabled: true,
       botToken: "12345689:abc-xyz",
       dmPolicy: "pairing",
-      proxy: "http://proxy.local:8080"
-    }
-  }
+      proxy: "http://proxy.local:8080",
+    },
+  },
 }
 ```
 
@@ -39,9 +39,9 @@ Onboarding: select Zalo and confirm the install prompt to fetch the plugin autom
     zalo: {
       webhookUrl: "https://example.com/zalo-webhook",
       webhookSecret: "your-secret-8-plus-chars",
-      webhookPath: "/zalo-webhook"
-    }
-  }
+      webhookPath: "/zalo-webhook",
+    },
+  },
 }
 ```
 

package/index.ts

@@ -1,6 +1,5 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-
 import { zaloDock, zaloPlugin } from "./src/channel.js";
 import { handleZaloWebhookRequest } from "./src/monitor.js";
 import { setZaloRuntime } from "./src/runtime.js";

package/openclaw.plugin.json

@@ -1,8 +1,6 @@
 {
   "id": "zalo",
-  "channels": [
-    "zalo"
-  ],
+  "channels": ["zalo"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@openclaw/zalo",
-  "version": "2026.1.29",
-  "type": "module",
+  "version": "2026.2.2",
   "description": "OpenClaw Zalo channel plugin",
+  "type": "module",
+  "dependencies": {
+    "openclaw": "workspace:*",
+    "undici": "7.20.0"
+  },
+  "devDependencies": {
+    "openclaw": "workspace:*"
+  },
   "openclaw": {
     "extensions": [
       "./index.ts"
@@ -25,9 +32,5 @@
       "localPath": "extensions/zalo",
       "defaultChoice": "npm"
     }
-  },
-  "dependencies": {
-    "openclaw": "workspace:*",
-    "undici": "7.19.0"
   }
 }

package/src/accounts.ts

@@ -1,26 +1,33 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
-
 import type { ResolvedZaloAccount, ZaloAccountConfig, ZaloConfig } from "./types.js";
 import { resolveZaloToken } from "./token.js";
 
 function listConfiguredAccountIds(cfg: OpenClawConfig): string[] {
   const accounts = (cfg.channels?.zalo as ZaloConfig | undefined)?.accounts;
-  if (!accounts || typeof accounts !== "object") return [];
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
   return Object.keys(accounts).filter(Boolean);
 }
 
 export function listZaloAccountIds(cfg: OpenClawConfig): string[] {
   const ids = listConfiguredAccountIds(cfg);
-  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
-  return ids.sort((a, b) => a.localeCompare(b));
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
 }
 
 export function resolveDefaultZaloAccountId(cfg: OpenClawConfig): string {
   const zaloConfig = cfg.channels?.zalo as ZaloConfig | undefined;
-  if (zaloConfig?.defaultAccount?.trim()) return zaloConfig.defaultAccount.trim();
+  if (zaloConfig?.defaultAccount?.trim()) {
+    return zaloConfig.defaultAccount.trim();
+  }
   const ids = listZaloAccountIds(cfg);
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
   return ids[0] ?? DEFAULT_ACCOUNT_ID;
 }
 
@@ -29,7 +36,9 @@ function resolveAccountConfig(
   accountId: string,
 ): ZaloAccountConfig | undefined {
   const accounts = (cfg.channels?.zalo as ZaloConfig | undefined)?.accounts;
-  if (!accounts || typeof accounts !== "object") return undefined;
+  if (!accounts || typeof accounts !== "object") {
+    return undefined;
+  }
   return accounts[accountId] as ZaloAccountConfig | undefined;
 }
 

package/src/actions.ts

@@ -4,7 +4,6 @@ import type {
   OpenClawConfig,
 } from "openclaw/plugin-sdk";
 import { jsonResult, readStringParam } from "openclaw/plugin-sdk";
-
 import { listEnabledZaloAccounts } from "./accounts.js";
 import { sendMessageZalo } from "./send.js";
 
@@ -18,17 +17,23 @@ function listEnabledAccounts(cfg: OpenClawConfig) {
 
 export const zaloMessageActions: ChannelMessageActionAdapter = {
   listActions: ({ cfg }) => {
-    const accounts = listEnabledAccounts(cfg as OpenClawConfig);
-    if (accounts.length === 0) return [];
+    const accounts = listEnabledAccounts(cfg);
+    if (accounts.length === 0) {
+      return [];
+    }
     const actions = new Set<ChannelMessageActionName>(["send"]);
     return Array.from(actions);
   },
   supportsButtons: () => false,
   extractToolSend: ({ args }) => {
     const action = typeof args.action === "string" ? args.action.trim() : "";
-    if (action !== "sendMessage") return null;
+    if (action !== "sendMessage") {
+      return null;
+    }
     const to = typeof args.to === "string" ? args.to : undefined;
-    if (!to) return null;
+    if (!to) {
+      return null;
+    }
     const accountId = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
     return { to, accountId };
   },
@@ -44,7 +49,7 @@ export const zaloMessageActions: ChannelMessageActionAdapter = {
       const result = await sendMessageZalo(to ?? "", content ?? "", {
         accountId: accountId ?? undefined,
         mediaUrl: mediaUrl ?? undefined,
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
       });
 
       if (!result.ok) {

package/src/api.ts

@@ -122,7 +122,9 @@ export async function callZaloApi<T = unknown>(
 
     return data;
   } finally {
-    if (timeoutId) clearTimeout(timeoutId);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
   }
 }
 

package/src/channel.directory.test.ts

@@ -1,7 +1,5 @@
-import { describe, expect, it } from "vitest";
-
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
+import { describe, expect, it } from "vitest";
 import { zaloPlugin } from "./channel.js";
 
 describe("zalo directory", () => {
@@ -19,7 +17,12 @@ describe("zalo directory", () => {
     expect(zaloPlugin.directory?.listGroups).toBeTruthy();
 
     await expect(
-      zaloPlugin.directory!.listPeers({ cfg, accountId: undefined, query: undefined, limit: undefined }),
+      zaloPlugin.directory!.listPeers({
+        cfg,
+        accountId: undefined,
+        query: undefined,
+        limit: undefined,
+      }),
     ).resolves.toEqual(
       expect.arrayContaining([
         { kind: "user", id: "123" },
@@ -28,8 +31,13 @@ describe("zalo directory", () => {
       ]),
     );
 
-    await expect(zaloPlugin.directory!.listGroups({ cfg, accountId: undefined, query: undefined, limit: undefined })).resolves.toEqual(
-      [],
-    );
+    await expect(
+      zaloPlugin.directory!.listGroups({
+        cfg,
+        accountId: undefined,
+        query: undefined,
+        limit: undefined,
+      }),
+    ).resolves.toEqual([]);
   });
 });

package/src/channel.ts

@@ -15,13 +15,17 @@ import {
   PAIRING_APPROVED_MESSAGE,
   setAccountEnabledInConfigSection,
 } from "openclaw/plugin-sdk";
-
-import { listZaloAccountIds, resolveDefaultZaloAccountId, resolveZaloAccount, type ResolvedZaloAccount } from "./accounts.js";
+import {
+  listZaloAccountIds,
+  resolveDefaultZaloAccountId,
+  resolveZaloAccount,
+  type ResolvedZaloAccount,
+} from "./accounts.js";
 import { zaloMessageActions } from "./actions.js";
 import { ZaloConfigSchema } from "./config-schema.js";
 import { zaloOnboardingAdapter } from "./onboarding.js";
-import { resolveZaloProxyFetch } from "./proxy.js";
 import { probeZalo } from "./probe.js";
+import { resolveZaloProxyFetch } from "./proxy.js";
 import { sendMessageZalo } from "./send.js";
 import { collectZaloStatusIssues } from "./status-issues.js";
 
@@ -39,7 +43,9 @@ const meta = {
 
 function normalizeZaloMessagingTarget(raw: string): string | undefined {
   const trimmed = raw?.trim();
-  if (!trimmed) return undefined;
+  if (!trimmed) {
+    return undefined;
+  }
   return trimmed.replace(/^(zalo|zl):/i, "");
 }
 
@@ -53,8 +59,8 @@ export const zaloDock: ChannelDock = {
   outbound: { textChunkLimit: 2000 },
   config: {
     resolveAllowFrom: ({ cfg, accountId }) =>
-      (resolveZaloAccount({ cfg: cfg as OpenClawConfig, accountId }).config.allowFrom ?? []).map(
-        (entry) => String(entry),
+      (resolveZaloAccount({ cfg: cfg, accountId }).config.allowFrom ?? []).map((entry) =>
+        String(entry),
       ),
     formatAllowFrom: ({ allowFrom }) =>
       allowFrom
@@ -87,12 +93,12 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
   reload: { configPrefixes: ["channels.zalo"] },
   configSchema: buildChannelConfigSchema(ZaloConfigSchema),
   config: {
-    listAccountIds: (cfg) => listZaloAccountIds(cfg as OpenClawConfig),
-    resolveAccount: (cfg, accountId) => resolveZaloAccount({ cfg: cfg as OpenClawConfig, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultZaloAccountId(cfg as OpenClawConfig),
+    listAccountIds: (cfg) => listZaloAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveZaloAccount({ cfg: cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultZaloAccountId(cfg),
     setAccountEnabled: ({ cfg, accountId, enabled }) =>
       setAccountEnabledInConfigSection({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         sectionKey: "zalo",
         accountId,
         enabled,
@@ -100,7 +106,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
       }),
     deleteAccount: ({ cfg, accountId }) =>
       deleteAccountFromConfigSection({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         sectionKey: "zalo",
         accountId,
         clearBaseFields: ["botToken", "tokenFile", "name"],
@@ -114,8 +120,8 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
       tokenSource: account.tokenSource,
     }),
     resolveAllowFrom: ({ cfg, accountId }) =>
-      (resolveZaloAccount({ cfg: cfg as OpenClawConfig, accountId }).config.allowFrom ?? []).map(
-        (entry) => String(entry),
+      (resolveZaloAccount({ cfg: cfg, accountId }).config.allowFrom ?? []).map((entry) =>
+        String(entry),
       ),
     formatAllowFrom: ({ allowFrom }) =>
       allowFrom
@@ -127,9 +133,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
   security: {
     resolveDmPolicy: ({ cfg, accountId, account }) => {
       const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
-      const useAccountPath = Boolean(
-        (cfg as OpenClawConfig).channels?.zalo?.accounts?.[resolvedAccountId],
-      );
+      const useAccountPath = Boolean(cfg.channels?.zalo?.accounts?.[resolvedAccountId]);
       const basePath = useAccountPath
         ? `channels.zalo.accounts.${resolvedAccountId}.`
         : "channels.zalo.";
@@ -155,7 +159,9 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
     targetResolver: {
       looksLikeId: (raw) => {
         const trimmed = raw.trim();
-        if (!trimmed) return false;
+        if (!trimmed) {
+          return false;
+        }
         return /^\d{3,}$/.test(trimmed);
       },
       hint: "<chatId>",
@@ -164,7 +170,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
   directory: {
     self: async () => null,
     listPeers: async ({ cfg, accountId, query, limit }) => {
-      const account = resolveZaloAccount({ cfg: cfg as OpenClawConfig, accountId });
+      const account = resolveZaloAccount({ cfg: cfg, accountId });
       const q = query?.trim().toLowerCase() || "";
       const peers = Array.from(
         new Set(
@@ -185,7 +191,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
     resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
     applyAccountName: ({ cfg, accountId, name }) =>
       applyAccountNameToChannelSection({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         channelKey: "zalo",
         accountId,
         name,
@@ -201,7 +207,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
     },
     applyAccountConfig: ({ cfg, accountId, input }) => {
       const namedConfig = applyAccountNameToChannelSection({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         channelKey: "zalo",
         accountId,
         name: input.name,
@@ -240,9 +246,9 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
             ...next.channels?.zalo,
             enabled: true,
             accounts: {
-              ...(next.channels?.zalo?.accounts ?? {}),
+              ...next.channels?.zalo?.accounts,
               [accountId]: {
-                ...(next.channels?.zalo?.accounts?.[accountId] ?? {}),
+                ...next.channels?.zalo?.accounts?.[accountId],
                 enabled: true,
                 ...(input.tokenFile
                   ? { tokenFile: input.tokenFile }
@@ -260,16 +266,22 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
     idLabel: "zaloUserId",
     normalizeAllowEntry: (entry) => entry.replace(/^(zalo|zl):/i, ""),
     notifyApproval: async ({ cfg, id }) => {
-      const account = resolveZaloAccount({ cfg: cfg as OpenClawConfig });
-      if (!account.token) throw new Error("Zalo token not configured");
+      const account = resolveZaloAccount({ cfg: cfg });
+      if (!account.token) {
+        throw new Error("Zalo token not configured");
+      }
       await sendMessageZalo(id, PAIRING_APPROVED_MESSAGE, { token: account.token });
     },
   },
   outbound: {
     deliveryMode: "direct",
     chunker: (text, limit) => {
-      if (!text) return [];
-      if (limit <= 0 || text.length <= limit) return [text];
+      if (!text) {
+        return [];
+      }
+      if (limit <= 0 || text.length <= limit) {
+        return [text];
+      }
       const chunks: string[] = [];
       let remaining = text;
       while (remaining.length > limit) {
@@ -277,15 +289,21 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
         const lastNewline = window.lastIndexOf("\n");
         const lastSpace = window.lastIndexOf(" ");
         let breakIdx = lastNewline > 0 ? lastNewline : lastSpace;
-        if (breakIdx <= 0) breakIdx = limit;
+        if (breakIdx <= 0) {
+          breakIdx = limit;
+        }
         const rawChunk = remaining.slice(0, breakIdx);
         const chunk = rawChunk.trimEnd();
-        if (chunk.length > 0) chunks.push(chunk);
+        if (chunk.length > 0) {
+          chunks.push(chunk);
+        }
         const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
         const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
         remaining = remaining.slice(nextStart).trimStart();
       }
-      if (remaining.length) chunks.push(remaining);
+      if (remaining.length) {
+        chunks.push(remaining);
+      }
       return chunks;
     },
     chunkerMode: "text",
@@ -293,7 +311,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
     sendText: async ({ to, text, accountId, cfg }) => {
       const result = await sendMessageZalo(to, text, {
         accountId: accountId ?? undefined,
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
       });
       return {
         channel: "zalo",
@@ -306,7 +324,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
       const result = await sendMessageZalo(to, text, {
         accountId: accountId ?? undefined,
         mediaUrl,
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
       });
       return {
         channel: "zalo",
@@ -366,7 +384,9 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
       try {
         const probe = await probeZalo(token, 2500, fetcher);
         const name = probe.ok ? probe.bot?.name?.trim() : null;
-        if (name) zaloBotLabel = ` (${name})`;
+        if (name) {
+          zaloBotLabel = ` (${name})`;
+        }
         ctx.setStatus({
           accountId: account.accountId,
           bot: probe.bot,
@@ -379,7 +399,7 @@ export const zaloPlugin: ChannelPlugin<ResolvedZaloAccount> = {
       return monitorZaloProvider({
         token,
         account,
-        config: ctx.cfg as OpenClawConfig,
+        config: ctx.cfg,
         runtime: ctx.runtime,
         abortSignal: ctx.abortSignal,
         useWebhook: Boolean(account.config.webhookUrl),

package/src/monitor.ts

@@ -1,7 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-
 import type { OpenClawConfig, MarkdownTableMode } from "openclaw/plugin-sdk";
-
 import type { ResolvedZaloAccount } from "./accounts.js";
 import {
   ZaloApiError,
@@ -52,7 +50,9 @@ function logVerbose(core: ZaloCoreRuntime, runtime: ZaloRuntimeEnv, message: str
 }
 
 function isSenderAllowed(senderId: string, allowFrom: string[]): boolean {
-  if (allowFrom.includes("*")) return true;
+  if (allowFrom.includes("*")) {
+    return true;
+  }
   const normalizedSenderId = senderId.toLowerCase();
   return allowFrom.some((entry) => {
     const normalized = entry.toLowerCase().replace(/^(zalo|zl):/i, "");
@@ -108,7 +108,9 @@ const webhookTargets = new Map<string, WebhookTarget[]>();
 
 function normalizeWebhookPath(raw: string): string {
   const trimmed = raw.trim();
-  if (!trimmed) return "/";
+  if (!trimmed) {
+    return "/";
+  }
   const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
   if (withSlash.length > 1 && withSlash.endsWith("/")) {
     return withSlash.slice(0, -1);
@@ -118,7 +120,9 @@ function normalizeWebhookPath(raw: string): string {
 
 function resolveWebhookPath(webhookPath?: string, webhookUrl?: string): string | null {
   const trimmedPath = webhookPath?.trim();
-  if (trimmedPath) return normalizeWebhookPath(trimmedPath);
+  if (trimmedPath) {
+    return normalizeWebhookPath(trimmedPath);
+  }
   if (webhookUrl?.trim()) {
     try {
       const parsed = new URL(webhookUrl);
@@ -137,9 +141,7 @@ export function registerZaloWebhookTarget(target: WebhookTarget): () => void {
   const next = [...existing, normalizedTarget];
   webhookTargets.set(key, next);
   return () => {
-    const updated = (webhookTargets.get(key) ?? []).filter(
-      (entry) => entry !== normalizedTarget,
-    );
+    const updated = (webhookTargets.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
     if (updated.length > 0) {
       webhookTargets.set(key, updated);
     } else {
@@ -155,7 +157,9 @@ export async function handleZaloWebhookRequest(
   const url = new URL(req.url ?? "/", "http://localhost");
   const path = normalizeWebhookPath(url.pathname);
   const targets = webhookTargets.get(path);
-  if (!targets || targets.length === 0) return false;
+  if (!targets || targets.length === 0) {
+    return false;
+  }
 
   if (req.method !== "POST") {
     res.statusCode = 405;
@@ -181,12 +185,11 @@ export async function handleZaloWebhookRequest(
 
   // Zalo sends updates directly as { event_name, message, ... }, not wrapped in { ok, result }
   const raw = body.value;
-  const record =
-    raw && typeof raw === "object" ? (raw as Record<string, unknown>) : null;
+  const record = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : null;
   const update: ZaloUpdate | undefined =
     record && record.ok === true && record.result
       ? (record.result as ZaloUpdate)
-      : (record as ZaloUpdate | null) ?? undefined;
+      : ((record as ZaloUpdate | null) ?? undefined);
 
   if (!update?.event_name) {
     res.statusCode = 400;
@@ -241,7 +244,9 @@ function startPollingLoop(params: {
   const pollTimeout = 30;
 
   const poll = async () => {
-    if (isStopped() || abortSignal.aborted) return;
+    if (isStopped() || abortSignal.aborted) {
+      return;
+    }
 
     try {
       const response = await getUpdates(token, { timeout: pollTimeout }, fetcher);
@@ -288,20 +293,13 @@ async function processUpdate(
   fetcher?: ZaloFetch,
 ): Promise<void> {
   const { event_name, message } = update;
-  if (!message) return;
+  if (!message) {
+    return;
+  }
 
   switch (event_name) {
     case "message.text.received":
-      await handleTextMessage(
-        message,
-        token,
-        account,
-        config,
-        runtime,
-        core,
-        statusSink,
-        fetcher,
-      );
+      await handleTextMessage(message, token, account, config, runtime, core, statusSink, fetcher);
       break;
     case "message.image.received":
       await handleImageMessage(
@@ -338,7 +336,9 @@ async function handleTextMessage(
   fetcher?: ZaloFetch,
 ): Promise<void> {
   const { text } = message;
-  if (!text?.trim()) return;
+  if (!text?.trim()) {
+    return;
+  }
 
   await processMessageWithPipeline({
     message,
@@ -439,10 +439,7 @@ async function processMessageWithPipeline(params: {
   const dmPolicy = account.config.dmPolicy ?? "pairing";
   const configAllowFrom = (account.config.allowFrom ?? []).map((v) => String(v));
   const rawBody = text?.trim() || (mediaPath ? "<media:image>" : "");
-  const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(
-    rawBody,
-    config,
-  );
+  const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(rawBody, config);
   const storeAllowFrom =
     !isGroup && (dmPolicy !== "open" || shouldComputeAuth)
       ? await core.channel.pairing.readAllowFromStore("zalo").catch(() => [])
@@ -453,7 +450,9 @@ async function processMessageWithPipeline(params: {
   const commandAuthorized = shouldComputeAuth
     ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
         useAccessGroups,
-        authorizers: [{ configured: effectiveAllowFrom.length > 0, allowed: senderAllowedForCommands }],
+        authorizers: [
+          { configured: effectiveAllowFrom.length > 0, allowed: senderAllowedForCommands },
+        ],
       })
     : undefined;
 
@@ -649,11 +648,7 @@ async function deliverZaloReply(params: {
 
   if (text) {
     const chunkMode = core.channel.text.resolveChunkMode(config, "zalo", accountId);
-    const chunks = core.channel.text.chunkMarkdownTextWithMode(
-      text,
-      ZALO_TEXT_LIMIT,
-      chunkMode,
-    );
+    const chunks = core.channel.text.chunkMarkdownTextWithMode(text, ZALO_TEXT_LIMIT, chunkMode);
     for (const chunk of chunks) {
       try {
         await sendMessage(token, { chat_id: chatId, text: chunk }, fetcher);
@@ -665,9 +660,7 @@ async function deliverZaloReply(params: {
   }
 }
 
-export async function monitorZaloProvider(
-  options: ZaloMonitorOptions,
-): Promise<ZaloMonitorResult> {
+export async function monitorZaloProvider(options: ZaloMonitorOptions): Promise<ZaloMonitorResult> {
   const {
     token,
     account,

package/src/monitor.webhook.test.ts

@@ -1,9 +1,7 @@
-import { createServer } from "node:http";
 import type { AddressInfo } from "node:net";
-
-import { describe, expect, it } from "vitest";
-
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import { createServer } from "node:http";
+import { describe, expect, it } from "vitest";
 import type { ResolvedZaloAccount } from "./types.js";
 import { handleZaloWebhookRequest, registerZaloWebhookTarget } from "./monitor.js";
 
@@ -16,7 +14,9 @@ async function withServer(
     server.listen(0, "127.0.0.1", () => resolve());
   });
   const address = server.address() as AddressInfo | null;
-  if (!address) throw new Error("missing server address");
+  if (!address) {
+    throw new Error("missing server address");
+  }
   try {
     await fn(`http://127.0.0.1:${address.port}`);
   } finally {
@@ -46,23 +46,26 @@ describe("handleZaloWebhookRequest", () => {
     });
 
     try {
-      await withServer(async (req, res) => {
-        const handled = await handleZaloWebhookRequest(req, res);
-        if (!handled) {
-          res.statusCode = 404;
-          res.end("not found");
-        }
-      }, async (baseUrl) => {
-        const response = await fetch(`${baseUrl}/hook`, {
-          method: "POST",
-          headers: {
-            "x-bot-api-secret-token": "secret",
-          },
-          body: "null",
-        });
+      await withServer(
+        async (req, res) => {
+          const handled = await handleZaloWebhookRequest(req, res);
+          if (!handled) {
+            res.statusCode = 404;
+            res.end("not found");
+          }
+        },
+        async (baseUrl) => {
+          const response = await fetch(`${baseUrl}/hook`, {
+            method: "POST",
+            headers: {
+              "x-bot-api-secret-token": "secret",
+            },
+            body: "null",
+          });
 
-        expect(response.status).toBe(400);
-      });
+          expect(response.status).toBe(400);
+        },
+      );
     } finally {
       unregister();
     }

package/src/onboarding.ts

@@ -10,12 +10,7 @@ import {
   normalizeAccountId,
   promptAccountId,
 } from "openclaw/plugin-sdk";
-
-import {
-  listZaloAccountIds,
-  resolveDefaultZaloAccountId,
-  resolveZaloAccount,
-} from "./accounts.js";
+import { listZaloAccountIds, resolveDefaultZaloAccountId, resolveZaloAccount } from "./accounts.js";
 
 const channel = "zalo" as const;
 
@@ -25,7 +20,8 @@ function setZaloDmPolicy(
   cfg: OpenClawConfig,
   dmPolicy: "pairing" | "allowlist" | "open" | "disabled",
 ) {
-  const allowFrom = dmPolicy === "open" ? addWildcardAllowFrom(cfg.channels?.zalo?.allowFrom) : undefined;
+  const allowFrom =
+    dmPolicy === "open" ? addWildcardAllowFrom(cfg.channels?.zalo?.allowFrom) : undefined;
   return {
     ...cfg,
     channels: {
@@ -64,17 +60,9 @@ function setZaloUpdateMode(
         },
       } as OpenClawConfig;
     }
-    const accounts = { ...(cfg.channels?.zalo?.accounts ?? {}) } as Record<
-      string,
-      Record<string, unknown>
-    >;
+    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;
+    const { webhookUrl: _url, webhookSecret: _secret, webhookPath: _path, ...rest } = existing;
     accounts[accountId] = rest;
     return {
       ...cfg,
@@ -103,12 +91,9 @@ function setZaloUpdateMode(
     } as OpenClawConfig;
   }
 
-  const accounts = { ...(cfg.channels?.zalo?.accounts ?? {}) } as Record<
-    string,
-    Record<string, unknown>
-  >;
+  const accounts = { ...cfg.channels?.zalo?.accounts } as Record<string, Record<string, unknown>>;
   accounts[accountId] = {
-    ...(accounts[accountId] ?? {}),
+    ...accounts[accountId],
     webhookUrl,
     webhookSecret,
     webhookPath,
@@ -152,8 +137,12 @@ async function promptZaloAllowFrom(params: {
     initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
     validate: (value) => {
       const raw = String(value ?? "").trim();
-      if (!raw) return "Required";
-      if (!/^\d+$/.test(raw)) return "Use a numeric Zalo user id";
+      if (!raw) {
+        return "Required";
+      }
+      if (!/^\d+$/.test(raw)) {
+        return "Use a numeric Zalo user id";
+      }
       return undefined;
     },
   });
@@ -187,9 +176,9 @@ async function promptZaloAllowFrom(params: {
         ...cfg.channels?.zalo,
         enabled: true,
         accounts: {
-          ...(cfg.channels?.zalo?.accounts ?? {}),
+          ...cfg.channels?.zalo?.accounts,
           [accountId]: {
-            ...(cfg.channels?.zalo?.accounts?.[accountId] ?? {}),
+            ...cfg.channels?.zalo?.accounts?.[accountId],
             enabled: cfg.channels?.zalo?.accounts?.[accountId]?.enabled ?? true,
             dmPolicy: "allowlist",
             allowFrom: unique,
@@ -206,14 +195,14 @@ const dmPolicy: ChannelOnboardingDmPolicy = {
   policyKey: "channels.zalo.dmPolicy",
   allowFromKey: "channels.zalo.allowFrom",
   getCurrent: (cfg) => (cfg.channels?.zalo?.dmPolicy ?? "pairing") as "pairing",
-  setPolicy: (cfg, policy) => setZaloDmPolicy(cfg as OpenClawConfig, policy),
+  setPolicy: (cfg, policy) => setZaloDmPolicy(cfg, policy),
   promptAllowFrom: async ({ cfg, prompter, accountId }) => {
     const id =
       accountId && normalizeAccountId(accountId)
-        ? normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID
-        : resolveDefaultZaloAccountId(cfg as OpenClawConfig);
+        ? (normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID)
+        : resolveDefaultZaloAccountId(cfg);
     return promptZaloAllowFrom({
-      cfg: cfg as OpenClawConfig,
+      cfg: cfg,
       prompter,
       accountId: id,
     });
@@ -224,8 +213,8 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
   channel,
   dmPolicy,
   getStatus: async ({ cfg }) => {
-    const configured = listZaloAccountIds(cfg as OpenClawConfig).some((accountId) =>
-      Boolean(resolveZaloAccount({ cfg: cfg as OpenClawConfig, accountId }).token),
+    const configured = listZaloAccountIds(cfg).some((accountId) =>
+      Boolean(resolveZaloAccount({ cfg: cfg, accountId }).token),
     );
     return {
       channel,
@@ -235,15 +224,19 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
       quickstartScore: configured ? 1 : 10,
     };
   },
-  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds, forceAllowFrom }) => {
+  configure: async ({
+    cfg,
+    prompter,
+    accountOverrides,
+    shouldPromptAccountIds,
+    forceAllowFrom,
+  }) => {
     const zaloOverride = accountOverrides.zalo?.trim();
-    const defaultZaloAccountId = resolveDefaultZaloAccountId(cfg as OpenClawConfig);
-    let zaloAccountId = zaloOverride
-      ? normalizeAccountId(zaloOverride)
-      : defaultZaloAccountId;
+    const defaultZaloAccountId = resolveDefaultZaloAccountId(cfg);
+    let zaloAccountId = zaloOverride ? normalizeAccountId(zaloOverride) : defaultZaloAccountId;
     if (shouldPromptAccountIds && !zaloOverride) {
       zaloAccountId = await promptAccountId({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         prompter,
         label: "Zalo",
         currentId: zaloAccountId,
@@ -252,7 +245,7 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
       });
     }
 
-    let next = cfg as OpenClawConfig;
+    let next = cfg;
     const resolvedAccount = resolveZaloAccount({ cfg: next, accountId: zaloAccountId });
     const accountConfigured = Boolean(resolvedAccount.token);
     const allowEnv = zaloAccountId === DEFAULT_ACCOUNT_ID;
@@ -333,9 +326,9 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
               ...next.channels?.zalo,
               enabled: true,
               accounts: {
-                ...(next.channels?.zalo?.accounts ?? {}),
+                ...next.channels?.zalo?.accounts,
                 [zaloAccountId]: {
-                  ...(next.channels?.zalo?.accounts?.[zaloAccountId] ?? {}),
+                  ...next.channels?.zalo?.accounts?.[zaloAccountId],
                   enabled: true,
                   botToken: token,
                 },
@@ -354,7 +347,8 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
       const webhookUrl = String(
         await prompter.text({
           message: "Webhook URL (https://...) ",
-          validate: (value) => (value?.trim()?.startsWith("https://") ? undefined : "HTTPS URL required"),
+          validate: (value) =>
+            value?.trim()?.startsWith("https://") ? undefined : "HTTPS URL required",
         }),
       ).trim();
       const defaultPath = (() => {
@@ -369,7 +363,9 @@ export const zaloOnboardingAdapter: ChannelOnboardingAdapter = {
           message: "Webhook secret (8-256 chars)",
           validate: (value) => {
             const raw = String(value ?? "");
-            if (raw.length < 8 || raw.length > 256) return "8-256 chars";
+            if (raw.length < 8 || raw.length > 256) {
+              return "8-256 chars";
+            }
             return undefined;
           },
         }),

package/src/proxy.ts

@@ -1,18 +1,21 @@
-import { ProxyAgent, fetch as undiciFetch } from "undici";
 import type { Dispatcher } from "undici";
-
+import { ProxyAgent, fetch as undiciFetch } from "undici";
 import type { ZaloFetch } from "./api.js";
 
 const proxyCache = new Map<string, ZaloFetch>();
 
 export function resolveZaloProxyFetch(proxyUrl?: string | null): ZaloFetch | undefined {
   const trimmed = proxyUrl?.trim();
-  if (!trimmed) return undefined;
+  if (!trimmed) {
+    return undefined;
+  }
   const cached = proxyCache.get(trimmed);
-  if (cached) return cached;
+  if (cached) {
+    return cached;
+  }
   const agent = new ProxyAgent(trimmed);
   const fetcher: ZaloFetch = (input, init) =>
-    undiciFetch(input, { ...(init ?? {}), dispatcher: agent as Dispatcher });
+    undiciFetch(input, { ...init, dispatcher: agent as Dispatcher });
   proxyCache.set(trimmed, fetcher);
   return fetcher;
 }

package/src/send.ts

@@ -1,8 +1,7 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
 import type { ZaloFetch } from "./api.js";
-import { sendMessage, sendPhoto } from "./api.js";
 import { resolveZaloAccount } from "./accounts.js";
+import { sendMessage, sendPhoto } from "./api.js";
 import { resolveZaloProxyFetch } from "./proxy.js";
 import { resolveZaloToken } from "./token.js";
 
@@ -65,10 +64,14 @@ export async function sendMessageZalo(
   }
 
   try {
-    const response = await sendMessage(token, {
-      chat_id: chatId.trim(),
-      text: text.slice(0, 2000),
-    }, fetcher);
+    const response = await sendMessage(
+      token,
+      {
+        chat_id: chatId.trim(),
+        text: text.slice(0, 2000),
+      },
+      fetcher,
+    );
 
     if (response.ok && response.result) {
       return { ok: true, messageId: response.result.message_id };
@@ -100,11 +103,15 @@ export async function sendPhotoZalo(
   }
 
   try {
-    const response = await sendPhoto(token, {
-      chat_id: chatId.trim(),
-      photo: photoUrl.trim(),
-      caption: options.caption?.slice(0, 2000),
-    }, fetcher);
+    const response = await sendPhoto(
+      token,
+      {
+        chat_id: chatId.trim(),
+        photo: photoUrl.trim(),
+        caption: options.caption?.slice(0, 2000),
+      },
+      fetcher,
+    );
 
     if (response.ok && response.result) {
       return { ok: true, messageId: response.result.message_id };

package/src/status-issues.ts

@@ -14,7 +14,9 @@ const asString = (value: unknown): string | undefined =>
   typeof value === "string" ? value : typeof value === "number" ? String(value) : undefined;
 
 function readZaloAccountStatus(value: ChannelAccountSnapshot): ZaloAccountStatus | null {
-  if (!isRecord(value)) return null;
+  if (!isRecord(value)) {
+    return null;
+  }
   return {
     accountId: value.accountId,
     enabled: value.enabled,
@@ -23,25 +25,26 @@ function readZaloAccountStatus(value: ChannelAccountSnapshot): ZaloAccountStatus
   };
 }
 
-export function collectZaloStatusIssues(
-  accounts: ChannelAccountSnapshot[],
-): ChannelStatusIssue[] {
+export function collectZaloStatusIssues(accounts: ChannelAccountSnapshot[]): ChannelStatusIssue[] {
   const issues: ChannelStatusIssue[] = [];
   for (const entry of accounts) {
     const account = readZaloAccountStatus(entry);
-    if (!account) continue;
+    if (!account) {
+      continue;
+    }
     const accountId = asString(account.accountId) ?? "default";
     const enabled = account.enabled !== false;
     const configured = account.configured === true;
-    if (!enabled || !configured) continue;
+    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.',
+        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.',
       });
     }

package/src/token.ts

@@ -1,7 +1,5 @@
 import { readFileSync } from "node:fs";
-
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
-
 import type { ZaloConfig } from "./types.js";
 
 export type ZaloTokenResolution = {
@@ -23,12 +21,16 @@ export function resolveZaloToken(
 
   if (accountConfig) {
     const token = accountConfig.botToken?.trim();
-    if (token) return { token, source: "config" };
+    if (token) {
+      return { token, source: "config" };
+    }
     const tokenFile = accountConfig.tokenFile?.trim();
     if (tokenFile) {
       try {
         const fileToken = readFileSync(tokenFile, "utf8").trim();
-        if (fileToken) return { token: fileToken, source: "configFile" };
+        if (fileToken) {
+          return { token: fileToken, source: "configFile" };
+        }
       } catch {
         // ignore read failures
       }
@@ -37,18 +39,24 @@ export function resolveZaloToken(
 
   if (isDefaultAccount) {
     const token = baseConfig?.botToken?.trim();
-    if (token) return { token, source: "config" };
+    if (token) {
+      return { token, source: "config" };
+    }
     const tokenFile = baseConfig?.tokenFile?.trim();
     if (tokenFile) {
       try {
         const fileToken = readFileSync(tokenFile, "utf8").trim();
-        if (fileToken) return { token: fileToken, source: "configFile" };
+        if (fileToken) {
+          return { token: fileToken, source: "configFile" };
+        }
       } catch {
         // ignore read failures
       }
     }
     const envToken = process.env.ZALO_BOT_TOKEN?.trim();
-    if (envToken) return { token: envToken, source: "env" };
+    if (envToken) {
+      return { token: envToken, source: "env" };
+    }
   }
 
   return { token: "", source: "none" };