zalo-agent-cli 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zalo-agent-cli",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "CLI tool for Zalo automation — multi-account, proxy support, bank transfers, QR payments",
   "type": "module",
   "bin": {

package/src/commands/group.js

@@ -1,7 +1,9 @@
 /**
- * Group commands — list, create, info, members, add/remove-member, rename, leave, join.
+ * Group commands — list, create, info, members, add/remove-member, rename, avatar,
+ * admin, owner, block/unblock, settings, leave, join.
  */
 
+import { resolve } from "path";
 import { getApi } from "../core/zalo-client.js";
 import { success, error, info, output } from "../utils/output.js";
 
@@ -97,6 +99,78 @@ export function registerGroupCommands(program) {
             }
         });
 
+    group
+        .command("avatar <groupId> <imagePath>")
+        .description("Change group avatar")
+        .action(async (groupId, imagePath) => {
+            try {
+                const result = await getApi().changeGroupAvatar(resolve(imagePath), groupId);
+                output(result, program.opts().json, () => success("Group avatar changed"));
+            } catch (e) {
+                error(`Change avatar failed: ${e.message}`);
+            }
+        });
+
+    group
+        .command("add-admin <groupId> <userIds...>")
+        .description("Promote members to group admin (deputy)")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().addGroupDeputy(userIds, groupId);
+                output(result, program.opts().json, () => success("Admin(s) added"));
+            } catch (e) {
+                error(`Add admin failed: ${e.message}`);
+            }
+        });
+
+    group
+        .command("remove-admin <groupId> <userIds...>")
+        .description("Demote admins back to regular members")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().removeGroupDeputy(userIds, groupId);
+                output(result, program.opts().json, () => success("Admin(s) removed"));
+            } catch (e) {
+                error(`Remove admin failed: ${e.message}`);
+            }
+        });
+
+    group
+        .command("transfer-owner <groupId> <userId>")
+        .description("Transfer group ownership to another member")
+        .action(async (groupId, userId) => {
+            try {
+                const result = await getApi().changeGroupOwner(userId, groupId);
+                output(result, program.opts().json, () => success(`Ownership transferred to ${userId}`));
+            } catch (e) {
+                error(`Transfer owner failed: ${e.message}`);
+            }
+        });
+
+    group
+        .command("block-member <groupId> <userIds...>")
+        .description("Block members from rejoining the group")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().addGroupBlockedMember(userIds, groupId);
+                output(result, program.opts().json, () => success("Member(s) blocked"));
+            } catch (e) {
+                error(`Block member failed: ${e.message}`);
+            }
+        });
+
+    group
+        .command("unblock-member <groupId> <userIds...>")
+        .description("Unblock previously blocked members")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().removeGroupBlockedMember(userIds, groupId);
+                output(result, program.opts().json, () => success("Member(s) unblocked"));
+            } catch (e) {
+                error(`Unblock member failed: ${e.message}`);
+            }
+        });
+
     group
         .command("leave <groupId>")
         .description("Leave a group")

package/src/commands/listen.js

@@ -6,7 +6,11 @@
 import { getApi, autoLogin, clearSession } from "../core/zalo-client.js";
 import { success, error, info, warning } from "../utils/output.js";
 
