zalo-agent-cli 1.0.9 → 1.0.10

package/package.json

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

package/src/commands/friend.js

@@ -2,8 +2,8 @@
  * Friend commands — list, find, info, add, accept, remove, block, unblock, last-online, online.
  */
 
-import { getApi } from "../core/zalo-client.js";
-import { success, error, info, output } from "../utils/output.js";
+import { getApi, autoLogin, clearSession } from "../core/zalo-client.js";
+import { success, error, info, warning, output } from "../utils/output.js";
 
 /** Extract numeric error code from zca-js error message string. */
 function extractErrorCode(msg) {
@@ -166,4 +166,140 @@ export function registerFriendCommands(program) {
                 error(e.message);
             }
         });
+
+    /** Map FriendEventType enum to readable labels */
+    const FRIEND_EVENT_LABELS = {
+        0: "FRIEND_ADDED",
+        1: "FRIEND_REMOVED",
+        2: "FRIEND_REQUEST",
+        3: "UNDO_REQUEST",
+        4: "REJECT_REQUEST",
+        5: "SEEN_REQUEST",
+        6: "BLOCKED",
+        7: "UNBLOCKED",
+        8: "BLOCK_CALL",
+        9: "UNBLOCK_CALL",
+        10: "PIN_UNPIN",
+        11: "PIN_CREATE",
+    };
+
+    friend
+        .command("listen")
+        .description(
+            "Listen for friend events: new requests, accepts, removes, blocks. Use --json for machine parsing. Auto-reconnect enabled.",
+        )
+        .option(
+            "-f, --filter <type>",
+            "Filter events: request (new requests only), add (accepted only), all (default)",
+            "all",
+        )
+        .option("-w, --webhook <url>", "POST each event as JSON to this URL (for n8n, Make, etc.)")
+        .option("--auto-accept", "Automatically accept incoming friend requests")
+        .action(async (opts) => {
+            const jsonMode = program.opts().json;
+            const startTime = Date.now();
+
+            function uptime() {
+                const s = Math.floor((Date.now() - startTime) / 1000);
+                const h = Math.floor(s / 3600);
+                const m = Math.floor((s % 3600) / 60);
+                return h > 0 ? `${h}h${m}m` : `${m}m${s % 60}s`;
+            }
+
+            async function startListener() {
+                try {
+                    const api = getApi();
+
+                    api.listener.on("friend_event", async (event) => {
+                        const label = FRIEND_EVENT_LABELS[event.type] || "UNKNOWN";
+
+                        // Filter
+                        if (opts.filter === "request" && event.type !== 2) return;
+                        if (opts.filter === "add" && event.type !== 0) return;
+
+                        const data = {
+                            event: label,
+                            type: event.type,
+                            threadId: event.threadId,
+                            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);
+                        }
+
+                        // Webhook
+                        if (opts.webhook) {
+                            try {
+                                await fetch(opts.webhook, {
+                                    method: "POST",
+                                    headers: { "Content-Type": "application/json" },
+                                    body: JSON.stringify(data),
+                                });
+                            } catch {
+                                // Silent
+                            }
+                        }
+
+                        // Auto-accept friend requests
+                        if (opts.autoAccept && event.type === 2 && !event.isSelf) {
+                            try {
+                                await api.acceptFriendRequest(event.data.fromUid);
+                                success(`Auto-accepted friend request from ${event.data.fromUid}`);
+                            } catch (e) {
+                                error(`Auto-accept failed: ${e.message}`);
+                            }
+                        }
+                    });
+
+                    api.listener.on("closed", async (code, _reason) => {
+                        if (code === 3000) {
+                            error("Another Zalo Web session opened. Listener stopped.");
+                            process.exit(1);
+                        }
+                        warning(`Connection closed (code: ${code}). Re-login in 5s...`);
+                        await new Promise((r) => setTimeout(r, 5000));
+                        try {
+                            clearSession();
+                            await autoLogin(jsonMode);
+                            startListener();
+                        } catch (e) {
+                            error(`Re-login failed: ${e.message}. Retrying in 30s...`);
+                            await new Promise((r) => setTimeout(r, 30000));
+                            startListener();
+                        }
+                    });
+
+                    api.listener.start({ retryOnClose: true });
+
+                    info("Listening for friend events... Press Ctrl+C to stop.");
+                    info("Auto-reconnect enabled.");
+                    if (opts.filter !== "all") info(`Filter: ${opts.filter} events only`);
+                    if (opts.webhook) info(`Webhook: POST to ${opts.webhook}`);
+                    if (opts.autoAccept) info("Auto-accept: ON — will accept all incoming requests");
+                } catch (e) {
+                    error(`Listen failed: ${e.message}`);
+                    process.exit(1);
+                }
+            }
+
+            await startListener();
+
+            await new Promise((resolve) => {
+                process.on("SIGINT", () => {
+                    try {
+                        getApi().listener.stop();
+                    } catch {}
+                    info(`Listener stopped. Uptime: ${uptime()}`);
+                    resolve();
+                });
+            });
+        });
 }