@ardennguyen/zalo-agent-cli 1.0.7

package/src/commands/listen.js

@@ -0,0 +1,293 @@
+/**
+ * Unified listener — combines message, friend, and group events in one WebSocket connection.
+ * Production-ready with auto-reconnect and re-login.
+ */
+
+import { appendFileSync, mkdirSync, existsSync } from "fs";
+import { resolve, join } from "path";
+import { getApi, autoLogin, clearSession } from "../core/zalo-client.js";
+import { success, error, info, warning } from "../utils/output.js";
+
+/** 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",
+    2: "friend_request",
+    3: "undo_request",
+    4: "reject_request",
+    5: "seen_request",
+    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
+        .command("listen")
+        .description(
+            "Listen for all Zalo events (messages, friend requests, group events) via one WebSocket. Auto-reconnect enabled.",
+        )
+        .option(
+            "-e, --events <types>",
+            "Comma-separated event types: message,friend,group,reaction (default: message,friend)",
+            "message,friend",
+        )
+        .option("-f, --filter <type>", "Message filter: user (DM only), group (groups only), all", "all")
+        .option("-w, --webhook <url>", "POST each event as JSON to this URL (for n8n, Make, etc.)")
+        .option("--no-self", "Exclude self-sent messages")
+        .option("--auto-accept", "Auto-accept incoming friend requests")
+        .option("--save <dir>", "Save messages locally as JSONL files (one file per thread, e.g. --save ./zalo-logs)")
+        .action(async (opts) => {
+            const jsonMode = program.opts().json;
+            const startTime = Date.now();
+            let reconnectCount = 0;
+            let eventCount = 0;
+            const enabledEvents = new Set(opts.events.split(",").map((e) => e.trim()));
+
+            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`;
+            }
+
+            /** Fire-and-forget webhook POST — never blocks event processing */
+            function postWebhook(data) {
+                if (!opts.webhook) return;
+                fetch(opts.webhook, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(data),
+                    signal: AbortSignal.timeout(5000),
+                }).catch((e) => {
+                    console.error(`[listen] Webhook failed: ${e.message}`);
+                });
+            }
+
+            // Setup save directory if --save flag provided
+            let saveDir = null;
+            if (opts.save) {
+                saveDir = resolve(opts.save);
+                if (!existsSync(saveDir)) mkdirSync(saveDir, { recursive: true });
+                info(`Saving messages to: ${saveDir}`);
+            }
+
+            /** Append event to JSONL file (one file per threadId) */
+            function saveEvent(data) {
+                if (!saveDir || !data.threadId) return;
+                const filename = `${data.threadId}.jsonl`;
+                const filepath = join(saveDir, filename);
+                const line = JSON.stringify({ ...data, savedAt: new Date().toISOString() }) + "\n";
+                try {
+                    appendFileSync(filepath, line, "utf-8");
+                } catch (e) {
+                    console.error(`[listen] Save failed: ${e.message}`);
+                }
+            }
+
+            /** Output event as JSON or human-readable, save locally, then post to webhook */
+            function emitEvent(data, humanMsg) {
+                eventCount++;
+                if (jsonMode) {
+                    console.log(JSON.stringify(data));
+                } else {
+                    info(humanMsg);
+                }
+                saveEvent(data);
+                postWebhook(data);
+            }
+
+            /** 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 !== THREAD_USER) return;
+                        if (opts.filter === "group" && msg.type !== THREAD_GROUP) return;
+                        if (!opts.self && msg.isSelf) return;
+
+                        const rawContent = msg.data.content;
+                        const isText = typeof rawContent === "string";
+                        const msgType = msg.data.msgType || null;
+                        // Build readable display: show type + title/href for non-text
+                        let displayContent;
+                        if (isText) {
+                            displayContent = rawContent;
+                        } else if (rawContent && typeof rawContent === "object") {
+                            const parts = [msgType || "attachment"];
+                            if (rawContent.title) parts.push(`"${rawContent.title}"`);
+                            if (rawContent.href) parts.push(rawContent.href);
+                            displayContent = `[${parts.join(" | ")}]`;
+                        } else {
+                            displayContent = `[${msgType || "non-text"}]`;
+                        }
+                        const data = {
+                            event: "message",
+                            msgId: msg.data.msgId,
+                            cliMsgId: msg.data.cliMsgId,
+                            threadId: msg.threadId,
+                            type: msg.type,
+                            isSelf: msg.isSelf,
+                            uidFrom: msg.data.uidFrom || null,
+                            dName: msg.data.dName || null,
+                            msgType,
+                            content: rawContent,
+                        };
+                        const dir = msg.isSelf ? "→" : "←";
+                        const typeLabel = msg.type === THREAD_USER ? "DM" : "GR";
+                        emitEvent(
+                            data,
+                            `${dir} [${typeLabel}] [${msg.threadId}] ${displayContent}  (msgId: ${msg.data.msgId})`,
+                        );
+                    });
+                }
+
+                // --- Friend events ---
+                if (enabledEvents.has("friend")) {
+                    api.listener.on("friend_event", async (event) => {
+                        const label = FRIEND_EVENT_LABELS[event.type] || "friend_unknown";
+                        const data = {
+                            event: label,
+                            threadId: event.threadId,
+                            isSelf: event.isSelf,
+                            data: event.data,
+                        };
+                        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}`);
+                            } catch (e) {
+                                error(`Auto-accept failed: ${e.message}`);
+                            }
+                        }
+                    });
+                }
+
+                // --- Group events ---
+                if (enabledEvents.has("group")) {
+                    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", (reaction) => {
+                        if (!opts.self && reaction.isSelf) return;
+                        emitEvent(
+                            {
+                                event: "reaction",
+                                threadId: reaction.threadId,
+                                isSelf: reaction.isSelf,
+                                isGroup: reaction.isGroup,
+                                data: reaction.data,
+                            },
+                            `Reaction in ${reaction.threadId}`,
+                        );
+                    });
+                }
+
+                // --- 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("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);
+                            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) => {
+                    // WS errors are followed by close/disconnect — don't crash
+                });
+            }
+
+            // --- 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 (saveDir) info(`Save dir: ${saveDir} (JSONL per thread)`);
+                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 {
+                        getApi().listener.stop();
+                    } catch (e) {
+                        console.error(`[listen] Stop failed: ${e.message}`);
+                    }
+                    info(`Stopped. Uptime: ${uptime()}, events: ${eventCount}, reconnects: ${reconnectCount}`);
+                    if (saveDir) info(`Messages saved to: ${saveDir}`);
+                    resolve();
+                });
+            });
+        });
+}

package/src/commands/login.js

@@ -0,0 +1,165 @@
+/**
+ * Login commands — QR login, credential login, logout, status, whoami.
+ */
+
+import { readFileSync, unlinkSync } from "fs";
+import {
+    loginWithQR,
+    loginWithCredentials,
+    extractCredentials,
+    clearSession,
+    isLoggedIn,
+    getApi,
+    getOwnId,
+} from "../core/zalo-client.js";
+import { saveCredentials, deleteCredentials } from "../core/credentials.js";
+import { addAccount, getActive, removeAccount } from "../core/accounts.js";
+import { maskProxy } from "../utils/proxy-helpers.js";
+import { displayQR, getQRPath } from "../utils/qr-display.js";
+import { startQrServer } from "../utils/qr-http-server.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerLoginCommands(program) {
+    program
+        .command("login")
+        .description("Login to Zalo via QR code scan or from exported credentials")
+        .option("-p, --proxy <url>", "Proxy URL (http/https/socks5://[user:pass@]host:port)")
+        .option("-n, --name <label>", "Friendly name for this account", "")
+        .option("--qr-url", "Start local HTTP server to view QR in browser (for VPS/headless)")
+        .option("-q, --qr-port <port>", "Port for QR HTTP server (default: 18927)", parseInt)
+        .option("--credentials <path>", "Login from exported credentials file (skip QR)")
+        .action(async (opts) => {
+            // Credential-based login (headless/CI)
+            if (opts.credentials) {
+                try {
+                    const raw = JSON.parse(readFileSync(opts.credentials, "utf-8"));
+                    const proxy = opts.proxy || raw.proxy || null;
+                    if (proxy) info(`Using proxy: ${maskProxy(proxy)}`);
+
+                    const { ownId } = await loginWithCredentials(raw, proxy);
+
+                    let displayName = opts.name || raw.name || "";
+                    try {
+                        const accountInfo = await getApi().fetchAccountInfo();
+                        displayName = accountInfo?.profile?.displayName || displayName || ownId;
+                    } catch {}
+
+                    const creds = extractCredentials();
+                    saveCredentials(ownId, creds);
+                    addAccount(ownId, displayName, proxy);
+                    success(`Logged in as ${displayName} (${ownId})`);
+                } catch (e) {
+                    error(`Login from credentials failed: ${e.message}`);
+                    process.exit(1);
+                }
+                return;
+            }
+
+            // QR-based login
+            const jsonMode = program.opts().json;
+            if (opts.proxy) info(`Using proxy: ${maskProxy(opts.proxy)}`);
+            if (!jsonMode) info("Generating QR code... Scan with Zalo mobile app.");
+
+            let qrServer = null;
+            try {
+                const { ownId } = await loginWithQR(opts.proxy, (event) => {
+                    displayQR(event);
+
+                    // Always start HTTP server for QR scanning (no flag needed)
+                    if (!qrServer) {
+                        qrServer = startQrServer(getQRPath(), opts.qrPort || 18927);
+                    }
+                });
+
+                // Fetch display name from Zalo profile
+                let displayName = opts.name || "";
+                try {
+                    const accountInfo = await getApi().fetchAccountInfo();
+                    displayName = accountInfo?.profile?.displayName || displayName || ownId;
+                } catch {}
+
+                const creds = extractCredentials();
+                saveCredentials(ownId, creds);
+                addAccount(ownId, displayName, opts.proxy);
+
+                if (jsonMode) {
+                    console.log(JSON.stringify({ event: "login_success", ownId, name: displayName }));
+                } else {
+                    success(`Logged in as ${displayName} (${ownId})`);
+                }
+            } catch (e) {
+                if (jsonMode) {
+                    console.log(JSON.stringify({ event: "login_error", message: e.message }));
+                } else {
+                    error(`Login failed: ${e.message}`);
+                }
+                process.exit(1);
+            } finally {
+                if (qrServer) qrServer.close();
+            }
+        });
+
+    program
+        .command("logout")
+        .description("Logout current account (keeps credentials for auto-login)")
+        .option("--purge", "Also delete saved credentials (must QR login again)")
+        .action((opts) => {
+            const active = getActive();
+            clearSession();
+
+            if (opts.purge && active) {
+                deleteCredentials(active.ownId);
+                removeAccount(active.ownId);
+                // Also remove QR image
+                try {
+                    unlinkSync(getQRPath());
+                } catch {}
+                success(`Logged out and purged credentials for ${active.name || active.ownId}`);
+            } else {
+                success("Logged out (credentials kept — will auto-login on next command)");
+                if (active) info(`To fully remove: zalo-agent account remove ${active.ownId}`);
+            }
+        });
+
+    program
+        .command("status")
+        .description("Show current login status")
+        .action(() => {
+            const active = getActive();
+            const data = {
+                loggedIn: isLoggedIn(),
+                ownId: getOwnId(),
+                activeAccount: active
+                    ? { ownId: active.ownId, name: active.name, proxy: maskProxy(active.proxy) }
+                    : null,
+            };
+            output(data, program.opts().json, () => {
+                if (data.loggedIn) {
+                    success(`Logged in as ${data.ownId}`);
+                    if (active) info(`Account: ${active.name || active.ownId} | Proxy: ${maskProxy(active.proxy)}`);
+                } else {
+                    info("Not logged in");
+                    if (active)
+                        info(`Active account: ${active.name || active.ownId} (will auto-login on next command)`);
+                }
+            });
+        });
+
+    program
+        .command("whoami")
+        .description("Show current user profile")
+        .action(async () => {
+            try {
+                const api = getApi();
+                const accountInfo = await api.fetchAccountInfo();
+                output(accountInfo, program.opts().json, () => {
+                    const p = accountInfo?.profile || {};
+                    info(`Name: ${p.displayName || "?"}`);
+                    info(`ID: ${p.userId || getOwnId()}`);
+                    info(`Phone: ${p.phoneNumber || "?"}`);
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}

package/src/commands/mcp.js

@@ -0,0 +1,219 @@
+/**
+ * MCP server command — starts a Model Context Protocol server over stdio transport.
+ * Allows Claude Code and other MCP clients to read/send Zalo messages via tool calls.
+ *
+ * IMPORTANT: All diagnostic output uses console.error() — stdout is the MCP transport channel.
+ */
+
+import { getApi, autoLogin, clearSession } from "../core/zalo-client.js";
+import { MessageBuffer } from "../mcp/message-buffer.js";
+import { ThreadFilter } from "../mcp/thread-filter.js";
+import { loadMCPConfig, parseDuration } from "../mcp/mcp-config.js";
+import { extractMessageText } from "../utils/extract-message-text.js";
+import { createMCPServer } from "../mcp/mcp-server.js";
+import { registerTools } from "../mcp/mcp-tools.js";
+import { createHTTPServer } from "../mcp/mcp-http-transport.js";
+import { ZaloNotifier } from "../mcp/notifier.js";
+import { ThreadNameCache } from "../mcp/thread-name-cache.js";
+import { autoDownloadMedia, isDownloadableMedia } from "../mcp/media-downloader.js";
+
+/** Zalo close code for duplicate web session — fatal, do not retry */
+const CLOSE_DUPLICATE = 3000;
+
+/**
+ * Normalize a raw zca-js message event into the buffer's message shape.
+ * @param {object} msg - Raw zca-js message event
+ * @returns {object} Normalized message
+ */
+function normalizeMessage(msg) {
+    const rawContent = msg.data.content;
+    const isText = typeof rawContent === "string";
+    return {
+        id: msg.data.msgId,
+        threadId: msg.threadId,
+        threadType: msg.type === 0 ? "dm" : "group",
+        senderId: msg.data.uidFrom || null,
+        senderName: msg.data.dName || null,
+        text: isText ? rawContent : extractMessageText(rawContent, msg.data.msgType),
+        timestamp: Date.now(),
+        type: isText ? "text" : msg.data.msgType || "attachment",
+        attachment:
+            !isText && rawContent
+                ? {
+                      type: msg.data.msgType,
+                      url: rawContent.href || null,
+                      description: rawContent.title || null,
+                  }
+                : null,
+        replyTo: null,
+    };
+}
+
+export function registerMCPCommands(program) {
+    const mcp = program.command("mcp").description("MCP server for AI agent integration");
+
+    mcp.command("start")
+        .description("Start MCP server (stdio or HTTP transport)")
+        .option("--config <path>", "Config file path (default: ~/.zalo-agent-cli/mcp-config.json)")
+        .option("--http <port>", "Use HTTP transport on specified port (default: stdio)")
+        .option("--auth <token>", "Bearer token for HTTP auth (only with --http)")
+        .option("--host <address>", "HTTP bind address (default: 127.0.0.1, only with --http)")
+        .action(async (opts) => {
+            // Perform login explicitly here — preAction hook skips "mcp"
+            try {
+                await autoLogin(false);
+            } catch (e) {
+                console.error("[mcp] Auto-login failed:", e.message);
+                process.exit(1);
+            }
+
+            // Load MCP config (config path option reserved for future use)
+            const config = loadMCPConfig();
+            console.error("[mcp] Config loaded:", JSON.stringify(config.limits));
+
+            // Build buffer + filter from config
+            const maxAge = parseDuration(config.limits?.bufferMaxAge ?? "2h");
+            const maxSize = config.limits?.bufferMaxSize ?? 500;
+            const buffer = new MessageBuffer(maxSize, maxAge);
+            const filter = new ThreadFilter(config);
+
+            // Build thread name cache (groups + friends → in-memory index)
+            const nameCache = new ThreadNameCache();
+            try {
+                await nameCache.init(getApi());
+            } catch (e) {
+                console.error("[mcp] Thread name cache init failed (non-fatal):", e.message);
+            }
+
+            // Start MCP server — stdio (default) or HTTP
+            let httpServer = null;
+            try {
+                if (opts.http) {
+                    const port = Number(opts.http);
+                    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                        console.error(`[mcp] Invalid port: ${opts.http}. Must be 1-65535.`);
+                        process.exit(1);
+                    }
+                    const deps = { api: getApi(), buffer, filter, config, nameCache };
+                    const authToken = opts.auth?.trim() || null;
+                    httpServer = createHTTPServer(registerTools, deps, port, authToken, opts.host || "127.0.0.1");
+                    console.error(`[mcp] HTTP server started on port ${port}`);
+                } else {
+                    await createMCPServer(getApi(), buffer, filter, config, nameCache);
+                }
+            } catch (e) {
+                console.error("[mcp] Failed to start MCP server:", e.message);
+                process.exit(1);
+            }
+
+            // Setup notifier (sends to Zalo group when agent is offline)
+            const notifier = new ZaloNotifier(getApi(), config);
+
+            let reconnectCount = 0;
+
+            /**
+             * Attach Zalo listener handlers to the current API instance.
+             * Must be called again after each re-login with the new API instance.
+             * @param {object} api - zca-js API instance
+             */
+            function attachListenerHandlers(api) {
+                api.listener.on("message", (msg) => {
+                    // Skip self-sent messages
+                    if (msg.isSelf) return;
+
+                    const normalized = normalizeMessage(msg);
+
+                    // Apply thread watch filter
+                    if (!filter.shouldWatch(normalized.threadId, normalized.threadType)) return;
+
+                    // Apply noise filter (stickers, system msgs, short emoji)
+                    if (!filter.shouldKeep(normalized)) return;
+
+                    // Auto-download media (images, audio, video) in background
+                    if (normalized.attachment?.url && isDownloadableMedia(normalized.type)) {
+                        const threadName = nameCache?.get(normalized.threadId)?.name || null;
+                        autoDownloadMedia(normalized, {
+                            downloadDir: config.media?.downloadDir || undefined,
+                            threadName,
+                        });
+                    }
+
+                    buffer.push(normalized.threadId, normalized);
+                    notifier.onMessage(normalized);
+                    console.error(`[mcp] Buffered ${normalized.threadType} msg from ${normalized.threadId}`);
+                });
+
+                api.listener.on("connected", () => {
+                    if (reconnectCount > 0) {
+                        console.error(`[mcp] Reconnected (#${reconnectCount})`);
+                    }
+                });
+
+                api.listener.on("disconnected", (code) => {
+                    console.error(`[mcp] Disconnected (code: ${code}). Auto-retrying...`);
+                });
+
+                api.listener.on("closed", async (code) => {
+                    if (code === CLOSE_DUPLICATE) {
+                        console.error("[mcp] Duplicate Zalo Web session detected. Exiting.");
+                        process.exit(1);
+                    }
+                    reconnectCount++;
+                    console.error(
+                        `[mcp] Connection closed (code: ${code}). Re-login in 5s... (reconnect #${reconnectCount})`,
+                    );
+                    await new Promise((r) => setTimeout(r, 5000));
+                    try {
+                        clearSession();
+                        await autoLogin(false);
+                        console.error("[mcp] Re-login successful. Restarting listener...");
+                        const newApi = getApi();
+                        attachListenerHandlers(newApi);
+                        newApi.listener.start({ retryOnClose: true });
+                    } catch (e) {
+                        console.error(`[mcp] Re-login failed: ${e.message}. Retrying in 30s...`);
+                        await new Promise((r) => setTimeout(r, 30000));
+                        try {
+                            clearSession();
+                            await autoLogin(false);
+                            const retryApi = getApi();
+                            attachListenerHandlers(retryApi);
+                            retryApi.listener.start({ retryOnClose: true });
+                            console.error("[mcp] Re-login successful on retry.");
+                        } catch (e2) {
+                            console.error(`[mcp] Re-login retry failed: ${e2.message}. Exiting.`);
+                            process.exit(1);
+                        }
+                    }
+                });
+
+                api.listener.on("error", () => {
+                    // WS errors are followed by close/disconnect — suppress to avoid noise
+                });
+            }
+
+            // Wire listener and start
+            try {
+                const api = getApi();
+                attachListenerHandlers(api);
+                api.listener.start({ retryOnClose: true });
+                console.error("[mcp] Zalo listener started. MCP server ready.");
+            } catch (e) {
+                console.error("[mcp] Failed to start listener:", e.message);
+                process.exit(1);
+            }
+
+            // Graceful shutdown on SIGINT
+            process.on("SIGINT", () => {
+                try {
+                    getApi().listener.stop();
+                } catch {}
+                notifier?.destroy();
+                httpServer?.close();
+                process.exit(0);
+            });
+
+            // Keep process alive (MCP server runs on stdio — process must not exit)
+            await new Promise(() => {});
+        });
+}