@ardennguyen/zalo-agent-cli 2.2.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ardennguyen/zalo-agent-cli",
-    "version": "2.2.1",
+    "version": "2.2.2",
     "description": "CLI tool for Zalo automation — multi-account, proxy, bank transfers, QR payments, Official Account API v3.0",
     "type": "module",
     "bin": {
@@ -77,6 +77,6 @@
     },
     "allowScripts": {
         "better-sqlite3@13.0.3": true,
-        "@ardennguyen/zalo-agent-cli@2.2.1": true
+        "@ardennguyen/zalo-agent-cli@2.2.2": true
     }
 }

package/src/commands/mcp.js

@@ -90,6 +90,38 @@ export function normalizeMessage(msg, info = null) {
     };
 }
 
+/**
+ * Fire-and-forget HTTP POST for an incoming buffered MCP message when a
+ * webhook URL is configured (`-w, --webhook <url>` or `webhook` in
+ * `mcp-config.json`). Never blocks or throws into the listener loop.
+ *
+ * @param {string|null} webhookUrl
+ * @param {object} message - Normalized message object
+ * @param {object} [extra] - Additional top-level fields (e.g. `{ accountId }`)
+ * @param {Function} [fetchFn=fetch] - Injectable fetch for unit testing
+ * @returns {Promise<boolean>} True when dispatched, false when skipped or failed
+ */
+export async function postMCPWebhook(webhookUrl, message, extra = {}, fetchFn = fetch) {
+    if (!webhookUrl) return false;
+    const payload = {
+        event: "message",
+        ...extra,
+        ...message,
+    };
+    try {
+        await fetchFn(webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(5000),
+        });
+        return true;
+    } catch (e) {
+        console.error(`[mcp] Webhook failed: ${e.message}`);
+        return false;
+    }
+}
+
 export function registerMCPCommands(program) {
     const mcp = program.command("mcp").description("MCP server for AI agent integration");
 
@@ -104,6 +136,10 @@ export function registerMCPCommands(program) {
         .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)")
+        .option(
+            "-w, --webhook <url>",
+            "POST each watched incoming message as JSON to this URL (or set webhook in mcp-config.json)",
+        )
         .option(
             "--no-delivered-receipts",
             "Do not acknowledge received messages as delivered (every Zalo client does; seen receipts are never sent)",
@@ -281,6 +317,10 @@ export function registerMCPCommands(program) {
 
             // Setup notifier (sends to Zalo group when agent is offline)
             const notifier = new ZaloNotifier(sessionApi, config);
+            const webhookUrl = opts.webhook?.trim() || config.webhook?.trim() || null;
+            if (webhookUrl) {
+                console.error(`[mcp] Webhook enabled: ${webhookUrl}`);
+            }
 
             // Delivered receipts: the same shared implementation `listen` uses
             // (AGENTS.md §13 -- the two listeners must not differ). Diagnostics
@@ -366,6 +406,7 @@ export function registerMCPCommands(program) {
                         if (!filter.shouldKeep(normalized)) continue;
                         buffer.push(normalized.threadId, normalized);
                         notifier.onMessage(normalized);
+                        postMCPWebhook(webhookUrl, normalized, { accountId: activeAcc.ownId });
                     }
                 },
             });
@@ -433,6 +474,7 @@ export function registerMCPCommands(program) {
 
                     buffer.push(normalized.threadId, normalized);
                     notifier.onMessage(normalized);
+                    postMCPWebhook(webhookUrl, normalized, { accountId: activeAcc.ownId });
                     console.error(`[mcp] Buffered ${normalized.threadType} msg from ${normalized.threadId}`);
                 });
 

package/src/mcp/mcp-config.js

@@ -16,6 +16,7 @@ export function getDefaultConfig() {
         watchThreads: ["dm:*", "group:*"],
         mode: "manual",
         triggerKeywords: ["@bot"],
+        webhook: null,
         notify: {
             enabled: false,
             thread: null,

package/src/mcp/mcp-http-transport.js

@@ -79,6 +79,46 @@ export function createHTTPServer(registerToolsFn, deps, port, authToken, host =
         }
     });
 
