@openclaw/zalouser 2026.3.7 → 2026.3.8-beta.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2026.3.8-beta.1
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.3.8
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.3.7
 
 ### Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/zalouser",
-  "version": "2026.3.7",
+  "version": "2026.3.8-beta.1",
   "description": "OpenClaw Zalo Personal Account plugin via native zca-js integration",
   "type": "module",
   "dependencies": {
@@ -29,6 +29,11 @@
       "npmSpec": "@openclaw/zalouser",
       "localPath": "extensions/zalouser",
       "defaultChoice": "npm"
+    },
+    "releaseChecks": {
+      "rootDependencyMirrorAllowlist": [
+        "zca-js"
+      ]
     }
   }
 }

package/src/channel.directory.test.ts

@@ -0,0 +1,72 @@
+import type { RuntimeEnv } from "openclaw/plugin-sdk/zalouser";
+import { describe, expect, it, vi } from "vitest";
+
+const listZaloGroupMembersMock = vi.hoisted(() => vi.fn(async () => []));
+
+vi.mock("./zalo-js.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    listZaloGroupMembers: listZaloGroupMembersMock,
+  };
+});
+
+vi.mock("./accounts.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    resolveZalouserAccountSync: () => ({
+      accountId: "default",
+      profile: "default",
+      name: "test",
+      enabled: true,
+      authenticated: true,
+      config: {},
+    }),
+  };
+});
+
+import { zalouserPlugin } from "./channel.js";
+
+const runtimeStub: RuntimeEnv = {
+  log: vi.fn(),
+  error: vi.fn(),
+  exit: ((code: number): never => {
+    throw new Error(`exit ${code}`);
+  }) as RuntimeEnv["exit"],
+};
+
+describe("zalouser directory group members", () => {
+  it("accepts prefixed group ids from directory groups list output", async () => {
+    await zalouserPlugin.directory!.listGroupMembers!({
+      cfg: {},
+      accountId: "default",
+      groupId: "group:1471383327500481391",
+      runtime: runtimeStub,
+    });
+
+    expect(listZaloGroupMembersMock).toHaveBeenCalledWith("default", "1471383327500481391");
+  });
+
+  it("keeps backward compatibility for raw group ids", async () => {
+    await zalouserPlugin.directory!.listGroupMembers!({
+      cfg: {},
+      accountId: "default",
+      groupId: "1471383327500481391",
+      runtime: runtimeStub,
+    });
+
+    expect(listZaloGroupMembersMock).toHaveBeenCalledWith("default", "1471383327500481391");
+  });
+
+  it("accepts provider-native g- group ids without stripping the prefix", async () => {
+    await zalouserPlugin.directory!.listGroupMembers!({
+      cfg: {},
+      accountId: "default",
+      groupId: "g-1471383327500481391",
+      runtime: runtimeStub,
+    });
+
+    expect(listZaloGroupMembersMock).toHaveBeenCalledWith("default", "g-1471383327500481391");
+  });
+});

package/src/channel.sendpayload.test.ts

