zalo-agent-cli 1.0.24 → 1.0.26

package/README.md

@@ -160,7 +160,7 @@ zalo-agent whoami
 
 | Command | Description |
 |---------|-------------|
-| `msg send <threadId> <text> [-t 0\|1]` | Send text message |
+| `msg send <threadId> <text> [-t 0\|1] [--md] [--style specs...]` | Send text message (with formatting) |
 | `msg send-image <threadId> <paths...> [-t 0\|1] [-m caption]` | Send images |
 | `msg send-file <threadId> <paths...> [-t 0\|1] [-m caption]` | Send files |
 | `msg send-card <threadId> <userId> [-t 0\|1] [--phone NUM]` | Send contact card |
@@ -174,6 +174,30 @@ zalo-agent whoami
 
 > `-t 0` = User (default), `-t 1` = Group
 
+**Text formatting with `--md` (markdown mode):**
+```bash
+zalo-agent msg send <threadId> "**Bold** *Italic* __Underline__ ~~Strike~~ {red:Red} {big:BIG}" --md
+```
+
+| Syntax | Style |
+|--------|-------|
+| `**text**` | Bold |
+| `*text*` | Italic |
+| `__text__` | Underline |
+| `~~text~~` | Strikethrough |
+| `{red:text}` | Red text |
+| `{orange:text}` | Orange text |
+| `{yellow:text}` | Yellow text |
+| `{green:text}` | Green text |
+| `{big:text}` | Large font |
+| `{small:text}` | Small font |
+
+**Manual style with `--style` (for agents/automation):**
+```bash
+# Format: start:len:style — style names: bold, italic, underline, strikethrough, red, orange, yellow, green, big, small
+zalo-agent msg send <threadId> "Hello World" --style 0:5:bold 6:5:italic
+```
+
 #### Friends (`friend`)
 
 | Command | Description |
@@ -260,6 +284,37 @@ zalo-agent poll vote <pollId> 123 456
 zalo-agent poll lock <pollId>
 ```
 
+#### Reminders (`reminder`)
+
+| Command | Description |
+|---------|-------------|
+| `reminder create <threadId> <title> [-t 0\|1] [--time "YYYY-MM-DD HH:mm"] [--repeat mode] [--emoji]` | Create a reminder |
+| `reminder list <threadId> [-t 0\|1] [-n count]` | List reminders |
+| `reminder info <reminderId>` | View reminder details (group only) |
+| `reminder responses <reminderId>` | View who accepted/rejected (group only) |
+| `reminder edit <reminderId> <threadId> <title> [-t 0\|1] [--time] [--repeat] [--emoji]` | Edit a reminder |
+| `reminder remove <reminderId> <threadId> [-t 0\|1]` | Remove a reminder |
+
+**Repeat modes:** `none`, `daily`, `weekly`, `monthly`
+
+**Example:**
+```bash
+# Create a daily reminder in a group at 9:00 AM tomorrow
+zalo-agent reminder create <groupId> "Standup meeting" -t 1 --time "2026-03-16 09:00" --repeat daily
+
+# List reminders in a group
+zalo-agent reminder list <groupId> -t 1
+
+# View who responded
+zalo-agent reminder responses <reminderId>
+
+# Edit reminder title and time
+zalo-agent reminder edit <reminderId> <groupId> "New title" -t 1 --time "2026-03-17 10:00"
+
+# Remove a reminder
+zalo-agent reminder remove <reminderId> <groupId> -t 1
+```
+
 #### Accounts (`account`)
 
 | Command | Description |
@@ -515,6 +570,27 @@ zalo-agent poll vote <pollId> 123 456
 zalo-agent poll lock <pollId>
 ```
 
