@openclaw/zalouser 2026.2.25 → 2026.3.2

package/src/zca-client.ts

@@ -0,0 +1,249 @@
+import {
+  LoginQRCallbackEventType as LoginQRCallbackEventTypeRuntime,
+  Reactions as ReactionsRuntime,
+  ThreadType as ThreadTypeRuntime,
+  Zalo as ZaloRuntime,
+} from "zca-js";
+
+export const ThreadType = ThreadTypeRuntime as {
+  User: 0;
+  Group: 1;
+};
+
+export const LoginQRCallbackEventType = LoginQRCallbackEventTypeRuntime as {
+  QRCodeGenerated: 0;
+  QRCodeExpired: 1;
+  QRCodeScanned: 2;
+  QRCodeDeclined: 3;
+  GotLoginInfo: 4;
+};
+
+export const Reactions = ReactionsRuntime as Record<string, string> & {
+  HEART: string;
+  LIKE: string;
+  HAHA: string;
+  WOW: string;
+  CRY: string;
+  ANGRY: string;
+  NONE: string;
+};
+
+export type Credentials = {
+  imei: string;
+  cookie: unknown;
+  userAgent: string;
+  language?: string;
+};
+
+export type User = {
+  userId: string;
+  username: string;
+  displayName: string;
+  zaloName: string;
+  avatar: string;
+};
+
+export type GroupInfo = {
+  groupId: string;
+  name: string;
+  totalMember?: number;
+  memberIds?: unknown[];
+  currentMems?: Array<{
+    id?: unknown;
+    dName?: string;
+    zaloName?: string;
+    avatar?: string;
+  }>;
+};
+
+export type Message = {
+  type: number;
+  threadId: string;
+  isSelf: boolean;
+  data: Record<string, unknown>;
+};
+
+export type LoginQRCallbackEvent =
+  | {
+      type: 0;
+      data: {
+        code: string;
+        image: string;
+      };
+      actions: {
+        saveToFile: (qrPath?: string) => Promise<unknown>;
+        retry: () => unknown;
+        abort: () => unknown;
+      };
+    }
+  | {
+      type: 1;
+      data: null;
+      actions: {
+        retry: () => unknown;
+        abort: () => unknown;
+      };
+    }
+  | {
+      type: 2;
+      data: {
+        avatar: string;
+        display_name: string;
+      };
+      actions: {
+        retry: () => unknown;
+        abort: () => unknown;
+      };
+    }
+  | {
+      type: 3;
+      data: {
+        code: string;
+      };
+      actions: {
+        retry: () => unknown;
+        abort: () => unknown;
+      };
+    }
+  | {
+      type: 4;
+      data: {
+        cookie: unknown;
+        imei: string;
+        userAgent: string;
+      };
+      actions: null;
+    };
+
+export type Listener = {
+  on(event: "message", callback: (message: Message) => void): void;
+  on(event: "error", callback: (error: unknown) => void): void;
+  on(event: "closed", callback: (code: number, reason: string) => void): void;
+  off(event: "message", callback: (message: Message) => void): void;
+  off(event: "error", callback: (error: unknown) => void): void;
+  off(event: "closed", callback: (code: number, reason: string) => void): void;
+  start(opts?: { retryOnClose?: boolean }): void;
+  stop(): void;
+};
+
+export type API = {
+  listener: Listener;
+  getContext(): {
+    imei: string;
+    userAgent: string;
+    language?: string;
+  };
+  getCookie(): {
+    toJSON(): {
+      cookies: unknown[];
+    };
+  };
+  fetchAccountInfo(): Promise<{ profile: User } | User>;
+  getAllFriends(): Promise<User[]>;
+  getOwnId(): string;
+  getAllGroups(): Promise<{
+    gridVerMap: Record<string, string>;
+  }>;
+  getGroupInfo(groupId: string | string[]): Promise<{
+    gridInfoMap: Record<string, GroupInfo & { memVerList?: unknown }>;
+  }>;
+  getGroupMembersInfo(memberId: string | string[]): Promise<{
+    profiles: Record<
+      string,
+      {
+        id?: string;
+        displayName?: string;
+        zaloName?: string;
+        avatar?: string;
+      }
+    >;
+  }>;
+  sendMessage(
+    message: string | Record<string, unknown>,
+    threadId: string,
+    type?: number,
+  ): Promise<{
+    message?: { msgId?: string | number } | null;
+    attachment?: Array<{ msgId?: string | number }>;
+  }>;
+  sendLink(
+    payload: { link: string; msg?: string },
+    threadId: string,
+    type?: number,
+  ): Promise<{ msgId?: string | number }>;
+  sendTypingEvent(threadId: string, type?: number, destType?: number): Promise<{ status: number }>;
+  addReaction(
+    icon: string | { rType: number; source: number; icon: string },
+    dest: {
+      data: {
+        msgId: string;
+        cliMsgId: string;
+      };
+      threadId: string;
+      type: number;
+    },
+  ): Promise<unknown>;
+  sendDeliveredEvent(
+    isSeen: boolean,
+    messages:
+      | {
+          msgId: string;
+          cliMsgId: string;
+          uidFrom: string;
+          idTo: string;
+          msgType: string;
+          st: number;
+          at: number;
+          cmd: number;
+          ts: string | number;
+        }
+      | Array<{
+          msgId: string;
+          cliMsgId: string;
+          uidFrom: string;
+          idTo: string;
+          msgType: string;
+          st: number;
+          at: number;
+          cmd: number;
+          ts: string | number;
+        }>,
+    type?: number,
+  ): Promise<unknown>;
+  sendSeenEvent(
+    messages:
+      | {
+          msgId: string;
+          cliMsgId: string;
+          uidFrom: string;
+          idTo: string;
+          msgType: string;
+          st: number;
+          at: number;
+          cmd: number;
+          ts: string | number;
+        }
+      | Array<{
+          msgId: string;
+          cliMsgId: string;
+          uidFrom: string;
+          idTo: string;
+          msgType: string;
+          st: number;
+          at: number;
+          cmd: number;
+          ts: string | number;
+        }>,
+    type?: number,
+  ): Promise<unknown>;
+};
+
+type ZaloCtor = new (options?: { logging?: boolean; selfListen?: boolean }) => {
+  login(credentials: Credentials): Promise<API>;
+  loginQR(
+    options?: { userAgent?: string; language?: string; qrPath?: string },
+    callback?: (event: LoginQRCallbackEvent) => unknown,
+  ): Promise<API>;
+};
+
+export const Zalo = ZaloRuntime as unknown as ZaloCtor;