-/** Friend event type enum → readable label */
+/** Thread types matching zca-js ThreadType enum */
+const THREAD_USER = 0;
+const THREAD_GROUP = 1;
+
+/** Friend event type → readable label (matches zca-js FriendEventType enum order) */
 const FRIEND_EVENT_LABELS = {
     0: "friend_added",
     1: "friend_removed",
@@ -17,6 +21,10 @@ const FRIEND_EVENT_LABELS = {
     6: "blocked",
     7: "unblocked",
 };
+const FRIEND_REQUEST_TYPE = 2;
+
+/** Zalo close code for duplicate web session */
+const CLOSE_DUPLICATE = 3000;
 
 export function registerListenCommand(program) {
     program
@@ -47,30 +55,36 @@ export function registerListenCommand(program) {
                 return h > 0 ? `${h}h${m}m` : `${m}m${s % 60}s`;
             }
 
-            /** Send event data to webhook */
-            async function postWebhook(data) {
+            /** Fire-and-forget webhook POST — never blocks event processing */
+            function postWebhook(data) {
                 if (!opts.webhook) return;
-                try {
-                    await fetch(opts.webhook, {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify(data),
-                    });
-                } catch {
-                    // Silent — don't block listener
+                fetch(opts.webhook, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(data),
+                }).catch(() => {});
+            }
+
+            /** Output event as JSON or human-readable, then post to webhook */
+            function emitEvent(data, humanMsg) {
+                eventCount++;
+                if (jsonMode) {
+                    console.log(JSON.stringify(data));
+                } else {
+                    info(humanMsg);
                 }
+                postWebhook(data);
             }
 
-            /** Attach all event handlers to current API */
-            function attachHandlers(api) {
+            /** Attach ALL handlers (data + lifecycle) to current API listener */
+            function attachAllHandlers(api) {
                 // --- Message events ---
                 if (enabledEvents.has("message")) {
                     api.listener.on("message", async (msg) => {
-                        if (opts.filter === "user" && msg.type !== 0) return;
-                        if (opts.filter === "group" && msg.type !== 1) return;
+                        if (opts.filter === "user" && msg.type !== THREAD_USER) return;
+                        if (opts.filter === "group" && msg.type !== THREAD_GROUP) return;
                         if (!opts.self && msg.isSelf) return;
 
-                        eventCount++;
                         const content = typeof msg.data.content === "string" ? msg.data.content : "[non-text]";
                         const data = {
                             event: "message",
@@ -81,24 +95,18 @@ export function registerListenCommand(program) {
                             isSelf: msg.isSelf,
                             content,
                         };
-
-                        if (jsonMode) {
-                            console.log(JSON.stringify(data));
-                        } else {
-                            const dir = msg.isSelf ? "→" : "←";
-                            const typeLabel = msg.type === 0 ? "DM" : "GR";
-                            console.log(
-                                `  ${dir} [${typeLabel}] [${msg.threadId}] ${content}  (msgId: ${msg.data.msgId})`,
-                            );
-                        }
-                        await postWebhook(data);
+                        const dir = msg.isSelf ? "→" : "←";
+                        const typeLabel = msg.type === THREAD_USER ? "DM" : "GR";
+                        emitEvent(
+                            data,
+                            `${dir} [${typeLabel}] [${msg.threadId}] ${content}  (msgId: ${msg.data.msgId})`,
+                        );
                     });
                 }
 
                 // --- Friend events ---
                 if (enabledEvents.has("friend")) {
                     api.listener.on("friend_event", async (event) => {
-                        eventCount++;
                         const label = FRIEND_EVENT_LABELS[event.type] || "friend_unknown";
                         const data = {
                             event: label,
@@ -106,20 +114,14 @@ export function registerListenCommand(program) {
                             isSelf: event.isSelf,
                             data: event.data,
                         };
-
-                        if (jsonMode) {
-                            console.log(JSON.stringify(data));
-                        } else {
-                            const msg =
-                                event.type === 2
-                                    ? `Friend request from ${event.data.fromUid}: "${event.data.message || ""}"`
-                                    : `${label} — ${event.threadId}`;
-                            info(msg);
-                        }
-                        await postWebhook(data);
-
-                        // Auto-accept
-                        if (opts.autoAccept && event.type === 2 && !event.isSelf) {
+                        const humanMsg =
+                            event.type === FRIEND_REQUEST_TYPE
+                                ? `Friend request from ${event.data.fromUid}: "${event.data.message || ""}"`
+                                : `${label} — ${event.threadId}`;
+                        emitEvent(data, humanMsg);
+
+                        // Auto-accept incoming friend requests
+                        if (opts.autoAccept && event.type === FRIEND_REQUEST_TYPE && !event.isSelf) {
                             try {
                                 await api.acceptFriendRequest(event.data.fromUid);
                                 success(`Auto-accepted friend request from ${event.data.fromUid}`);
@@ -132,104 +134,103 @@ export function registerListenCommand(program) {
 
                 // --- Group events ---
                 if (enabledEvents.has("group")) {
-                    api.listener.on("group_event", async (event) => {
-                        eventCount++;
-                        const data = {
-                            event: `group_${event.type}`,
-                            threadId: event.threadId,
-                            isSelf: event.isSelf,
-                            data: event.data,
-                        };
-
-                        if (jsonMode) {
-                            console.log(JSON.stringify(data));
-                        } else {
-                            info(`Group: ${event.type} — ${event.threadId}`);
-                        }
-                        await postWebhook(data);
+                    api.listener.on("group_event", (event) => {
+                        emitEvent(
+                            {
+                                event: `group_${event.type}`,
+                                threadId: event.threadId,
+                                isSelf: event.isSelf,
+                                data: event.data,
+                            },
+                            `Group: ${event.type} — ${event.threadId}`,
+                        );
                     });
                 }
 
                 // --- Reaction events ---
                 if (enabledEvents.has("reaction")) {
-                    api.listener.on("reaction", async (reaction) => {
+                    api.listener.on("reaction", (reaction) => {
                         if (!opts.self && reaction.isSelf) return;
-                        eventCount++;
-                        const data = {
-                            event: "reaction",
-                            threadId: reaction.threadId,
-                            isSelf: reaction.isSelf,
-                            isGroup: reaction.isGroup,
-                            data: reaction.data,
-                        };
-
-                        if (jsonMode) {
-                            console.log(JSON.stringify(data));
-                        } else {
-                            info(`Reaction in ${reaction.threadId}`);
-                        }
-                        await postWebhook(data);
+                        emitEvent(
+                            {
+                                event: "reaction",
+                                threadId: reaction.threadId,
+                                isSelf: reaction.isSelf,
+                                isGroup: reaction.isGroup,
+                                data: reaction.data,
+                            },
+                            `Reaction in ${reaction.threadId}`,
+                        );
                     });
                 }
-            }
-
-            /** Start listener with auto-reconnect */
-            async function startListener() {
-                try {
-                    const api = getApi();
 
-                    api.listener.on("connected", () => {
-                        if (reconnectCount > 0) {
-                            info(`Reconnected (#${reconnectCount}, uptime: ${uptime()}, events: ${eventCount})`);
-                        }
-                    });
+                // --- Lifecycle events (MUST be on same listener for reconnect to work) ---
+                api.listener.on("connected", () => {
+                    if (reconnectCount > 0) {
+                        info(`Reconnected (#${reconnectCount}, uptime: ${uptime()}, events: ${eventCount})`);
+                    }
+                });
 
-                    api.listener.on("disconnected", (code, _reason) => {
-                        warning(`Disconnected (code: ${code}). Auto-retrying...`);
-                    });
+                api.listener.on("disconnected", (code, _reason) => {
+                    warning(`Disconnected (code: ${code}). Auto-retrying...`);
+                });
 
-                    api.listener.on("closed", async (code, _reason) => {
-                        if (code === 3000) {
-                            error("Another Zalo Web session opened. Listener stopped.");
-                            process.exit(1);
-                        }
-                        reconnectCount++;
-                        warning(`Connection closed (code: ${code}). Re-login in 5s... (uptime: ${uptime()})`);
-                        await new Promise((r) => setTimeout(r, 5000));
+                api.listener.on("closed", async (code, _reason) => {
+                    if (code === CLOSE_DUPLICATE) {
+                        error("Another Zalo Web session opened. Listener stopped.");
+                        process.exit(1);
+                    }
+                    reconnectCount++;
+                    warning(`Connection closed (code: ${code}). Re-login in 5s... (uptime: ${uptime()})`);
+                    await new Promise((r) => setTimeout(r, 5000));
+                    try {
+                        clearSession();
+                        await autoLogin(jsonMode);
+                        info("Re-login successful. Restarting listener...");
+                        // Attach ALL handlers to the NEW api (including lifecycle)
+                        const newApi = getApi();
+                        attachAllHandlers(newApi);
+                        newApi.listener.start({ retryOnClose: true });
+                    } catch (e) {
+                        error(`Re-login failed: ${e.message}. Retrying in 30s...`);
+                        await new Promise((r) => setTimeout(r, 30000));
                         try {
                             clearSession();
                             await autoLogin(jsonMode);
-                            info("Re-login successful. Restarting listener...");
-                            attachHandlers(getApi());
-                            getApi().listener.start({ retryOnClose: true });
-                        } catch (e) {
-                            error(`Re-login failed: ${e.message}. Retrying in 30s...`);
-                            await new Promise((r) => setTimeout(r, 30000));
-                            startListener();
+                            const retryApi = getApi();
+                            attachAllHandlers(retryApi);
+                            retryApi.listener.start({ retryOnClose: true });
+                            info("Re-login successful on retry.");
+                        } catch (e2) {
+                            error(`Re-login retry failed: ${e2.message}. Exiting.`);
+                            process.exit(1);
                         }
-                    });
-
-                    api.listener.on("error", (_err) => {
-                        // Log but don't crash
-                    });
+                    }
+                });
 
-                    attachHandlers(api);
-                    api.listener.start({ retryOnClose: true });
-
-                    info("Listening for Zalo events... Press Ctrl+C to stop.");
-                    info(`Events: ${opts.events}`);
-                    info("Auto-reconnect enabled.");
-                    if (opts.filter !== "all") info(`Message filter: ${opts.filter}`);
-                    if (opts.webhook) info(`Webhook: ${opts.webhook}`);
-                    if (opts.autoAccept) info("Auto-accept friend requests: ON");
-                } catch (e) {
-                    error(`Listen failed: ${e.message}`);
-                    process.exit(1);
-                }
+                api.listener.on("error", (_err) => {
+                    // WS errors are followed by close/disconnect — don't crash
+                });
             }
 
-            await startListener();
+            // --- Initial start ---
+            try {
+                const api = getApi();
+                attachAllHandlers(api);
+                api.listener.start({ retryOnClose: true });
+
+                info("Listening for Zalo events... Press Ctrl+C to stop.");
+                info(`Events: ${opts.events}`);
+                info("Auto-reconnect enabled.");
+                if (opts.filter !== "all") info(`Message filter: ${opts.filter}`);
+                if (opts.webhook) info(`Webhook: ${opts.webhook}`);
+                if (opts.autoAccept) info("Auto-accept friend requests: ON");
+            } catch (e) {
+                error(`Listen failed: ${e.message}`);
+                process.exit(1);
+            }
 
+            // Keep alive until Ctrl+C
             await new Promise((resolve) => {
                 process.on("SIGINT", () => {
                     try {

package/src/commands/msg.js

@@ -211,10 +211,7 @@ export function registerMsgCommands(program) {
             "React to a message. Reaction codes: :> (haha), /-heart (heart), /-strong (like), :o (wow), :-(( (cry), :-h (angry)",
         )
         .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
-        .option(
-            "-c, --cli-msg-id <id>",
-            "Client message ID (required for reaction to appear, get from msg listen --json)",
-        )
+        .option("-c, --cli-msg-id <id>", "Client message ID (required for reaction to appear, get from listen --json)")
         .action(async (msgId, threadId, reaction, opts) => {
             try {
                 // zca-js addReaction(icon, dest) — dest needs msgId + cliMsgId