+#### 7. Nhắc nhở (Reminder)
+
+```bash
+# Tạo nhắc nhở hàng ngày trong nhóm lúc 9h sáng
+zalo-agent reminder create <groupId> "Họp standup" -t 1 --time "2026-03-16 09:00" --repeat daily
+
+# Xem danh sách nhắc nhở
+zalo-agent reminder list <groupId> -t 1
+
+# Xem ai đã chấp nhận/từ chối
+zalo-agent reminder responses <reminderId>
+
+# Sửa nhắc nhở
+zalo-agent reminder edit <reminderId> <groupId> "Tiêu đề mới" -t 1 --time "2026-03-17 10:00"
+
+# Xóa nhắc nhở
+zalo-agent reminder remove <reminderId> <groupId> -t 1
+```
+
+Chế độ lặp: `none` (không lặp), `daily` (hàng ngày), `weekly` (hàng tuần), `monthly` (hàng tháng)
+
 ### Danh sách lệnh
 
 Xem đầy đủ tại [phần tiếng Anh](#command-reference) phía trên. Tất cả lệnh đều giống nhau.

package/package.json

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

package/src/commands/msg.js

@@ -7,16 +7,99 @@ import { resolve } from "path";
 import { getApi } from "../core/zalo-client.js";
 import { success, error, info, output } from "../utils/output.js";
 
+/**
+ * TextStyle codes matching zca-js TextStyle enum.
+ * Used for --style option and markdown parsing.
+ */
+const TEXT_STYLES = {
+    bold: "b",
+    b: "b",
+    italic: "i",
+    i: "i",
+    underline: "u",
+    u: "u",
+    strikethrough: "s",
+    s: "s",
+    red: "c_db342e",
+    orange: "c_f27806",
+    yellow: "c_f7b503",
+    green: "c_15a85f",
+    small: "f_13",
+    big: "f_18",
+};
+
+/**
+ * Parse markdown-like syntax from message text into plain text + styles array.
+ * Supports: **bold**, *italic*, __underline__, ~~strikethrough~~,
+ *           {red:text}, {orange:text}, {green:text}, {yellow:text},
+ *           {big:text}, {small:text}
+ */
+function parseMarkdownStyles(input) {
+    const styles = [];
+    let plain = input;
+
+    // Process markdown patterns (order matters: ** before *)
+    const patterns = [
+        { regex: /\*\*(.+?)\*\*/g, st: "b" },
+        { regex: /\*(.+?)\*/g, st: "i" },
+        { regex: /__(.+?)__/g, st: "u" },
+        { regex: /~~(.+?)~~/g, st: "s" },
+        { regex: /\{(red|orange|yellow|green|big|small):(.+?)\}/g, st: null },
+    ];
+
+    for (const p of patterns) {
+        let match;
+        // Re-run from scratch each time since offsets shift
+        while ((match = p.regex.exec(plain)) !== null) {
+            const fullMatch = match[0];
+            const start = match.index;
+            let content, st;
+            if (p.st === null) {
+                // Color/size pattern: {color:text}
+                st = TEXT_STYLES[match[1]];
+                content = match[2];
+            } else {
+                st = p.st;
+                content = match[1];
+            }
+            // Replace the markdown syntax with plain content
+            plain = plain.slice(0, start) + content + plain.slice(start + fullMatch.length);
+            styles.push({ start, len: content.length, st });
+            // Reset regex since string changed
+            p.regex.lastIndex = start + content.length;
+        }
+    }
+
+    return { plain, styles };
+}
+
+/**
+ * Parse manual style specs: "start:len:style" → { start, len, st }
+ * Style names: bold, italic, underline, strikethrough, red, orange, yellow, green, big, small
+ */
+function parseStyleSpecs(specs) {
+    return specs
+        .map((spec) => {
+            const [start, len, style] = spec.split(":");
+            const st = TEXT_STYLES[style];
+            if (!st) return null;
+            return { start: Number(start), len: Number(len), st };
+        })
+        .filter(Boolean);
+}
+
 export function registerMsgCommands(program) {
     const msg = program.command("msg").description("Send and manage messages");
 
     msg.command("send <threadId> <message>")
-        .description("Send a text message")
+        .description("Send a text message with optional formatting")
         .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
         .option(
             "--mention <specs...>",
             "Mention users in group message. Format: pos:userId:len (e.g. 0:USER_ID:5). Use userId=-1 for @All.",
         )
+        .option("--style <specs...>", "Text styles. Format: start:len:style (e.g. 0:5:bold 6:5:italic)")
+        .option("--md", "Parse markdown-like formatting: **bold** *italic* __underline__ ~~strike~~ {red:text}")
         .option(
             "--react <icon>",
             "Auto-react to sent message. Codes: :> (haha), /-heart (heart), /-strong (like), :o (wow), :-(( (cry), :-h (angry)",
@@ -29,8 +112,27 @@ export function registerMsgCommands(program) {
                     return { pos: Number(pos), uid, len: Number(len) };
                 });
 
-                // Build message content object if mentions exist
-                const msgContent = mentions.length > 0 ? { msg: message, mentions } : message;
+                // Parse text styles
+                let styles = [];
+                let finalMsg = message;
+
+                if (opts.md) {
+                    // Markdown-like parsing: **bold** *italic* __underline__ ~~strike~~
+                    const parsed = parseMarkdownStyles(message);
+                    finalMsg = parsed.plain;
+                    styles = parsed.styles;
+                }
+
+                if (opts.style) {
+                    // Manual style specs: start:len:style
+                    styles = styles.concat(parseStyleSpecs(opts.style));
+                }
+
+                // Build message content
+                const hasExtras = mentions.length > 0 || styles.length > 0;
+                const msgContent = hasExtras
+                    ? { msg: finalMsg, ...(mentions.length > 0 && { mentions }), ...(styles.length > 0 && { styles }) }
+                    : finalMsg;
 
                 const cliMsgId = String(Date.now());
                 const result = await getApi().sendMessage(msgContent, threadId, Number(opts.type));

package/src/commands/reminder.js

@@ -0,0 +1,195 @@
+/**
+ * Reminder commands — create, list, info, edit, remove reminders in users/groups.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+/** Repeat mode labels matching zca-js ReminderRepeatMode enum. */
+const REPEAT_MODES = { none: 0, daily: 1, weekly: 2, monthly: 3 };
+const REPEAT_LABELS = { 0: "None", 1: "Daily", 2: "Weekly", 3: "Monthly" };
+
+/** Parse a datetime string into Unix timestamp (ms). Accepts ISO or "YYYY-MM-DD HH:mm". */
+function parseTime(str) {
+    // Try "YYYY-MM-DD HH:mm" format
+    const match = str.match(/^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})$/);
+    if (match) {
+        const [, y, mo, d, h, mi] = match;
+        return new Date(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi)).getTime();
+    }
+    // Fallback to Date.parse (ISO, etc.)
+    const ts = Date.parse(str);
+    if (isNaN(ts)) return null;
+    return ts;
+}
+
+export function registerReminderCommands(program) {
+    const reminder = program.command("reminder").description("Create and manage reminders in users/groups");
+
+    reminder
+        .command("create <threadId> <title>")
+        .description("Create a reminder")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("--time <datetime>", 'Reminder time: "YYYY-MM-DD HH:mm" (default: now)')
+        .option("--emoji <emoji>", "Emoji icon", "⏰")
+        .option("--repeat <mode>", "Repeat: none, daily, weekly, monthly", "none")
+        .action(async (threadId, title, opts) => {
+            try {
+                const repeatMode = REPEAT_MODES[opts.repeat];
+                if (repeatMode === undefined) {
+                    error(`Invalid repeat mode: "${opts.repeat}". Valid: none, daily, weekly, monthly`);
+                    return;
+                }
+                let startTime = Date.now();
+                if (opts.time) {
+                    startTime = parseTime(opts.time);
+                    if (!startTime) {
+                        error(`Invalid time format: "${opts.time}". Use "YYYY-MM-DD HH:mm" or ISO format.`);
+                        return;
+                    }
+                }
+                const result = await getApi().createReminder(
+                    { title, emoji: opts.emoji, startTime, repeat: repeatMode },
+                    threadId,
+                    Number(opts.type),
+                );
+                output(result, program.opts().json, () => {
+                    success(`Reminder created: "${title}"`);
+                    const id = result.reminderId || result.id || "?";
+                    info(`Reminder ID: ${id}`);
+                    info(`Time: ${new Date(startTime).toLocaleString()}`);
+                    if (repeatMode > 0) info(`Repeat: ${REPEAT_LABELS[repeatMode]}`);
+                });
+            } catch (e) {
+                error(`Create reminder failed: ${e.message}`);
+            }
+        });
+
+    reminder
+        .command("list <threadId>")
+        .description("List reminders in a thread")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("-n, --count <n>", "Max results", "20")
+        .action(async (threadId, opts) => {
+            try {
+                let result;
+                try {
+                    result = await getApi().getListReminder({ count: Number(opts.count) }, threadId, Number(opts.type));
+                } catch {
+                    result = null;
+                }
+                const items = Array.isArray(result) ? result : [];
+                output(items, program.opts().json, () => {
+                    if (items.length === 0) {
+                        info("No reminders found.");
+                        return;
+                    }
+                    info(`${items.length} reminder(s):`);
+                    console.log();
+                    for (const r of items) {
+                        const id = r.reminderId || r.id || "?";
+                        const title = r.params?.title || "?";
+                        const time = new Date(r.startTime).toLocaleString();
+                        const repeat = REPEAT_LABELS[r.repeat] || "None";
+                        const emoji = r.emoji || "";
+                        console.log(`  ${emoji} [${id}] ${title}`);
+                        console.log(`     Time: ${time} | Repeat: ${repeat}`);
+                    }
+                });
+            } catch (e) {
+                error(`List reminders failed: ${e.message}`);
+            }
+        });
+
+    reminder
+        .command("info <reminderId>")
+        .description("View reminder details (group reminders only)")
+        .action(async (reminderId) => {
+            try {
+                const result = await getApi().getReminder(reminderId);
+                output(result, program.opts().json, () => {
+                    const title = result.params?.title || "?";
+                    const id = result.id || reminderId;
+                    info(`Title: ${result.emoji || ""} ${title}`);
+                    info(`Reminder ID: ${id}`);
+                    info(`Created: ${new Date(result.createTime).toLocaleString()}`);
+                    info(`Time: ${new Date(result.startTime).toLocaleString()}`);
+                    info(`Repeat: ${REPEAT_LABELS[result.repeat] || "None"}`);
+                    info(`Creator: ${result.creatorId}`);
+                    if (result.responseMem) {
+                        info(
+                            `Responses: ${result.responseMem.acceptMember} accepted, ${result.responseMem.rejectMember} rejected`,
+                        );
+                    }
+                });
+            } catch (e) {
+                error(`Get reminder failed: ${e.message}`);
+            }
+        });
+
+    reminder
+        .command("responses <reminderId>")
+        .description("View who accepted/rejected a reminder (group only)")
+        .action(async (reminderId) => {
+            try {
+                const result = await getApi().getReminderResponses(reminderId);
+                output(result, program.opts().json, () => {
+                    const accepted = result.acceptMember || [];
+                    const rejected = result.rejectMember || [];
+                    info(`Accepted (${accepted.length}):`);
+                    accepted.forEach((uid) => console.log(`  ✓ ${uid}`));
+                    info(`Rejected (${rejected.length}):`);
+                    rejected.forEach((uid) => console.log(`  ✗ ${uid}`));
+                });
+            } catch (e) {
+                error(`Get responses failed: ${e.message}`);
+            }
+        });
+
+    reminder
+        .command("edit <reminderId> <threadId> <title>")
+        .description("Edit a reminder")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("--time <datetime>", 'New time: "YYYY-MM-DD HH:mm"')
+        .option("--emoji <emoji>", "New emoji icon")
+        .option("--repeat <mode>", "Repeat: none, daily, weekly, monthly")
+        .action(async (reminderId, threadId, title, opts) => {
+            try {
+                const editOpts = { title, topicId: reminderId };
+                if (opts.emoji) editOpts.emoji = opts.emoji;
+                if (opts.time) {
+                    const ts = parseTime(opts.time);
+                    if (!ts) {
+                        error(`Invalid time format: "${opts.time}". Use "YYYY-MM-DD HH:mm".`);
+                        return;
+                    }
+                    editOpts.startTime = ts;
+                }
+                if (opts.repeat) {
+                    const mode = REPEAT_MODES[opts.repeat];
+                    if (mode === undefined) {
+                        error(`Invalid repeat mode: "${opts.repeat}". Valid: none, daily, weekly, monthly`);
+                        return;
+                    }
+                    editOpts.repeat = mode;
+                }
+                const result = await getApi().editReminder(editOpts, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success(`Reminder ${reminderId} updated`));
+            } catch (e) {
+                error(`Edit reminder failed: ${e.message}`);
+            }
+        });
+
+    reminder
+        .command("remove <reminderId> <threadId>")
+        .description("Remove a reminder")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (reminderId, threadId, opts) => {
+            try {
+                const result = await getApi().removeReminder(reminderId, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success(`Reminder ${reminderId} removed`));
+            } catch (e) {
+                error(`Remove reminder failed: ${e.message}`);
+            }
+        });
+}

package/src/index.js

@@ -20,6 +20,7 @@ import { registerConvCommands } from "./commands/conv.js";
 import { registerAccountCommands } from "./commands/account.js";
 import { registerProfileCommands } from "./commands/profile.js";
 import { registerPollCommands } from "./commands/poll.js";
+import { registerReminderCommands } from "./commands/reminder.js";
 import { registerListenCommand } from "./commands/listen.js";
 import { autoLogin } from "./core/zalo-client.js";
 import { checkForUpdates, selfUpdate } from "./utils/update-check.js";
@@ -74,6 +75,7 @@ registerConvCommands(program);
 registerAccountCommands(program);
 registerProfileCommands(program);
 registerPollCommands(program);
+registerReminderCommands(program);
 registerListenCommand(program);
 
 program.parse();