@openclaw/zalouser 2026.1.29 → 2026.2.2

package/src/onboarding.ts

@@ -11,7 +11,7 @@ import {
   promptAccountId,
   promptChannelAccessConfig,
 } from "openclaw/plugin-sdk";
-
+import type { ZcaFriend, ZcaGroup } from "./types.js";
 import {
   listZalouserAccountIds,
   resolveDefaultZalouserAccountId,
@@ -19,7 +19,6 @@ import {
   checkZcaAuthenticated,
 } from "./accounts.js";
 import { runZca, runZcaInteractive, checkZcaInstalled, parseJsonOutput } from "./zca.js";
-import type { ZcaFriend, ZcaGroup } from "./types.js";
 
 const channel = "zalouser" as const;
 
@@ -28,9 +27,7 @@ function setZalouserDmPolicy(
   dmPolicy: "pairing" | "allowlist" | "open" | "disabled",
 ): OpenClawConfig {
   const allowFrom =
-    dmPolicy === "open"
-      ? addWildcardAllowFrom(cfg.channels?.zalouser?.allowFrom)
-      : undefined;
+    dmPolicy === "open" ? addWildcardAllowFrom(cfg.channels?.zalouser?.allowFrom) : undefined;
   return {
     ...cfg,
     channels: {
@@ -75,19 +72,29 @@ async function promptZalouserAllowFrom(params: {
 
   const resolveUserId = async (input: string): Promise<string | null> => {
     const trimmed = input.trim();
-    if (!trimmed) return null;
-    if (/^\d+$/.test(trimmed)) return trimmed;
+    if (!trimmed) {
+      return null;
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return trimmed;
+    }
     const ok = await checkZcaInstalled();
-    if (!ok) return null;
+    if (!ok) {
+      return null;
+    }
     const result = await runZca(["friend", "find", trimmed], {
       profile: resolved.profile,
       timeout: 15000,
     });
-    if (!result.ok) return null;
+    if (!result.ok) {
+      return null;
+    }
     const parsed = parseJsonOutput<ZcaFriend[]>(result.stdout);
     const rows = Array.isArray(parsed) ? parsed : [];
     const match = rows[0];
-    if (!match?.userId) return null;
+    if (!match?.userId) {
+      return null;
+    }
     if (rows.length > 1) {
       await prompter.note(
         `Multiple matches for "${trimmed}", using ${match.displayName ?? match.userId}.`,
@@ -142,9 +149,9 @@ async function promptZalouserAllowFrom(params: {
           ...cfg.channels?.zalouser,
           enabled: true,
           accounts: {
-            ...(cfg.channels?.zalouser?.accounts ?? {}),
+            ...cfg.channels?.zalouser?.accounts,
             [accountId]: {
-              ...(cfg.channels?.zalouser?.accounts?.[accountId] ?? {}),
+              ...cfg.channels?.zalouser?.accounts?.[accountId],
               enabled: cfg.channels?.zalouser?.accounts?.[accountId]?.enabled ?? true,
               dmPolicy: "allowlist",
               allowFrom: unique,
@@ -182,9 +189,9 @@ function setZalouserGroupPolicy(
         ...cfg.channels?.zalouser,
         enabled: true,
         accounts: {
-          ...(cfg.channels?.zalouser?.accounts ?? {}),
+          ...cfg.channels?.zalouser?.accounts,
           [accountId]: {
-            ...(cfg.channels?.zalouser?.accounts?.[accountId] ?? {}),
+            ...cfg.channels?.zalouser?.accounts?.[accountId],
             enabled: cfg.channels?.zalouser?.accounts?.[accountId]?.enabled ?? true,
             groupPolicy,
           },
@@ -221,9 +228,9 @@ function setZalouserGroupAllowlist(
         ...cfg.channels?.zalouser,
         enabled: true,
         accounts: {
-          ...(cfg.channels?.zalouser?.accounts ?? {}),
+          ...cfg.channels?.zalouser?.accounts,
           [accountId]: {
-            ...(cfg.channels?.zalouser?.accounts?.[accountId] ?? {}),
+            ...cfg.channels?.zalouser?.accounts?.[accountId],
             enabled: cfg.channels?.zalouser?.accounts?.[accountId]?.enabled ?? true,
             groups,
           },
@@ -239,15 +246,22 @@ async function resolveZalouserGroups(params: {
   entries: string[];
 }): Promise<Array<{ input: string; resolved: boolean; id?: string }>> {
   const account = resolveZalouserAccountSync({ cfg: params.cfg, accountId: params.accountId });
-  const result = await runZca(["group", "list", "-j"], { profile: account.profile, timeout: 15000 });
-  if (!result.ok) throw new Error(result.stderr || "Failed to list groups");
-  const groups = (parseJsonOutput<ZcaGroup[]>(result.stdout) ?? []).filter(
-    (group) => Boolean(group.groupId),
+  const result = await runZca(["group", "list", "-j"], {
+    profile: account.profile,
+    timeout: 15000,
+  });
+  if (!result.ok) {
+    throw new Error(result.stderr || "Failed to list groups");
+  }
+  const groups = (parseJsonOutput<ZcaGroup[]>(result.stdout) ?? []).filter((group) =>
+    Boolean(group.groupId),
   );
   const byName = new Map<string, ZcaGroup[]>();
   for (const group of groups) {
     const name = group.name?.trim().toLowerCase();
-    if (!name) continue;
+    if (!name) {
+      continue;
+    }
     const list = byName.get(name) ?? [];
     list.push(group);
     byName.set(name, list);
@@ -255,8 +269,12 @@ async function resolveZalouserGroups(params: {
 
   return params.entries.map((input) => {
     const trimmed = input.trim();
-    if (!trimmed) return { input, resolved: false };
-    if (/^\d+$/.test(trimmed)) return { input, resolved: true, id: trimmed };
+    if (!trimmed) {
+      return { input, resolved: false };
+    }
+    if (/^\d+$/.test(trimmed)) {
+      return { input, resolved: true, id: trimmed };
+    }
     const matches = byName.get(trimmed.toLowerCase()) ?? [];
     const match = matches[0];
     return match?.groupId
@@ -270,15 +288,15 @@ const dmPolicy: ChannelOnboardingDmPolicy = {
   channel,
   policyKey: "channels.zalouser.dmPolicy",
   allowFromKey: "channels.zalouser.allowFrom",
-  getCurrent: (cfg) => ((cfg as OpenClawConfig).channels?.zalouser?.dmPolicy ?? "pairing") as "pairing",
-  setPolicy: (cfg, policy) => setZalouserDmPolicy(cfg as OpenClawConfig, policy),
+  getCurrent: (cfg) => (cfg.channels?.zalouser?.dmPolicy ?? "pairing") as "pairing",
+  setPolicy: (cfg, policy) => setZalouserDmPolicy(cfg, policy),
   promptAllowFrom: async ({ cfg, prompter, accountId }) => {
     const id =
       accountId && normalizeAccountId(accountId)
-        ? normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID
-        : resolveDefaultZalouserAccountId(cfg as OpenClawConfig);
+        ? (normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID)
+        : resolveDefaultZalouserAccountId(cfg);
     return promptZalouserAllowFrom({
-      cfg: cfg as OpenClawConfig,
+      cfg: cfg,
       prompter,
       accountId: id,
     });
@@ -289,10 +307,10 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
   channel,
   dmPolicy,
   getStatus: async ({ cfg }) => {
-    const ids = listZalouserAccountIds(cfg as OpenClawConfig);
+    const ids = listZalouserAccountIds(cfg);
     let configured = false;
     for (const accountId of ids) {
-      const account = resolveZalouserAccountSync({ cfg: cfg as OpenClawConfig, accountId });
+      const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
       const isAuth = await checkZcaAuthenticated(account.profile);
       if (isAuth) {
         configured = true;
@@ -307,7 +325,13 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
       quickstartScore: configured ? 1 : 15,
     };
   },
-  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds, forceAllowFrom }) => {
+  configure: async ({
+    cfg,
+    prompter,
+    accountOverrides,
+    shouldPromptAccountIds,
+    forceAllowFrom,
+  }) => {
     // Check zca is installed
     const zcaInstalled = await checkZcaInstalled();
     if (!zcaInstalled) {
@@ -324,14 +348,12 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
     }
 
     const zalouserOverride = accountOverrides.zalouser?.trim();
-    const defaultAccountId = resolveDefaultZalouserAccountId(cfg as OpenClawConfig);
-    let accountId = zalouserOverride
-      ? normalizeAccountId(zalouserOverride)
-      : defaultAccountId;
+    const defaultAccountId = resolveDefaultZalouserAccountId(cfg);
+    let accountId = zalouserOverride ? normalizeAccountId(zalouserOverride) : defaultAccountId;
 
     if (shouldPromptAccountIds && !zalouserOverride) {
       accountId = await promptAccountId({
-        cfg: cfg as OpenClawConfig,
+        cfg: cfg,
         prompter,
         label: "Zalo Personal",
         currentId: accountId,
@@ -340,7 +362,7 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
       });
     }
 
-    let next = cfg as OpenClawConfig;
+    let next = cfg;
     const account = resolveZalouserAccountSync({ cfg: next, accountId });
     const alreadyAuthenticated = await checkZcaAuthenticated(account.profile);
 
@@ -364,10 +386,7 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
         });
 
         if (!result.ok) {
-          await prompter.note(
-            `Login failed: ${result.stderr || "Unknown error"}`,
-            "Error",
-          );
+          await prompter.note(`Login failed: ${result.stderr || "Unknown error"}`, "Error");
         } else {
           const isNowAuth = await checkZcaAuthenticated(account.profile);
           if (isNowAuth) {
@@ -408,9 +427,9 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
             ...next.channels?.zalouser,
             enabled: true,
             accounts: {
-              ...(next.channels?.zalouser?.accounts ?? {}),
+              ...next.channels?.zalouser?.accounts,
               [accountId]: {
-                ...(next.channels?.zalouser?.accounts?.[accountId] ?? {}),
+                ...next.channels?.zalouser?.accounts?.[accountId],
                 enabled: true,
                 profile: account.profile,
               },
@@ -454,10 +473,7 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = {
             const unresolved = resolved
               .filter((entry) => !entry.resolved)
               .map((entry) => entry.input);
-            keys = [
-              ...resolvedIds,
-              ...unresolved.map((entry) => entry.trim()).filter(Boolean),
-            ];
+            keys = [...resolvedIds, ...unresolved.map((entry) => entry.trim()).filter(Boolean)];
             if (resolvedIds.length > 0 || unresolved.length > 0) {
               await prompter.note(
                 [

package/src/probe.ts

@@ -1,5 +1,5 @@
-import { runZca, parseJsonOutput } from "./zca.js";
 import type { ZcaUserInfo } from "./types.js";
+import { runZca, parseJsonOutput } from "./zca.js";
 
 export interface ZalouserProbeResult {
   ok: boolean;

package/src/send.ts

@@ -34,7 +34,9 @@ export async function sendMessageZalouser(
 
   // Send text message
   const args = ["msg", "send", threadId.trim(), text.slice(0, 2000)];
-  if (options.isGroup) args.push("-g");
+  if (options.isGroup) {
+    args.push("-g");
+  }
 
   try {
     const result = await runZca(args, { profile });
@@ -79,7 +81,9 @@ async function sendMediaZalouser(
   if (options.caption) {
     args.push("-m", options.caption.slice(0, 2000));
   }
-  if (options.isGroup) args.push("-g");
+  if (options.isGroup) {
+    args.push("-g");
+  }
 
   try {
     const result = await runZca(args, { profile });
@@ -104,7 +108,9 @@ export async function sendImageZalouser(
   if (options.caption) {
     args.push("-m", options.caption.slice(0, 2000));
   }
-  if (options.isGroup) args.push("-g");
+  if (options.isGroup) {
+    args.push("-g");
+  }
 
   try {
     const result = await runZca(args, { profile });
@@ -124,7 +130,9 @@ export async function sendLinkZalouser(
 ): Promise<ZalouserSendResult> {
   const profile = options.profile || process.env.ZCA_PROFILE || "default";
   const args = ["msg", "link", threadId.trim(), url.trim()];
-  if (options.isGroup) args.push("-g");
+  if (options.isGroup) {
+    args.push("-g");
+  }
 
   try {
     const result = await runZca(args, { profile });
@@ -140,7 +148,9 @@ export async function sendLinkZalouser(
 function extractMessageId(stdout: string): string | undefined {
   // Try to extract message ID from output
   const match = stdout.match(/message[_\s]?id[:\s]+(\S+)/i);
-  if (match) return match[1];
+  if (match) {
+    return match[1];
+  }
   // Return first word if it looks like an ID
   const firstWord = stdout.trim().split(/\s+/)[0];
   if (firstWord && /^[a-zA-Z0-9_-]+$/.test(firstWord)) {

package/src/status-issues.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, it } from "vitest";
-
 import { collectZalouserStatusIssues } from "./status-issues.js";
 
 describe("collectZalouserStatusIssues", () => {

package/src/status-issues.ts

@@ -15,7 +15,9 @@ const asString = (value: unknown): string | undefined =>
   typeof value === "string" ? value : typeof value === "number" ? String(value) : undefined;
 
 function readZalouserAccountStatus(value: ChannelAccountSnapshot): ZalouserAccountStatus | null {
-  if (!isRecord(value)) return null;
+  if (!isRecord(value)) {
+    return null;
+  }
   return {
     accountId: value.accountId,
     enabled: value.enabled,
@@ -26,7 +28,9 @@ function readZalouserAccountStatus(value: ChannelAccountSnapshot): ZalouserAccou
 }
 
 function isMissingZca(lastError?: string): boolean {
-  if (!lastError) return false;
+  if (!lastError) {
+    return false;
+  }
   const lower = lastError.toLowerCase();
   return lower.includes("zca") && (lower.includes("not found") || lower.includes("enoent"));
 }
@@ -37,10 +41,14 @@ export function collectZalouserStatusIssues(
   const issues: ChannelStatusIssue[] = [];
   for (const entry of accounts) {
     const account = readZalouserAccountStatus(entry);
-    if (!account) continue;
+    if (!account) {
+      continue;
+    }
     const accountId = asString(account.accountId) ?? "default";
     const enabled = account.enabled !== false;
-    if (!enabled) continue;
+    if (!enabled) {
+      continue;
+    }
 
     const configured = account.configured === true;
     const lastError = asString(account.lastError)?.trim();

package/src/tool.ts

@@ -1,5 +1,4 @@
 import { Type } from "@sinclair/typebox";
-
 import { runZca, parseJsonOutput } from "./zca.js";
 
 const ACTIONS = ["send", "image", "link", "friends", "groups", "me", "status"] as const;
@@ -16,17 +15,18 @@ function stringEnum<T extends readonly string[]>(
 }
 
 // Tool schema - avoiding Type.Union per tool schema guardrails
-export const ZalouserToolSchema = Type.Object({
-  action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
-  threadId: Type.Optional(
-    Type.String({ description: "Thread ID for messaging" }),
-  ),
-  message: Type.Optional(Type.String({ description: "Message text" })),
-  isGroup: Type.Optional(Type.Boolean({ description: "Is group chat" })),
-  profile: Type.Optional(Type.String({ description: "Profile name" })),
-  query: Type.Optional(Type.String({ description: "Search query" })),
-  url: Type.Optional(Type.String({ description: "URL for media/link" })),
-}, { additionalProperties: false });
+export const ZalouserToolSchema = Type.Object(
+  {
+    action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
+    threadId: Type.Optional(Type.String({ description: "Thread ID for messaging" })),
+    message: Type.Optional(Type.String({ description: "Message text" })),
+    isGroup: Type.Optional(Type.Boolean({ description: "Is group chat" })),
+    profile: Type.Optional(Type.String({ description: "Profile name" })),
+    query: Type.Optional(Type.String({ description: "Search query" })),
+    url: Type.Optional(Type.String({ description: "URL for media/link" })),
+  },
+  { additionalProperties: false },
+);
 
 type ToolParams = {
   action: (typeof ACTIONS)[number];
@@ -61,7 +61,9 @@ export async function executeZalouserTool(
           throw new Error("threadId and message required for send action");
         }
         const args = ["msg", "send", params.threadId, params.message];
-        if (params.isGroup) args.push("-g");
+        if (params.isGroup) {
+          args.push("-g");
+        }
         const result = await runZca(args, { profile: params.profile });
         if (!result.ok) {
           throw new Error(result.stderr || "Failed to send message");
@@ -77,8 +79,12 @@ export async function executeZalouserTool(
           throw new Error("url required for image action");
         }
         const args = ["msg", "image", params.threadId, "-u", params.url];
-        if (params.message) args.push("-m", params.message);
-        if (params.isGroup) args.push("-g");
+        if (params.message) {
+          args.push("-m", params.message);
+        }
+        if (params.isGroup) {
+          args.push("-g");
+        }
         const result = await runZca(args, { profile: params.profile });
         if (!result.ok) {
           throw new Error(result.stderr || "Failed to send image");
@@ -91,7 +97,9 @@ export async function executeZalouserTool(
           throw new Error("threadId and url required for link action");
         }
         const args = ["msg", "link", params.threadId, params.url];
-        if (params.isGroup) args.push("-g");
+        if (params.isGroup) {
+          args.push("-g");
+        }
         const result = await runZca(args, { profile: params.profile });
         if (!result.ok) {
           throw new Error(result.stderr || "Failed to send link");
@@ -100,9 +108,7 @@ export async function executeZalouserTool(
       }
 
       case "friends": {
-        const args = params.query
-          ? ["friend", "find", params.query]
-          : ["friend", "list", "-j"];
+        const args = params.query ? ["friend", "find", params.query] : ["friend", "list", "-j"];
         const result = await runZca(args, { profile: params.profile });
         if (!result.ok) {
           throw new Error(result.stderr || "Failed to get friends");
@@ -143,10 +149,12 @@ export async function executeZalouserTool(
         });
       }
 
-      default:
+      default: {
+        params.action satisfies never;
         throw new Error(
-          `Unknown action: ${params.action}. Valid actions: send, image, link, friends, groups, me, status`,
+          `Unknown action: ${String(params.action)}. Valid actions: send, image, link, friends, groups, me, status`,
         );
+      }
     }
   } catch (err) {
     return json({

package/src/types.ts

@@ -75,7 +75,10 @@ export type ZalouserAccountConfig = {
   dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
   allowFrom?: Array<string | number>;
   groupPolicy?: "open" | "allowlist" | "disabled";
-  groups?: Record<string, { allow?: boolean; enabled?: boolean; tools?: { allow?: string[]; deny?: string[] } }>;
+  groups?: Record<
+    string,
+    { allow?: boolean; enabled?: boolean; tools?: { allow?: string[]; deny?: string[] } }
+  >;
   messagePrefix?: string;
 };
 
@@ -87,7 +90,10 @@ export type ZalouserConfig = {
   dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
   allowFrom?: Array<string | number>;
   groupPolicy?: "open" | "allowlist" | "disabled";
-  groups?: Record<string, { allow?: boolean; enabled?: boolean; tools?: { allow?: string[]; deny?: string[] } }>;
+  groups?: Record<
+    string,
+    { allow?: boolean; enabled?: boolean; tools?: { allow?: string[]; deny?: string[] } }
+  >;
   messagePrefix?: string;
   accounts?: Record<string, ZalouserAccountConfig>;
 };

package/src/zca.ts

@@ -1,5 +1,4 @@
 import { spawn, type SpawnOptions } from "node:child_process";
-
 import type { ZcaResult, ZcaRunOptions } from "./types.js";
 
 const ZCA_BINARY = "zca";
@@ -16,10 +15,7 @@ function buildArgs(args: string[], options?: ZcaRunOptions): string[] {
   return result;
 }
 
-export async function runZca(
-  args: string[],
-  options?: ZcaRunOptions,
-): Promise<ZcaResult> {
+export async function runZca(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
   const fullArgs = buildArgs(args, options);
   const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
 
@@ -79,10 +75,7 @@ export async function runZca(
   });
 }
 
-export function runZcaInteractive(
-  args: string[],
-  options?: ZcaRunOptions,
-): Promise<ZcaResult> {
+export function runZcaInteractive(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
   const fullArgs = buildArgs(args, options);
 
   return new Promise((resolve) => {
@@ -115,6 +108,7 @@ export function runZcaInteractive(
 }
 
 function stripAnsi(str: string): string {
+  // oxlint-disable-next-line no-control-regex
   return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 }