@openclaw/zalouser 2026.5.2 → 2026.5.3-beta.2

package/src/tool.test.ts

@@ -1,212 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { sendImageZalouser, sendLinkZalouser, sendMessageZalouser } from "./send.js";
-import { createZalouserTool, executeZalouserTool } from "./tool.js";
-import {
-  checkZaloAuthenticated,
-  getZaloUserInfo,
-  listZaloFriendsMatching,
-  listZaloGroupsMatching,
-} from "./zalo-js.js";
-
-vi.mock("./send.js", () => ({
-  sendMessageZalouser: vi.fn(),
-  sendImageZalouser: vi.fn(),
-  sendLinkZalouser: vi.fn(),
-  sendReactionZalouser: vi.fn(),
-}));
-
-vi.mock("./zalo-js.js", () => ({
-  checkZaloAuthenticated: vi.fn(),
-  getZaloUserInfo: vi.fn(),
-  listZaloFriendsMatching: vi.fn(),
-  listZaloGroupsMatching: vi.fn(),
-}));
-
-const mockSendMessage = vi.mocked(sendMessageZalouser);
-const mockSendImage = vi.mocked(sendImageZalouser);
-const mockSendLink = vi.mocked(sendLinkZalouser);
-const mockCheckAuth = vi.mocked(checkZaloAuthenticated);
-const mockGetUserInfo = vi.mocked(getZaloUserInfo);
-const mockListFriends = vi.mocked(listZaloFriendsMatching);
-const mockListGroups = vi.mocked(listZaloGroupsMatching);
-
-function extractDetails(result: { content?: Array<{ type: string; text?: string }> }): unknown {
-  const text = result.content?.[0]?.text ?? "{}";
-  return JSON.parse(text) as unknown;
-}
-
-describe("executeZalouserTool", () => {
-  beforeEach(() => {
-    mockSendMessage.mockReset();
-    mockSendImage.mockReset();
-    mockSendLink.mockReset();
-    mockCheckAuth.mockReset();
-    mockGetUserInfo.mockReset();
-    mockListFriends.mockReset();
-    mockListGroups.mockReset();
-  });
-
-  it("returns error when send action is missing required fields", async () => {
-    const result = await executeZalouserTool("tool-1", { action: "send" });
-    expect(extractDetails(result)).toEqual({
-      error: "threadId and message required for send action",
-    });
-  });
-
-  it("sends text message for send action", async () => {
-    mockSendMessage.mockResolvedValueOnce({ ok: true, messageId: "m-1" });
-    const result = await executeZalouserTool("tool-1", {
-      action: "send",
-      threadId: "t-1",
-      message: "hello",
-      profile: "work",
-      isGroup: true,
-    });
-    expect(mockSendMessage).toHaveBeenCalledWith("t-1", "hello", {
-      profile: "work",
-      isGroup: true,
-    });
-    expect(extractDetails(result)).toEqual({ success: true, messageId: "m-1" });
-  });
-
-  it("defaults send routing from ambient deliveryContext target", async () => {
-    mockSendMessage.mockResolvedValueOnce({ ok: true, messageId: "m-ambient" });
-    const tool = createZalouserTool({
-      deliveryContext: {
-        channel: "zalouser",
-        to: "zalouser:g-ambient",
-      },
-    });
-
-    const result = await tool.execute("tool-1", {
-      action: "send",
-      message: "hello",
-    });
-
-    expect(mockSendMessage).toHaveBeenCalledWith("g-ambient", "hello", {
-      profile: undefined,
-      isGroup: true,
-    });
-    expect(extractDetails(result)).toEqual({ success: true, messageId: "m-ambient" });
-  });
-
-  it("keeps explicit threadId over ambient delivery defaults", async () => {
-    mockSendMessage.mockResolvedValueOnce({ ok: true, messageId: "m-explicit" });
-    const tool = createZalouserTool({
-      deliveryContext: {
-        channel: "zalouser",
-        to: "zalouser:g-ambient",
-      },
-    });
-
-    await tool.execute("tool-1", {
-      action: "send",
-      threadId: "u-explicit",
-      message: "hello",
-      isGroup: false,
-    });
-
-    expect(mockSendMessage).toHaveBeenCalledWith("u-explicit", "hello", {
-      profile: undefined,
-      isGroup: false,
-    });
-  });
-
-  it("does not route send actions from foreign ambient thread defaults", async () => {
-    const tool = createZalouserTool({
-      deliveryContext: {
-        channel: "slack",
-        to: "channel:C123",
-        threadId: "1710000000.000100",
-      },
-    });
-
-    const result = await tool.execute("tool-1", {
-      action: "send",
-      message: "hello",
-    });
-
-    expect(mockSendMessage).not.toHaveBeenCalled();
-    expect(extractDetails(result)).toEqual({
-      error: "threadId and message required for send action",
-    });
-  });
-
-  it("returns tool error when send action fails", async () => {
-    mockSendMessage.mockResolvedValueOnce({ ok: false, error: "blocked" });
-    const result = await executeZalouserTool("tool-1", {
-      action: "send",
-      threadId: "t-1",
-      message: "hello",
-    });
-    expect(extractDetails(result)).toEqual({ error: "blocked" });
-  });
-
-  it("routes image and link actions to correct helpers", async () => {
-    mockSendImage.mockResolvedValueOnce({ ok: true, messageId: "img-1" });
-    const imageResult = await executeZalouserTool("tool-1", {
-      action: "image",
-      threadId: "g-1",
-      url: "https://example.com/image.jpg",
-      message: "caption",
-      isGroup: true,
-    });
-    expect(mockSendImage).toHaveBeenCalledWith("g-1", "https://example.com/image.jpg", {
-      profile: undefined,
-      caption: "caption",
-      isGroup: true,
-    });
-    expect(extractDetails(imageResult)).toEqual({ success: true, messageId: "img-1" });
-
-    mockSendLink.mockResolvedValueOnce({ ok: true, messageId: "lnk-1" });
-    const linkResult = await executeZalouserTool("tool-1", {
-      action: "link",
-      threadId: "t-2",
-      url: "https://openclaw.ai",
-      message: "read this",
-    });
-    expect(mockSendLink).toHaveBeenCalledWith("t-2", "https://openclaw.ai", {
-      profile: undefined,
-      caption: "read this",
-      isGroup: undefined,
-    });
-    expect(extractDetails(linkResult)).toEqual({ success: true, messageId: "lnk-1" });
-  });
-
-  it("returns friends/groups lists", async () => {
-    mockListFriends.mockResolvedValueOnce([{ userId: "1", displayName: "Alice" }]);
-    mockListGroups.mockResolvedValueOnce([{ groupId: "2", name: "Work" }]);
-
-    const friends = await executeZalouserTool("tool-1", {
-      action: "friends",
-      profile: "work",
-      query: "ali",
-    });
-    expect(mockListFriends).toHaveBeenCalledWith("work", "ali");
-    expect(extractDetails(friends)).toEqual([{ userId: "1", displayName: "Alice" }]);
-
-    const groups = await executeZalouserTool("tool-1", {
-      action: "groups",
-      profile: "work",
-      query: "wrk",
-    });
-    expect(mockListGroups).toHaveBeenCalledWith("work", "wrk");
-    expect(extractDetails(groups)).toEqual([{ groupId: "2", name: "Work" }]);
-  });
-
-  it("reports me + status actions", async () => {
-    mockGetUserInfo.mockResolvedValueOnce({ userId: "7", displayName: "Me" });
-    mockCheckAuth.mockResolvedValueOnce(true);
-
-    const me = await executeZalouserTool("tool-1", { action: "me", profile: "work" });
-    expect(mockGetUserInfo).toHaveBeenCalledWith("work");
-    expect(extractDetails(me)).toEqual({ userId: "7", displayName: "Me" });
-
-    const status = await executeZalouserTool("tool-1", { action: "status", profile: "work" });
-    expect(mockCheckAuth).toHaveBeenCalledWith("work");
-    expect(extractDetails(status)).toEqual({
-      authenticated: true,
-      output: "authenticated",
-    });
-  });
-});