@@ -24,7 +24,7 @@ vi.mock("./accounts.js", async (importOriginal) => {
 function baseCtx(payload: ReplyPayload) {
   return {
     cfg: {},
-    to: "987654321",
+    to: "user:987654321",
     text: "",
     payload,
   };
@@ -49,6 +49,22 @@ describe("zalouserPlugin outbound sendPayload", () => {
     expect(result).toMatchObject({ channel: "zalouser", messageId: "zlu-t1" });
   });
 
+  it("group target delegates with isGroup=true and stripped threadId", async () => {
+    mockedSend.mockResolvedValue({ ok: true, messageId: "zlu-g1" });
+
+    const result = await zalouserPlugin.outbound!.sendPayload!({
+      ...baseCtx({ text: "hello group" }),
+      to: "group:1471383327500481391",
+    });
+
+    expect(mockedSend).toHaveBeenCalledWith(
+      "1471383327500481391",
+      "hello group",
+      expect.objectContaining({ isGroup: true }),
+    );
+    expect(result).toMatchObject({ channel: "zalouser", messageId: "zlu-g1" });
+  });
+
   it("single media delegates to sendMedia", async () => {
     mockedSend.mockResolvedValue({ ok: true, messageId: "zlu-m1" });
 
@@ -64,6 +80,38 @@ describe("zalouserPlugin outbound sendPayload", () => {
     expect(result).toMatchObject({ channel: "zalouser" });
   });
 
+  it("treats bare numeric targets as direct chats for backward compatibility", async () => {
+    mockedSend.mockResolvedValue({ ok: true, messageId: "zlu-d1" });
+
+    const result = await zalouserPlugin.outbound!.sendPayload!({
+      ...baseCtx({ text: "hello" }),
+      to: "987654321",
+    });
+
+    expect(mockedSend).toHaveBeenCalledWith(
+      "987654321",
+      "hello",
+      expect.objectContaining({ isGroup: false }),
+    );
+    expect(result).toMatchObject({ channel: "zalouser", messageId: "zlu-d1" });
+  });
+
+  it("preserves provider-native group ids when sending to raw g- targets", async () => {
+    mockedSend.mockResolvedValue({ ok: true, messageId: "zlu-g-native" });
+
+    const result = await zalouserPlugin.outbound!.sendPayload!({
+      ...baseCtx({ text: "hello native group" }),
+      to: "g-1471383327500481391",
+    });
+
+    expect(mockedSend).toHaveBeenCalledWith(
+      "g-1471383327500481391",
+      "hello native group",
+      expect.objectContaining({ isGroup: true }),
+    );
+    expect(result).toMatchObject({ channel: "zalouser", messageId: "zlu-g-native" });
+  });
+
   it("multi-media iterates URLs with caption on first", async () => {
     mockedSend
       .mockResolvedValueOnce({ ok: true, messageId: "zlu-1" })
@@ -115,3 +163,31 @@ describe("zalouserPlugin outbound sendPayload", () => {
     expect(result).toMatchObject({ channel: "zalouser" });
   });
 });
+
+describe("zalouserPlugin messaging target normalization", () => {
+  it("normalizes user/group aliases to canonical targets", () => {
+    const normalize = zalouserPlugin.messaging?.normalizeTarget;
+    expect(normalize).toBeTypeOf("function");
+    if (!normalize) {
+      return;
+    }
+    expect(normalize("zlu:g:30003")).toBe("group:30003");
+    expect(normalize("zalouser:u:20002")).toBe("user:20002");
+    expect(normalize("zlu:g-30003")).toBe("group:g-30003");
+    expect(normalize("zalouser:u-20002")).toBe("user:u-20002");
+    expect(normalize("20002")).toBe("20002");
+  });
+
+  it("treats canonical and provider-native user/group targets as ids", () => {
+    const looksLikeId = zalouserPlugin.messaging?.targetResolver?.looksLikeId;
+    expect(looksLikeId).toBeTypeOf("function");
+    if (!looksLikeId) {
+      return;
+    }
+    expect(looksLikeId("user:20002")).toBe(true);
+    expect(looksLikeId("group:30003")).toBe(true);
+    expect(looksLikeId("g-30003")).toBe(true);
+    expect(looksLikeId("u-20002")).toBe(true);
+    expect(looksLikeId("Alice Nguyen")).toBe(false);
+  });
+});

package/src/channel.ts

@@ -66,6 +66,97 @@ const meta = {
   quickstartAllowFrom: true,
 };
 
+function stripZalouserTargetPrefix(raw: string): string {
+  return raw
+    .trim()
+    .replace(/^(zalouser|zlu):/i, "")
+    .trim();
+}
+
+function normalizePrefixedTarget(raw: string): string | undefined {
+  const trimmed = stripZalouserTargetPrefix(raw);
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("group:")) {
+    const id = trimmed.slice("group:".length).trim();
+    return id ? `group:${id}` : undefined;
+  }
+  if (lower.startsWith("g:")) {
+    const id = trimmed.slice("g:".length).trim();
+    return id ? `group:${id}` : undefined;
+  }
+  if (lower.startsWith("user:")) {
+    const id = trimmed.slice("user:".length).trim();
+    return id ? `user:${id}` : undefined;
+  }
+  if (lower.startsWith("dm:")) {
+    const id = trimmed.slice("dm:".length).trim();
+    return id ? `user:${id}` : undefined;
+  }
+  if (lower.startsWith("u:")) {
+    const id = trimmed.slice("u:".length).trim();
+    return id ? `user:${id}` : undefined;
+  }
+  if (/^g-\S+$/i.test(trimmed)) {
+    return `group:${trimmed}`;
+  }
+  if (/^u-\S+$/i.test(trimmed)) {
+    return `user:${trimmed}`;
+  }
+
+  return trimmed;
+}
+
+function parseZalouserOutboundTarget(raw: string): {
+  threadId: string;
+  isGroup: boolean;
+} {
+  const normalized = normalizePrefixedTarget(raw);
+  if (!normalized) {
+    throw new Error("Zalouser target is required");
+  }
+  const lowered = normalized.toLowerCase();
+  if (lowered.startsWith("group:")) {
+    const threadId = normalized.slice("group:".length).trim();
+    if (!threadId) {
+      throw new Error("Zalouser group target is missing group id");
+    }
+    return { threadId, isGroup: true };
+  }
+  if (lowered.startsWith("user:")) {
+    const threadId = normalized.slice("user:".length).trim();
+    if (!threadId) {
+      throw new Error("Zalouser user target is missing user id");
+    }
+    return { threadId, isGroup: false };
+  }
+  // Backward-compatible fallback for bare IDs.
+  // Group sends should use explicit `group:<id>` targets.
+  return { threadId: normalized, isGroup: false };
+}
+
+function parseZalouserDirectoryGroupId(raw: string): string {
+  const normalized = normalizePrefixedTarget(raw);
+  if (!normalized) {
+    throw new Error("Zalouser group target is required");
+  }
+  const lowered = normalized.toLowerCase();
+  if (lowered.startsWith("group:")) {
+    const groupId = normalized.slice("group:".length).trim();
+    if (!groupId) {
+      throw new Error("Zalouser group target is missing group id");
+    }
+    return groupId;
+  }
+  if (lowered.startsWith("user:")) {
+    throw new Error("Zalouser group members lookup requires a group target (group:<id>)");
+  }
+  return normalized;
+}
+
 function resolveZalouserQrProfile(accountId?: string | null): string {
   const normalized = normalizeAccountId(accountId);
   if (!normalized || normalized === DEFAULT_ACCOUNT_ID) {
@@ -261,6 +352,8 @@ export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount> = {
           "name",
           "dmPolicy",
           "allowFrom",
+          "historyLimit",
+          "groupAllowFrom",
           "groupPolicy",
           "groups",
           "messagePrefix",
@@ -333,16 +426,19 @@ export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount> = {
     },
   },
   messaging: {
-    normalizeTarget: (raw) => {
-      const trimmed = raw?.trim();
-      if (!trimmed) {
-        return undefined;
-      }
-      return trimmed.replace(/^(zalouser|zlu):/i, "");
-    },
+    normalizeTarget: (raw) => normalizePrefixedTarget(raw),
     targetResolver: {
-      looksLikeId: isNumericTargetId,
-      hint: "<threadId>",
+      looksLikeId: (raw) => {
+        const normalized = normalizePrefixedTarget(raw);
+        if (!normalized) {
+          return false;
+        }
+        if (/^group:[^\s]+$/i.test(normalized) || /^user:[^\s]+$/i.test(normalized)) {
+          return true;
+        }
+        return isNumericTargetId(normalized);
+      },
+      hint: "<user:id|group:id>",
     },
   },
   directory: {
@@ -377,7 +473,7 @@ export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount> = {
       const groups = await listZaloGroupsMatching(account.profile, query);
       const rows = groups.map((group) =>
         mapGroup({
-          id: String(group.groupId),
+          id: `group:${String(group.groupId)}`,
           name: group.name ?? null,
           raw: group,
         }),
@@ -386,7 +482,8 @@ export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount> = {
     },
     listGroupMembers: async ({ cfg, accountId, groupId, limit }) => {
       const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
-      const members = await listZaloGroupMembers(account.profile, groupId);
+      const normalizedGroupId = parseZalouserDirectoryGroupId(groupId);
+      const members = await listZaloGroupMembers(account.profile, normalizedGroupId);
       const rows = members.map((member) =>
         mapUser({
           id: member.userId,
@@ -511,13 +608,19 @@ export const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount> = {
       }),
     sendText: async ({ to, text, accountId, cfg }) => {
       const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
-      const result = await sendMessageZalouser(to, text, { profile: account.profile });
+      const target = parseZalouserOutboundTarget(to);
+      const result = await sendMessageZalouser(target.threadId, text, {
+        profile: account.profile,
+        isGroup: target.isGroup,
+      });
       return buildChannelSendResult("zalouser", result);
     },
     sendMedia: async ({ to, text, mediaUrl, accountId, cfg, mediaLocalRoots }) => {
       const account = resolveZalouserAccountSync({ cfg: cfg, accountId });
-      const result = await sendMessageZalouser(to, text, {
+      const target = parseZalouserOutboundTarget(to);
+      const result = await sendMessageZalouser(target.threadId, text, {
         profile: account.profile,
+        isGroup: target.isGroup,
         mediaUrl,
         mediaLocalRoots,
       });

package/src/config-schema.ts

@@ -1,8 +1,10 @@
+import {
+  AllowFromEntrySchema,
+  buildCatchallMultiAccountChannelSchema,
+} from "openclaw/plugin-sdk/compat";
 import { MarkdownConfigSchema, ToolPolicySchema } from "openclaw/plugin-sdk/zalouser";
 import { z } from "zod";
 
-const allowFromEntry = z.union([z.string(), z.number()]);
-
 const groupConfigSchema = z.object({
   allow: z.boolean().optional(),
   enabled: z.boolean().optional(),
@@ -16,14 +18,13 @@ const zalouserAccountSchema = z.object({
   markdown: MarkdownConfigSchema,
   profile: z.string().optional(),
   dmPolicy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
-  allowFrom: z.array(allowFromEntry).optional(),
+  allowFrom: z.array(AllowFromEntrySchema).optional(),
+  historyLimit: z.number().int().min(0).optional(),
+  groupAllowFrom: z.array(AllowFromEntrySchema).optional(),
   groupPolicy: z.enum(["disabled", "allowlist", "open"]).optional(),
   groups: z.object({}).catchall(groupConfigSchema).optional(),
   messagePrefix: z.string().optional(),
   responsePrefix: z.string().optional(),
 });
 
-export const ZalouserConfigSchema = zalouserAccountSchema.extend({
-  accounts: z.object({}).catchall(zalouserAccountSchema).optional(),
-  defaultAccount: z.string().optional(),
-});
+export const ZalouserConfigSchema = buildCatchallMultiAccountChannelSchema(zalouserAccountSchema);