package/src/zca-js-exports.d.ts

@@ -0,0 +1,22 @@
+declare module "zca-js" {
+  export const ThreadType: {
+    User: number;
+    Group: number;
+  };
+
+  export const LoginQRCallbackEventType: {
+    QRCodeGenerated: number;
+    QRCodeExpired: number;
+    QRCodeScanned: number;
+    QRCodeDeclined: number;
+    GotLoginInfo: number;
+  };
+
+  export const Reactions: Record<string, string>;
+
+  export class Zalo {
+    constructor(options?: { logging?: boolean; selfListen?: boolean });
+    login(credentials: unknown): Promise<unknown>;
+    loginQR(options?: unknown, callback?: (event: unknown) => unknown): Promise<unknown>;
+  }
+}

package/src/zca.ts

@@ -1,198 +0,0 @@
-import { spawn, type SpawnOptions } from "node:child_process";
-import { stripAnsi } from "openclaw/plugin-sdk";
-import type { ZcaResult, ZcaRunOptions } from "./types.js";
-
-const ZCA_BINARY = "zca";
-const DEFAULT_TIMEOUT = 30000;
-
-function buildArgs(args: string[], options?: ZcaRunOptions): string[] {
-  const result: string[] = [];
-  // Profile flag comes first (before subcommand)
-  const profile = options?.profile || process.env.ZCA_PROFILE;
-  if (profile) {
-    result.push("--profile", profile);
-  }
-  result.push(...args);
-  return result;
-}
-
-export async function runZca(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
-  const fullArgs = buildArgs(args, options);
-  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-
-  return new Promise((resolve) => {
-    const spawnOpts: SpawnOptions = {
-      cwd: options?.cwd,
-      env: { ...process.env },
-      stdio: ["pipe", "pipe", "pipe"],
-    };
-
-    const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-
-    const timer = setTimeout(() => {
-      timedOut = true;
-      proc.kill("SIGTERM");
-    }, timeout);
-
-    proc.stdout?.on("data", (data: Buffer) => {
-      stdout += data.toString();
-    });
-
-    proc.stderr?.on("data", (data: Buffer) => {
-      stderr += data.toString();
-    });
-
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      if (timedOut) {
-        resolve({
-          ok: false,
-          stdout,
-          stderr: stderr || "Command timed out",
-          exitCode: code ?? 124,
-        });
-        return;
-      }
-      resolve({
-        ok: code === 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: code ?? 1,
-      });
-    });
-
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      resolve({
-        ok: false,
-        stdout: "",
-        stderr: err.message,
-        exitCode: 1,
-      });
-    });
-  });
-}
-
-export function runZcaInteractive(args: string[], options?: ZcaRunOptions): Promise<ZcaResult> {
-  const fullArgs = buildArgs(args, options);
-
-  return new Promise((resolve) => {
-    const spawnOpts: SpawnOptions = {
-      cwd: options?.cwd,
-      env: { ...process.env },
-      stdio: "inherit",
-    };
-
-    const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
-
-    proc.on("close", (code) => {
-      resolve({
-        ok: code === 0,
-        stdout: "",
-        stderr: "",
-        exitCode: code ?? 1,
-      });
-    });
-
-    proc.on("error", (err) => {
-      resolve({
-        ok: false,
-        stdout: "",
-        stderr: err.message,
-        exitCode: 1,
-      });
-    });
-  });
-}
-
-export function parseJsonOutput<T>(stdout: string): T | null {
-  try {
-    return JSON.parse(stdout) as T;
-  } catch {
-    const cleaned = stripAnsi(stdout);
-
-    try {
-      return JSON.parse(cleaned) as T;
-    } catch {
-      // zca may prefix output with INFO/log lines, try to find JSON
-      const lines = cleaned.split("\n");
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (line.startsWith("{") || line.startsWith("[")) {
-          // Try parsing from this line to the end
-          const jsonCandidate = lines.slice(i).join("\n").trim();
-          try {
-            return JSON.parse(jsonCandidate) as T;
-          } catch {
-            continue;
-          }
-        }
-      }
-      return null;
-    }
-  }
-}
-
-export async function checkZcaInstalled(): Promise<boolean> {
-  const result = await runZca(["--version"], { timeout: 5000 });
-  return result.ok;
-}
-
-export type ZcaStreamingOptions = ZcaRunOptions & {
-  onData?: (data: string) => void;
-  onError?: (err: Error) => void;
-};
-
-export function runZcaStreaming(
-  args: string[],
-  options?: ZcaStreamingOptions,
-): { proc: ReturnType<typeof spawn>; promise: Promise<ZcaResult> } {
-  const fullArgs = buildArgs(args, options);
-
-  const spawnOpts: SpawnOptions = {
-    cwd: options?.cwd,
-    env: { ...process.env },
-    stdio: ["pipe", "pipe", "pipe"],
-  };
-
-  const proc = spawn(ZCA_BINARY, fullArgs, spawnOpts);
-  let stdout = "";
-  let stderr = "";
-
-  proc.stdout?.on("data", (data: Buffer) => {
-    const text = data.toString();
-    stdout += text;
-    options?.onData?.(text);
-  });
-
-  proc.stderr?.on("data", (data: Buffer) => {
-    stderr += data.toString();
-  });
-
-  const promise = new Promise<ZcaResult>((resolve) => {
-    proc.on("close", (code) => {
-      resolve({
-        ok: code === 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: code ?? 1,
-      });
-    });
-
-    proc.on("error", (err) => {
-      options?.onError?.(err);
-      resolve({
-        ok: false,
-        stdout: "",
-        stderr: err.message,
-        exitCode: 1,
-      });
-    });
-  });
-
-  return { proc, promise };
-}