package/src/tool.ts

@@ -1,210 +0,0 @@
-import type { AnyAgentTool, OpenClawPluginToolContext } from "openclaw/plugin-sdk/core";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { Type } from "typebox";
-import { sendImageZalouser, sendLinkZalouser, sendMessageZalouser } from "./send.js";
-import { parseZalouserOutboundTarget } from "./session-route.js";
-import {
-  checkZaloAuthenticated,
-  getZaloUserInfo,
-  listZaloFriendsMatching,
-  listZaloGroupsMatching,
-} from "./zalo-js.js";
-
-const ACTIONS = ["send", "image", "link", "friends", "groups", "me", "status"] as const;
-
-type AgentToolResult = {
-  content: Array<{ type: "text"; text: string }>;
-  details: unknown;
-};
-
-function stringEnum<T extends readonly string[]>(
-  values: T,
-  options: { description?: string } = {},
-) {
-  return Type.Unsafe<T[number]>({
-    type: "string",
-    enum: [...values],
-    ...options,
-  });
-}
-
-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];
-  threadId?: string;
-  message?: string;
-  isGroup?: boolean;
-  profile?: string;
-  query?: string;
-  url?: string;
-};
-
-type ZalouserToolContext = Pick<OpenClawPluginToolContext, "deliveryContext">;
-
-function json(payload: unknown): AgentToolResult {
-  return {
-    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
-    details: payload,
-  };
-}
-
-function resolveAmbientZalouserTarget(context?: ZalouserToolContext): {
-  threadId?: string;
-  isGroup?: boolean;
-} {
-  const deliveryContext = context?.deliveryContext;
-  const rawTarget = deliveryContext?.to;
-  if (
-    (deliveryContext?.channel === undefined || deliveryContext.channel === "zalouser") &&
-    typeof rawTarget === "string" &&
-    rawTarget.trim()
-  ) {
-    try {
-      return parseZalouserOutboundTarget(rawTarget);
-    } catch {
-      // Ignore unrelated delivery targets; explicit tool params still win.
-    }
-  }
-  if (deliveryContext?.channel && deliveryContext.channel !== "zalouser") {
-    return {};
-  }
-  const ambientThreadId = deliveryContext?.threadId;
-  if (typeof ambientThreadId === "string" && ambientThreadId.trim()) {
-    return { threadId: ambientThreadId.trim() };
-  }
-  if (typeof ambientThreadId === "number" && Number.isFinite(ambientThreadId)) {
-    return { threadId: String(ambientThreadId) };
-  }
-  return {};
-}
-
-function resolveZalouserSendTarget(params: ToolParams, context?: ZalouserToolContext) {
-  const explicitThreadId = typeof params.threadId === "string" ? params.threadId.trim() : "";
-  const ambientTarget = resolveAmbientZalouserTarget(context);
-  return {
-    threadId: explicitThreadId || ambientTarget.threadId,
-    isGroup: typeof params.isGroup === "boolean" ? params.isGroup : ambientTarget.isGroup,
-  };
-}
-
-export async function executeZalouserTool(
-  _toolCallId: string,
-  params: ToolParams,
-  _signal?: AbortSignal,
-  _onUpdate?: unknown,
-  context?: ZalouserToolContext,
-): Promise<AgentToolResult> {
-  try {
-    switch (params.action) {
-      case "send": {
-        const target = resolveZalouserSendTarget(params, context);
-        if (!target.threadId || !params.message) {
-          throw new Error("threadId and message required for send action");
-        }
-        const result = await sendMessageZalouser(target.threadId, params.message, {
-          profile: params.profile,
-          isGroup: target.isGroup,
-        });
-        if (!result.ok) {
-          throw new Error(result.error || "Failed to send message");
-        }
-        return json({ success: true, messageId: result.messageId });
-      }
-
-      case "image": {
-        const target = resolveZalouserSendTarget(params, context);
-        if (!target.threadId) {
-          throw new Error("threadId required for image action");
-        }
-        if (!params.url) {
-          throw new Error("url required for image action");
-        }
-        const result = await sendImageZalouser(target.threadId, params.url, {
-          profile: params.profile,
-          caption: params.message,
-          isGroup: target.isGroup,
-        });
-        if (!result.ok) {
-          throw new Error(result.error || "Failed to send image");
-        }
-        return json({ success: true, messageId: result.messageId });
-      }
-
-      case "link": {
-        const target = resolveZalouserSendTarget(params, context);
-        if (!target.threadId || !params.url) {
-          throw new Error("threadId and url required for link action");
-        }
-        const result = await sendLinkZalouser(target.threadId, params.url, {
-          profile: params.profile,
-          caption: params.message,
-          isGroup: target.isGroup,
-        });
-        if (!result.ok) {
-          throw new Error(result.error || "Failed to send link");
-        }
-        return json({ success: true, messageId: result.messageId });
-      }
-
-      case "friends": {
-        const rows = await listZaloFriendsMatching(params.profile, params.query);
-        return json(rows);
-      }
-
-      case "groups": {
-        const rows = await listZaloGroupsMatching(params.profile, params.query);
-        return json(rows);
-      }
-
-      case "me": {
-        const info = await getZaloUserInfo(params.profile);
-        return json(info ?? { error: "Not authenticated" });
-      }
-
-      case "status": {
-        const authenticated = await checkZaloAuthenticated(params.profile);
-        return json({
-          authenticated,
-          output: authenticated ? "authenticated" : "not authenticated",
-        });
-      }
-
-      default: {
-        params.action satisfies never;
-        throw new Error(
-          `Unknown action: ${String(params.action)}. Valid actions: send, image, link, friends, groups, me, status`,
-        );
-      }
-    }
-  } catch (err) {
-    return json({
-      error: formatErrorMessage(err),
-    });
-  }
-}
-
-export function createZalouserTool(context?: ZalouserToolContext): AnyAgentTool {
-  return {
-    name: "zalouser",
-    label: "Zalo Personal",
-    description:
-      "Send messages and access data via Zalo personal account. " +
-      "Actions: send (text message), image (send image URL), link (send link), " +
-      "friends (list/search friends), groups (list groups), me (profile info), status (auth check).",
-    parameters: ZalouserToolSchema,
-    execute: async (toolCallId, params, signal, onUpdate) =>
-      await executeZalouserTool(toolCallId, params as ToolParams, signal, onUpdate, context),
-  } satisfies AnyAgentTool;
-}

