zalo-agent-cli 1.5.1 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zalo-agent-cli",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "CLI tool for Zalo automation — multi-account, proxy, bank transfers, QR payments, Official Account API v3.0",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
-    "release": "npm version patch -m 'release: v%s' && git push origin main --tags"
+    "release": "npm version patch -m 'release: v%s' && git push origin main --tags",
+    "prepublishOnly": "npm run lint && npm test"
   },
   "keywords": [
     "zalo",

package/src/commands/listen.js

@@ -65,7 +65,10 @@ export function registerListenCommand(program) {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(data),
-                }).catch(() => {});
+                    signal: AbortSignal.timeout(5000),
+                }).catch((e) => {
+                    console.error(`[listen] Webhook failed: ${e.message}`);
+                });
             }
 
             // Setup save directory if --save flag provided
@@ -84,7 +87,9 @@ export function registerListenCommand(program) {
                 const line = JSON.stringify({ ...data, savedAt: new Date().toISOString() }) + "\n";
                 try {
                     appendFileSync(filepath, line, "utf-8");
-                } catch {}
+                } catch (e) {
+                    console.error(`[listen] Save failed: ${e.message}`);
+                }
             }
 
             /** Output event as JSON or human-readable, save locally, then post to webhook */
@@ -276,7 +281,9 @@ export function registerListenCommand(program) {
                 process.on("SIGINT", () => {
                     try {
                         getApi().listener.stop();
-                    } catch {}
+                    } 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/mcp.js

@@ -14,7 +14,7 @@ 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 { autoDownloadImage } from "../mcp/image-downloader.js";
+import { autoDownloadMedia, isDownloadableMedia } from "../mcp/media-downloader.js";
 
 /** Zalo close code for duplicate web session — fatal, do not retry */
 const CLOSE_DUPLICATE = 3000;
@@ -56,6 +56,7 @@ export function registerMCPCommands(program) {
         .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 {
@@ -84,11 +85,17 @@ export function registerMCPCommands(program) {
             }
 
             // 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 };
-                    createHTTPServer(registerTools, deps, port, opts.auth || null);
+                    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);
@@ -121,11 +128,11 @@ export function registerMCPCommands(program) {
                     // Apply noise filter (stickers, system msgs, short emoji)
                     if (!filter.shouldKeep(normalized)) return;
 
-                    // Auto-download images in background (non-blocking)
-                    if (normalized.attachment?.url) {
+                    // Auto-download media (images, audio, video) in background
+                    if (normalized.attachment?.url && isDownloadableMedia(normalized.type)) {
                         const threadName = nameCache?.get(normalized.threadId)?.name || null;
-                        autoDownloadImage(normalized, {
-                            downloadDir: config.images?.downloadDir || undefined,
+                        autoDownloadMedia(normalized, {
+                            downloadDir: config.media?.downloadDir || undefined,
                             threadName,
                         });
                     }
@@ -195,6 +202,14 @@ export function registerMCPCommands(program) {
                 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(() => {});
         });

package/src/mcp/mcp-config.js

@@ -26,8 +26,8 @@ export function getDefaultConfig() {
             bufferMaxAge: "2h",
             bufferMaxSize: 500,
         },
-        images: {
-            downloadDir: null, // default: ~/.zalo-agent-cli/images/
+        media: {
+            downloadDir: null, // default: ~/.zalo-agent-cli/media/
             autoOpen: true,
         },
     };
@@ -48,7 +48,7 @@ export function loadMCPConfig() {
             ...saved,
             notify: { ...defaults.notify, ...saved.notify },
             limits: { ...defaults.limits, ...saved.limits },
-            images: { ...defaults.images, ...saved.images },
+            media: { ...defaults.media, ...saved.media },
         };
     } catch {
         // File doesn't exist or invalid JSON — use defaults

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

@@ -4,9 +4,16 @@
  */
 
 import express from "express";
+import { timingSafeEqual } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf8"));
+
 /**
  * Create HTTP MCP server with optional bearer token auth.
  * @param {Function} registerToolsFn - Registers tools on a McpServer instance
@@ -15,7 +22,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
  * @param {string|null} authToken - Bearer token (null = no auth)
  * @returns {import("http").Server}
  */
-export function createHTTPServer(registerToolsFn, deps, port, authToken) {
+export function createHTTPServer(registerToolsFn, deps, port, authToken, host = "127.0.0.1") {
     const app = express();
     app.use(express.json());
 
@@ -23,8 +30,10 @@ export function createHTTPServer(registerToolsFn, deps, port, authToken) {
     if (authToken) {
         app.use((req, res, next) => {
             if (req.path === "/health") return next();
-            const token = req.headers.authorization?.slice(7); // strip "Bearer "
-            if (token !== authToken) {
+            const token = req.headers.authorization?.slice(7) || "";
+            const expected = Buffer.from(authToken, "utf8");
+            const received = Buffer.from(token, "utf8");
+            if (expected.length !== received.length || !timingSafeEqual(expected, received)) {
                 return res.status(401).json({ error: "Unauthorized" });
             }
             next();
@@ -34,7 +43,7 @@ export function createHTTPServer(registerToolsFn, deps, port, authToken) {
     // MCP endpoint — stateless, fresh server+transport per request
     app.post("/mcp", async (req, res) => {
         try {
-            const server = new McpServer({ name: "zalo-agent", version: "1.0.0" });
+            const server = new McpServer({ name: "zalo-agent", version: pkg.version });
             registerToolsFn(server, deps.api, deps.buffer, deps.filter, deps.config, deps.nameCache);
 
             const transport = new StreamableHTTPServerTransport({
@@ -69,7 +78,7 @@ export function createHTTPServer(registerToolsFn, deps, port, authToken) {
         });
     });
 
-    return app.listen(port, "0.0.0.0", () => {
-        console.error(`MCP HTTP server listening on port ${port}`);
+    return app.listen(port, host, () => {
+        console.error(`MCP HTTP server listening on ${host}:${port}`);
     });
 }

package/src/mcp/mcp-server.js

@@ -3,10 +3,16 @@
  * Creates and connects the McpServer instance for Claude Code integration.
  */
 
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerTools } from "./mcp-tools.js";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf8"));
+
 /**
  * Create and start MCP server with stdio transport.
  * All logs MUST use console.error() — stdout is reserved for MCP protocol.
@@ -20,7 +26,7 @@ import { registerTools } from "./mcp-tools.js";
 export async function createMCPServer(api, buffer, filter, config, nameCache) {
     const server = new McpServer({
         name: "zalo-agent",
-        version: "1.0.0",
+        version: pkg.version,
     });
 
     registerTools(server, api, buffer, filter, config, nameCache);

package/src/mcp/mcp-tools.js

@@ -1,10 +1,10 @@
 /**
  * MCP tool registrations for Zalo message access and sending.
- * Registers 6 tools: zalo_get_messages, zalo_send_message, zalo_list_threads, zalo_search_threads, zalo_mark_read, zalo_view_image.
+ * Registers 6 tools: zalo_get_messages, zalo_send_message, zalo_list_threads, zalo_search_threads, zalo_mark_read, zalo_view_media.
  */
 
 import { z } from "zod";
-import { downloadImage, openFile } from "./image-downloader.js";
+import { downloadMedia, openFile } from "./media-downloader.js";
 
 /** Thread type constants matching zca-js ThreadType enum */
 const THREAD_USER = 0;
@@ -117,11 +117,9 @@ export function registerTools(server, api, buffer, filter, config, nameCache) {
         async ({ type }) => {
             try {
                 const stats = buffer.getStats(0);
-                // Enrich each stat entry with threadType by peeking at the first buffered message.
-                // buffer._threads is a Map<threadId, { messages: Array, lastActivity: number }>
+                // Enrich each stat entry with threadType and thread name
                 const enriched = stats.map((t) => {
-                    const thread = buffer._threads.get(t.threadId);
-                    const threadType = thread?.messages?.[0]?.threadType ?? "unknown";
+                    const threadType = buffer.getThreadType(t.threadId) ?? "unknown";
                     const cached = nameCache?.get(t.threadId);
                     return {
                         ...t,
@@ -195,39 +193,38 @@ export function registerTools(server, api, buffer, filter, config, nameCache) {
         },
     );
 
-    // --- zalo_view_image ---
-    const imgConfig = config.images || {};
+    // --- zalo_view_media ---
+    const mediaConfig = config.media || {};
     server.registerTool(
-        "zalo_view_image",
+        "zalo_view_media",
         {
-            title: "View Zalo Image",
+            title: "View Zalo Media",
             description:
-                "Open a Zalo image with the system viewer. Images are auto-downloaded when received, " +
-                "organized by thread folder with date/sender metadata filenames. " +
+                "Open a Zalo media file (image, audio, video) with the system viewer. " +
+                "Media is auto-downloaded when received, organized by thread folder with date/sender metadata filenames. " +
                 "If not yet downloaded, downloads first then opens.",
             inputSchema: z.object({
-                messageId: z.string().describe("Message ID from zalo_get_messages that has an image attachment"),
+                messageId: z.string().describe("Message ID from zalo_get_messages that has a media attachment"),
                 threadId: z.string().optional().describe("Thread ID to search in. Omit to search all threads."),
                 open: z
                     .boolean()
-                    .default(imgConfig.autoOpen ?? true)
-                    .describe("Open image with system viewer"),
+                    .default(mediaConfig.autoOpen ?? true)
+                    .describe("Open media with system viewer"),
             }),
         },
         async ({ messageId, threadId, open }) => {
             try {
-                // Find the message in the buffer by ID
                 const allMessages = buffer.read(threadId, 0, 9999).messages;
                 const message = allMessages.find((m) => m.id === messageId);
                 if (!message) return err(`Message ${messageId} not found in buffer`);
-                if (!message.attachment?.url) return err(`Message ${messageId} has no image attachment`);
+                if (!message.attachment?.url) return err(`Message ${messageId} has no media attachment`);
 
                 // Use local file if already auto-downloaded, otherwise download now
                 let localPath = message.attachment.localPath;
                 if (!localPath) {
                     const threadName = nameCache?.get(message.threadId)?.name || null;
-                    const result = await downloadImage(message, {
-                        downloadDir: imgConfig.downloadDir || undefined,
+                    const result = await downloadMedia(message, {
+                        downloadDir: mediaConfig.downloadDir || undefined,
                         autoOpen: false,
                         threadName,
                     });
@@ -236,9 +233,9 @@ export function registerTools(server, api, buffer, filter, config, nameCache) {
 
                 if (open) openFile(localPath);
 
-                return ok({ success: true, path: localPath });
+                return ok({ success: true, path: localPath, mediaType: message.type });
             } catch (e) {
-                console.error("[mcp-tools] zalo_view_image error:", e.message);
+                console.error("[mcp-tools] zalo_view_media error:", e.message);
                 return err(e.message);
             }
         },

package/src/mcp/{image-downloader.js → media-downloader.js}

@@ -1,21 +1,54 @@
 /**
- * Download Zalo images to local filesystem, organized by thread name.
+ * Download Zalo media (images, audio, video) to local filesystem, organized by thread name.
  * Folder structure: {downloadDir}/{threadName}/{date}_{time}_{sender}_{msgId}.{ext}
- * Cross-platform: opens images with system viewer (open/xdg-open/start).
+ * Cross-platform: opens media with system viewer (open/xdg-open/start).
  */
 
 import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { platform } from "os";
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { CONFIG_DIR } from "../core/credentials.js";
 
 /** Default download directory when not configured */
-const DEFAULT_DIR = join(CONFIG_DIR, "images");
+const DEFAULT_DIR = join(CONFIG_DIR, "media");
 
 /** Characters unsafe for filesystem paths — stripped from folder/file names */
 const UNSAFE_CHARS = /[/\\:*?"<>|]/g;
 
+/** Message types that have downloadable attachments */
+const DOWNLOADABLE_TYPES = new Set(["image", "video", "audio", "voice", "gif", "file"]);
+
+/** Extension lookup by content-type prefix */
+const CONTENT_TYPE_MAP = {
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/bmp": "bmp",
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/mp4": "m4a",
+    "audio/aac": "aac",
+    "audio/ogg": "ogg",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/quicktime": "mov",
+};
+
+/** Fallback extension by message type when URL and content-type give no clue */
+const TYPE_DEFAULT_EXT = {
+    image: "jpg",
+    audio: "mp3",
+    voice: "mp3",
+    video: "mp4",
+    gif: "gif",
+    file: "bin",
+};
+
 /**
  * Sanitize a string for use as a filesystem name.
  * @param {string} name
@@ -26,21 +59,32 @@ function sanitize(name) {
 }
 
 /**
- * Guess file extension from URL or content-type header.
+ * Guess file extension from URL, content-type, or message type.
  * @param {string} url
  * @param {string} [contentType]
+ * @param {string} [msgType] - Normalized message type (image, audio, video, etc.)
  * @returns {string}
  */
-function guessExtension(url, contentType) {
+function guessExtension(url, contentType, msgType) {
     // Try content-type first
     if (contentType) {
-        const match = contentType.match(/image\/(jpeg|jpg|png|gif|webp|bmp)/i);
-        if (match) return match[1] === "jpeg" ? "jpg" : match[1].toLowerCase();
+        const ct = contentType.split(";")[0].trim().toLowerCase();
+        if (CONTENT_TYPE_MAP[ct]) return CONTENT_TYPE_MAP[ct];
     }
-    // Try URL path
-    const urlMatch = url.match(/\.(jpeg|jpg|png|gif|webp|bmp)(\?|$)/i);
+    // Try URL path extension
+    const urlMatch = url.match(/\.(jpeg|jpg|png|gif|webp|bmp|mp3|m4a|aac|ogg|wav|mp4|webm|mov)(\?|$)/i);
     if (urlMatch) return urlMatch[1] === "jpeg" ? "jpg" : urlMatch[1].toLowerCase();
-    return "jpg"; // safe default for Zalo CDN
+    // Fallback by message type
+    return TYPE_DEFAULT_EXT[msgType] || "bin";
+}
+
+/**
+ * Check if a message type is downloadable media.
+ * @param {string} type - Normalized message type
+ * @returns {boolean}
+ */
+export function isDownloadableMedia(type) {
+    return DOWNLOADABLE_TYPES.has(type);
 }
 
 /**
@@ -79,46 +123,46 @@ function buildFileName(message, ext) {
  * @param {string} filePath
  */
 export function openFile(filePath) {
+    const isWin = platform() === "win32";
     const cmds = { darwin: "open", win32: "start", linux: "xdg-open" };
     const cmd = cmds[platform()] || "xdg-open";
-    // Use double quotes for paths with spaces; detach so CLI doesn't block
-    exec(`${cmd} "${filePath}"`, (err) => {
-        if (err) console.error(`[image-dl] Failed to open viewer: ${err.message}`);
+    // Windows "start" is a cmd.exe builtin — needs shell: true
+    execFile(cmd, isWin ? ["", filePath] : [filePath], { shell: isWin }, (err) => {
+        if (err) console.error(`[media-dl] Failed to open viewer: ${err.message}`);
     });
 }
 
 /**
- * Auto-download image in background when a message arrives.
+ * Auto-download media in background when a message arrives.
  * Non-blocking — fires and forgets. Mutates message.attachment.localPath on success.
  * @param {object} message - Normalized message (will be mutated with localPath)
  * @param {object} [options]
  * @param {string} [options.downloadDir] - Base download directory
  * @param {string} [options.threadName] - Thread display name from cache
  */
-export function autoDownloadImage(message, options = {}) {
+export function autoDownloadMedia(message, options = {}) {
     if (!message.attachment?.url) return;
-    // Fire-and-forget: download in background, don't block message processing
-    downloadImage(message, { ...options, autoOpen: false }).then(
+    downloadMedia(message, { ...options, autoOpen: false }).then(
         (result) => {
             message.attachment.localPath = result.path;
-            console.error(`[image-dl] Saved: ${result.path}`);
+            console.error(`[media-dl] Saved: ${result.path}`);
         },
         (err) => {
-            console.error(`[image-dl] Auto-download failed: ${err.message}`);
+            console.error(`[media-dl] Auto-download failed: ${err.message}`);
         },
     );
 }
 
 /**
- * Download an image from URL and save to organized local folder.
+ * Download media from URL and save to organized local folder.
  * @param {object} message - Normalized message with attachment.url
  * @param {object} [options]
  * @param {string} [options.downloadDir] - Base download directory
- * @param {boolean} [options.autoOpen] - Open image after download
+ * @param {boolean} [options.autoOpen] - Open media with system viewer after download
  * @param {string} [options.threadName] - Thread display name from cache
- * @returns {Promise<{ success: boolean, path: string, folder: string, fileName: string }>}
+ * @returns {Promise<{ success: boolean, path: string, folder: string, fileName: string, mediaType: string }>}
  */
-export async function downloadImage(message, options = {}) {
+export async function downloadMedia(message, options = {}) {
     const url = message.attachment?.url;
     if (!url) throw new Error("Message has no attachment URL");
 
@@ -127,22 +171,21 @@ export async function downloadImage(message, options = {}) {
     const folderPath = join(baseDir, folder);
     mkdirSync(folderPath, { recursive: true });
 
-    // Fetch image from Zalo CDN
     const response = await fetch(url);
     if (!response.ok) throw new Error(`Download failed: HTTP ${response.status}`);
 
     const contentType = response.headers.get("content-type") || "";
-    const ext = guessExtension(url, contentType);
+    const msgType = message.type || "file";
+    const ext = guessExtension(url, contentType, msgType);
     const fileName = buildFileName(message, ext);
     const filePath = join(folderPath, fileName);
 
     const buffer = Buffer.from(await response.arrayBuffer());
     writeFileSync(filePath, buffer);
 
-    // Auto-open with system viewer if configured
     if (options.autoOpen) {
         openFile(filePath);
     }
 
-    return { success: true, path: filePath, folder, fileName };
+    return { success: true, path: filePath, folder, fileName, mediaType: msgType };
 }

package/src/mcp/media-downloader.test.js

@@ -0,0 +1,45 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { isDownloadableMedia } from "./media-downloader.js";
+
+describe("isDownloadableMedia", () => {
+    it("returns true for image type", () => {
+        assert.ok(isDownloadableMedia("image"));
+    });
+
+    it("returns true for audio type", () => {
+        assert.ok(isDownloadableMedia("audio"));
+    });
+
+    it("returns true for voice type", () => {
+        assert.ok(isDownloadableMedia("voice"));
+    });
+
+    it("returns true for video type", () => {
+        assert.ok(isDownloadableMedia("video"));
+    });
+
+    it("returns true for gif type", () => {
+        assert.ok(isDownloadableMedia("gif"));
+    });
+
+    it("returns true for file type", () => {
+        assert.ok(isDownloadableMedia("file"));
+    });
+
+    it("returns false for text type", () => {
+        assert.equal(isDownloadableMedia("text"), false);
+    });
+
+    it("returns false for link type", () => {
+        assert.equal(isDownloadableMedia("link"), false);
+    });
+
+    it("returns false for sticker type", () => {
+        assert.equal(isDownloadableMedia("sticker"), false);
+    });
+
+    it("returns false for undefined type", () => {
+        assert.equal(isDownloadableMedia(undefined), false);
+    });
+});

package/src/mcp/message-buffer.js

@@ -94,6 +94,16 @@ export class MessageBuffer {
         return stats;
     }
 
+    /**
+     * Get thread type from first buffered message.
+     * @param {string} threadId
+     * @returns {string|null}
+     */
+    getThreadType(threadId) {
+        const thread = this._threads.get(threadId);
+        return thread?.messages?.[0]?.threadType ?? null;
+    }
+
     /**
      * Evict messages that exceed maxSize or maxAge for a given thread.
      * @param {string} threadId

package/src/mcp/message-buffer.test.js

@@ -265,6 +265,32 @@ describe("MessageBuffer getStats", () => {
     });
 });
 
+describe("MessageBuffer getThreadType", () => {
+    it("returns threadType from first buffered message", () => {
+        const buf = new MessageBuffer();
+        buf.push("t1", { text: "hi", threadType: "dm", timestamp: Date.now() });
+        buf.push("t1", { text: "hey", threadType: "dm", timestamp: Date.now() });
+        assert.equal(buf.getThreadType("t1"), "dm");
+    });
+
+    it("returns null for unknown thread", () => {
+        const buf = new MessageBuffer();
+        assert.equal(buf.getThreadType("nonexistent"), null);
+    });
+
+    it("returns null when thread exists but messages have no threadType", () => {
+        const buf = new MessageBuffer();
+        buf.push("t1", { text: "hi", timestamp: Date.now() });
+        assert.equal(buf.getThreadType("t1"), null);
+    });
+
+    it("returns group for group thread", () => {
+        const buf = new MessageBuffer();
+        buf.push("g1", { text: "hello", threadType: "group", timestamp: Date.now() });
+        assert.equal(buf.getThreadType("g1"), "group");
+    });
+});
+
 describe("MessageBuffer edge cases", () => {
     it("empty read on fresh buffer returns empty array and cursor 0", () => {
         const buf = new MessageBuffer();

package/src/mcp/notifier.js

@@ -6,7 +6,16 @@
 import { parseDuration } from "./mcp-config.js";
 
 /** Emoji prefix per message type for notification previews */
-const TYPE_EMOJI = { text: "💬", image: "📷", file: "📎", link: "🔗", video: "🎬", audio: "🎵", gif: "🎞️" };
+const TYPE_EMOJI = {
+    text: "💬",
+    image: "📷",
+    file: "📎",
+    link: "🔗",
+    video: "🎬",
+    audio: "🎵",
+    voice: "🎤",
+    gif: "🎞️",
+};
 
 /** Vietnamese label per message type for notification breakdown */
 const TYPE_LABEL = {
@@ -16,6 +25,7 @@ const TYPE_LABEL = {
     link: "link",
     video: "video",
     audio: "audio",
+    voice: "voice",
     gif: "gif",
 };
 

package/src/mcp/notifier.test.js

@@ -191,6 +191,36 @@ describe("ZaloNotifier _flush notification format", () => {
         await wait(30);
         assert.ok(calls[0].text.includes("2"));
     });
+
+    it("shows type breakdown with mixed media types", async () => {
+        const { api, calls } = makeSpy();
+        const n = new ZaloNotifier(api, enabledConfig());
+        n.onMessage(dmMsg("hello", { type: "text" }));
+        n.onMessage(dmMsg("[image]", { type: "image" }));
+        n.onMessage(dmMsg("[voice]", { type: "voice" }));
+        await wait(30);
+        assert.ok(calls[0].text.includes("1 text"));
+        assert.ok(calls[0].text.includes("1 ảnh"));
+        assert.ok(calls[0].text.includes("1 voice"));
+    });
+
+    it("uses emoji prefix for audio and video types", async () => {
+        const { api, calls } = makeSpy();
+        const n = new ZaloNotifier(api, enabledConfig());
+        n.onMessage(dmMsg("[audio]", { type: "audio", senderName: "Bob" }));
+        n.onMessage(dmMsg("[video]", { type: "video", senderName: "Eve" }));
+        await wait(30);
+        assert.ok(calls[0].text.includes("🎵"));
+        assert.ok(calls[0].text.includes("🎬"));
+    });
+
+    it("uses microphone emoji for voice messages", async () => {
+        const { api, calls } = makeSpy();
+        const n = new ZaloNotifier(api, enabledConfig());
+        n.onMessage(dmMsg("[voice]", { type: "voice" }));
+        await wait(30);
+        assert.ok(calls[0].text.includes("🎤"));
+    });
 });
 
 describe("ZaloNotifier cooldown batching", () => {