+    // Long-poll endpoint for zero-CPU event-driven wakeup (protected by auth middleware above)
+    app.get("/events/wait", async (req, res) => {
+        const rawTimeout = Number(req.query.timeout);
+        const timeoutSec = Number.isFinite(rawTimeout) && rawTimeout > 0 ? Math.min(rawTimeout, 300) : 60;
+        const threadId =
+            typeof req.query.threadId === "string" && req.query.threadId.trim() ? req.query.threadId.trim() : null;
+        const sinceRaw = req.query.since !== undefined ? Number(req.query.since) : undefined;
+        const since = Number.isFinite(sinceRaw) ? sinceRaw : undefined;
+
+        const ac = new AbortController();
+        res.on("close", () => ac.abort());
+
+        try {
+            const msg = await deps.buffer.waitForMessage({
+                threadId,
+                since,
+                timeoutMs: timeoutSec * 1000,
+                signal: ac.signal,
+            });
+            if (res.writableEnded) return;
+            if (msg) {
+                res.json({
+                    status: "message",
+                    message: msg,
+                    cursor: msg._cursor,
+                });
+            } else {
+                res.json({
+                    status: "timeout",
+                    message: null,
+                    cursor: deps.buffer.readCursor(),
+                });
+            }
+        } catch (err) {
+            if (!res.headersSent) {
+                res.status(500).json({ error: err.message });
+            }
+        }
+    });
+
     // Health check — no auth required
     app.get("/health", (req, res) => {
         res.json({

package/src/mcp/message-buffer.js

@@ -28,6 +28,8 @@ export class MessageBuffer {
         this._globalCursor = 0;
         /** @type {Map<string, { cursor: number, at: number }>} */
         this._readCursors = new Map();
+        /** @type {Set<{ threadId: string|null, resolve: Function, timer: NodeJS.Timeout }>} */
+        this._waiters = new Set();
     }
 
     /**
@@ -40,7 +42,8 @@ export class MessageBuffer {
     }
 
     /**
-     * Add message to thread buffer. Auto-evicts stale messages.
+     * Add message to thread buffer. Auto-evicts stale messages and wakes any
+     * long-poll waiters matching the thread.
      * @param {string} threadId
      * @param {object} message - Normalized message object
      */
@@ -54,6 +57,64 @@ export class MessageBuffer {
         thread.messages.push(message);
         thread.lastActivity = Date.now();
         this._evict(threadId);
+
+        for (const waiter of [...this._waiters]) {
+            if (!waiter.threadId || waiter.threadId === String(threadId)) {
+                this._waiters.delete(waiter);
+                clearTimeout(waiter.timer);
+                waiter.resolve(message);
+            }
+        }
+    }
+
+    /**
+     * Wait for the next buffered message (or return immediately if `since` is
+     * provided and a newer message is already in the buffer).
+     *
+     * @param {object} [opts]
+     * @param {string} [opts.threadId] - Optional thread filter
+     * @param {number} [opts.since] - Optional cursor; if a message > since already exists, resolves immediately
+     * @param {number} [opts.timeoutMs=60000] - Max wait duration in milliseconds
+     * @param {AbortSignal} [opts.signal] - Optional abort signal (e.g. when HTTP client disconnects)
+     * @returns {Promise<object|null>} The message object, or null on timeout/abort
+     */
+    waitForMessage({ threadId = null, since = undefined, timeoutMs = 60000, signal = undefined } = {}) {
+        if (since !== undefined && since !== null && Number.isFinite(Number(since))) {
+            const existing = this.read(threadId || undefined, Number(since), 1);
+            if (existing.messages.length > 0) {
+                return Promise.resolve(existing.messages[0]);
+            }
+        }
+        if (signal?.aborted) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve) => {
+            const waiter = {
+                threadId: threadId ? String(threadId) : null,
+                resolve: (msg) => {
+                    signal?.removeEventListener("abort", onAbort);
+                    resolve(msg);
+                },
+                timer: null,
+            };
+            const onAbort = () => {
+                if (this._waiters.delete(waiter)) {
+                    clearTimeout(waiter.timer);
+                    resolve(null);
+                }
+            };
+            waiter.timer = setTimeout(
+                () => {
+                    if (this._waiters.delete(waiter)) {
+                        signal?.removeEventListener("abort", onAbort);
+                        resolve(null);
+                    }
+                },
+                Math.max(1, Number(timeoutMs) || 60000),
+            );
+            signal?.addEventListener("abort", onAbort, { once: true });
+            this._waiters.add(waiter);
+        });
     }
 
     /**