zalo-agent-cli 1.0.8 → 1.0.9

package/package.json

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

package/src/commands/msg.js

@@ -4,8 +4,8 @@
  */
 
 import { resolve } from "path";
-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";
 
 export function registerMsgCommands(program) {
     const msg = program.command("msg").description("Send and manage messages");
@@ -238,19 +238,23 @@ export function registerMsgCommands(program) {
         .option("-w, --webhook <url>", "POST each message as JSON to this URL (for n8n, Make, etc.)")
         .option("--no-self", "Exclude messages sent by this account")
         .action(async (opts) => {
-            try {
-                const api = getApi();
-                const jsonMode = program.opts().json;
-                info("Listening for messages... Press Ctrl+C to stop.");
-                info("Note: Only one web listener per account. Browser Zalo will disconnect.");
-                if (opts.filter !== "all") info(`Filter: ${opts.filter} messages only`);
-                if (opts.webhook) info(`Webhook: POST to ${opts.webhook}`);
+            const jsonMode = program.opts().json;
+            const startTime = Date.now();
+            let reconnectCount = 0;
+
+            /** Format uptime as human-readable string */
+            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`;
+            }
 
+            /** Attach message handler to current API listener */
+            function attachMessageHandler(api) {
                 api.listener.on("message", async (msg) => {
-                    // Filter by type: 0=User, 1=Group
                     if (opts.filter === "user" && msg.type !== 0) return;
                     if (opts.filter === "group" && msg.type !== 1) return;
-                    // Filter self messages
                     if (!opts.self && msg.isSelf) return;
 
                     const content = typeof msg.data.content === "string" ? msg.data.content : "[non-text]";
@@ -263,7 +267,6 @@ export function registerMsgCommands(program) {
                         content,
                     };
 
-                    // Output to stdout
                     if (jsonMode) {
                         console.log(JSON.stringify(data));
                     } else {
@@ -272,7 +275,6 @@ export function registerMsgCommands(program) {
                         console.log(`  ${dir} [${typeLabel}] [${msg.threadId}] ${content}  (msgId: ${msg.data.msgId})`);
                     }
 
-                    // POST to webhook if configured
                     if (opts.webhook) {
                         try {
                             await fetch(opts.webhook, {
@@ -281,24 +283,84 @@ export function registerMsgCommands(program) {
                                 body: JSON.stringify(data),
                             });
                         } catch {
-                            // Silent webhook failure — don't block listener
+                            // Silent webhook failure
                         }
                     }
                 });
+            }
 
-                api.listener.start();
+            /** Start listener with auto-reconnect and re-login */
+            async function startListener() {
+                try {
+                    const api = getApi();
 
-                // Keep alive until Ctrl+C
-                await new Promise((resolve) => {
-                    process.on("SIGINT", () => {
-                        api.listener.stop();
-                        info("Listener stopped.");
-                        resolve();
+                    api.listener.on("connected", () => {
+                        if (reconnectCount > 0) {
+                            info(`Reconnected (attempt #${reconnectCount}, uptime: ${uptime()})`);
+                        }
                     });
-                });
-            } catch (e) {
-                error(`Listen failed: ${e.message}`);
+
+                    api.listener.on("disconnected", (code, _reason) => {
+                        warning(`Disconnected (code: ${code}). Auto-retrying...`);
+                    });
+
+                    // "closed" = permanent close (retries exhausted or duplicate connection)
+                    api.listener.on("closed", async (code, _reason) => {
+                        if (code === 3000) {
+                            // Duplicate connection — someone opened Zalo Web
+                            error("Another Zalo Web session opened. Listener stopped.");
+                            error("Close the other session and restart listener.");
+                            process.exit(1);
+                        }
+
+                        reconnectCount++;
+                        warning(`Connection closed (code: ${code}). Re-login in 5s... (uptime: ${uptime()})`);
+
+                        // Re-login and restart
+                        await new Promise((r) => setTimeout(r, 5000));
+                        try {
+                            clearSession();
+                            await autoLogin(jsonMode);
+                            info(`Re-login successful. Restarting listener...`);
+                            attachMessageHandler(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();
+                        }
+                    });
+
+                    api.listener.on("error", (_err) => {
+                        // Log but don't crash — WS errors are usually followed by close/disconnect
+                    });
+
+                    attachMessageHandler(api);
+                    // retryOnClose: true = zca-js auto-retries on temporary disconnects
+                    api.listener.start({ retryOnClose: true });
+
+                    info("Listening for messages... Press Ctrl+C to stop.");
+                    info("Auto-reconnect enabled. Will survive network drops.");
+                    if (opts.filter !== "all") info(`Filter: ${opts.filter} messages only`);
+                    if (opts.webhook) info(`Webhook: POST to ${opts.webhook}`);
+                } catch (e) {
+                    error(`Listen failed: ${e.message}`);
+                    process.exit(1);
+                }
             }
+
+            await startListener();
+
+            // Keep alive until Ctrl+C
+            await new Promise((resolve) => {
+                process.on("SIGINT", () => {
+                    try {
+                        getApi().listener.stop();
+                    } catch {}
+                    info(`Listener stopped. Uptime: ${uptime()}, reconnects: ${reconnectCount}`);
+                    resolve();
+                });
+            });
         });
 
     msg.command("delete <msgId> <threadId>")