package/src/types.ts

@@ -1,125 +0,0 @@
-import type { Style } from "./zca-constants.js";
-
-export type ZcaFriend = {
-  userId: string;
-  displayName: string;
-  avatar?: string;
-};
-
-export type ZaloGroup = {
-  groupId: string;
-  name: string;
-  memberCount?: number;
-};
-
-export type ZaloGroupMember = {
-  userId: string;
-  displayName: string;
-  avatar?: string;
-};
-
-export type ZaloEventMessage = {
-  msgId: string;
-  cliMsgId: string;
-  uidFrom: string;
-  idTo: string;
-  msgType: string;
-  st: number;
-  at: number;
-  cmd: number;
-  ts: string | number;
-};
-
-export type ZaloInboundMessage = {
-  threadId: string;
-  isGroup: boolean;
-  senderId: string;
-  senderName?: string;
-  groupName?: string;
-  content: string;
-  commandContent?: string;
-  timestampMs: number;
-  msgId?: string;
-  cliMsgId?: string;
-  hasAnyMention?: boolean;
-  wasExplicitlyMentioned?: boolean;
-  canResolveExplicitMention?: boolean;
-  implicitMention?: boolean;
-  eventMessage?: ZaloEventMessage;
-  raw: unknown;
-};
-
-export type ZcaUserInfo = {
-  userId: string;
-  displayName: string;
-  avatar?: string;
-};
-
-export type ZaloSendOptions = {
-  profile?: string;
-  mediaUrl?: string;
-  caption?: string;
-  isGroup?: boolean;
-  mediaLocalRoots?: readonly string[];
-  mediaReadFile?: (filePath: string) => Promise<Buffer>;
-  textMode?: "markdown" | "plain";
-  textChunkMode?: "length" | "newline";
-  textChunkLimit?: number;
-  textStyles?: Style[];
-};
-
-export type ZaloSendResult = {
-  ok: boolean;
-  messageId?: string;
-  error?: string;
-};
-
-export type ZaloGroupContext = {
-  groupId: string;
-  name?: string;
-  members?: string[];
-};
-
-export type ZaloAuthStatus = {
-  connected: boolean;
-  message: string;
-};
-
-type ZalouserToolConfig = { allow?: string[]; deny?: string[] };
-
-export type ZalouserGroupConfig = {
-  enabled?: boolean;
-  requireMention?: boolean;
-  tools?: ZalouserToolConfig;
-};
-
-type ZalouserSharedConfig = {
-  enabled?: boolean;
-  name?: string;
-  profile?: string;
-  dangerouslyAllowNameMatching?: boolean;
-  dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
-  allowFrom?: Array<string | number>;
-  historyLimit?: number;
-  groupAllowFrom?: Array<string | number>;
-  groupPolicy?: "open" | "allowlist" | "disabled";
-  groups?: Record<string, ZalouserGroupConfig>;
-  messagePrefix?: string;
-  responsePrefix?: string;
-};
-
-export type ZalouserAccountConfig = ZalouserSharedConfig;
-
-export type ZalouserConfig = ZalouserSharedConfig & {
-  defaultAccount?: string;
-  accounts?: Record<string, ZalouserAccountConfig>;
-};
-
-export type ResolvedZalouserAccount = {
-  accountId: string;
-  name?: string;
-  enabled: boolean;
-  profile: string;
-  authenticated: boolean;
-  config: ZalouserAccountConfig;
-};