@ardennguyen/zalo-agent-cli 1.0.7

package/src/commands/poll.js

@@ -0,0 +1,159 @@
+/**
+ * Poll commands — create, view, vote, add options, lock, and share polls in groups.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerPollCommands(program) {
+    const poll = program.command("poll").description("Create and manage polls in groups");
+
+    poll.command("create <groupId> <question> <options...>")
+        .description("Create a poll in a group (options separated by spaces, quote multi-word options)")
+        .option("--multi", "Allow multiple choices")
+        .option("--add-options", "Allow members to add new options")
+        .option("--anonymous", "Hide voter identities")
+        .option("--hide-preview", "Hide results until voted")
+        .option("--expire <minutes>", "Auto-close after N minutes", parseInt)
+        .action(async (groupId, question, options, opts) => {
+            try {
+                if (options.length < 2) {
+                    error("A poll requires at least 2 options.");
+                    return;
+                }
+                const expiredTime = opts.expire ? opts.expire * 60 * 1000 : 0;
+                const result = await getApi().createPoll(
+                    {
+                        question,
+                        options,
+                        allowMultiChoices: !!opts.multi,
+                        allowAddNewOption: !!opts.addOptions,
+                        isAnonymous: !!opts.anonymous,
+                        hideVotePreview: !!opts.hidePreview,
+                        expiredTime,
+                    },
+                    groupId,
+                );
+                output(result, program.opts().json, () => {
+                    success(`Poll created: "${question}"`);
+                    info(`Poll ID: ${result.poll_id}`);
+                    if (result.options) {
+                        result.options.forEach((o) => console.log(`  [${o.option_id}] ${o.content}`));
+                    }
+                });
+            } catch (e) {
+                error(`Create poll failed: ${e.message}`);
+            }
+        });
+
+    poll.command("info <pollId>")
+        .description("View poll details and results")
+        .action(async (pollId) => {
+            try {
+                const result = await getApi().getPollDetail(Number(pollId));
+                output(result, program.opts().json, () => {
+                    info(`Question: ${result.question}`);
+                    info(`Poll ID: ${result.poll_id}`);
+                    info(`Status: ${result.closed ? "Closed" : "Open"}`);
+                    info(`Total votes: ${result.num_vote}`);
+                    info(`Multi-choice: ${result.allow_multi_choices ? "Yes" : "No"}`);
+                    info(`Anonymous: ${result.is_anonymous ? "Yes" : "No"}`);
+                    if (result.expired_time > 0) {
+                        const expDate = new Date(result.expired_time);
+                        info(`Expires: ${expDate.toLocaleString()}`);
+                    }
+                    console.log();
+                    console.log("  ID    VOTES  OPTION");
+                    console.log("  " + "-".repeat(50));
+                    for (const o of result.options || []) {
+                        const voted = o.voted ? " ✓" : "";
+                        console.log(
+                            `  ${String(o.option_id).padEnd(6)} ${String(o.votes).padEnd(6)} ${o.content}${voted}`,
+                        );
+                    }
+                });
+            } catch (e) {
+                error(`Get poll failed: ${e.message}`);
+            }
+        });
+
+    poll.command("vote <pollId> <optionIds...>")
+        .description("Vote on a poll (use option IDs from 'poll info')")
+        .action(async (pollId, optionIds) => {
+            try {
+                const ids = optionIds.map(Number);
+                const result = await getApi().votePoll(Number(pollId), ids);
+                output(result, program.opts().json, () => {
+                    success(`Voted on poll ${pollId}`);
+                    if (result.options) {
+                        for (const o of result.options) {
+                            const voted = o.voted ? " ✓" : "";
+                            console.log(`  [${o.option_id}] ${o.content}: ${o.votes} vote(s)${voted}`);
+                        }
+                    }
+                });
+            } catch (e) {
+                error(`Vote failed: ${e.message}`);
+            }
+        });
+
+    poll.command("unvote <pollId>")
+        .description("Remove your vote from a poll")
+        .action(async (pollId) => {
+            try {
+                const result = await getApi().votePoll(Number(pollId), []);
+                output(result, program.opts().json, () => success(`Removed vote from poll ${pollId}`));
+            } catch (e) {
+                error(`Unvote failed: ${e.message}`);
+            }
+        });
+
+    poll.command("add-option <pollId> <options...>")
+        .description("Add new options to an existing poll")
+        .option("--vote", "Also vote for the new options")
+        .action(async (pollId, options, opts) => {
+            try {
+                const newOptions = options.map((content) => ({
+                    content,
+                    voted: !!opts.vote,
+                }));
+                const result = await getApi().addPollOptions({
+                    pollId: Number(pollId),
+                    options: newOptions,
+                    votedOptionIds: [],
+                });
+                output(result, program.opts().json, () => {
+                    success(`Added ${options.length} option(s) to poll ${pollId}`);
+                    if (result.options) {
+                        for (const o of result.options) {
+                            console.log(`  [${o.option_id}] ${o.content}: ${o.votes} vote(s)`);
+                        }
+                    }
+                });
+            } catch (e) {
+                error(`Add option failed: ${e.message}`);
+            }
+        });
+
+    poll.command("lock <pollId>")
+        .description("Lock/close a poll (no more votes)")
+        .action(async (pollId) => {
+            try {
+                const result = await getApi().lockPoll(Number(pollId));
+                output(result, program.opts().json, () => success(`Poll ${pollId} locked`));
+            } catch (e) {
+                error(`Lock poll failed: ${e.message}`);
+            }
+        });
+
+    poll.command("share <pollId>")
+        .description("Share a poll")
+        .action(async (pollId) => {
+            try {
+                const result = await getApi().sharePoll(Number(pollId));
+                output(result, program.opts().json, () => success(`Poll ${pollId} shared`));
+            } catch (e) {
+                error(`Share poll failed: ${e.message}`);
+            }
+        });
+}

package/src/commands/profile.js

@@ -0,0 +1,274 @@
+/**
+ * Profile commands — view/update profile, avatar, bio, and privacy settings.
+ */
+
+import { resolve } from "path";
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+/** Valid privacy setting keys and their human-readable labels + value descriptions. */
+const SETTING_MAP = {
+    "online-status": {
+        key: "show_online_status",
+        label: "Show online status",
+        values: { 0: "hidden", 1: "visible" },
+    },
+    "seen-status": {
+        key: "display_seen_status",
+        label: "Display seen status",
+        values: { 0: "hidden", 1: "visible" },
+    },
+    birthday: {
+        key: "view_birthday",
+        label: "Birthday visibility",
+        values: { 0: "hidden", 1: "full (day/month/year)", 2: "partial (day/month)" },
+    },
+    "receive-msg": {
+        key: "receive_message",
+        label: "Receive messages from",
+        values: { 1: "everyone", 2: "friends only" },
+    },
+    "accept-call": {
+        key: "accept_stranger_call",
+        label: "Accept calls from",
+        values: { 2: "friends only", 3: "everyone", 4: "friends + contacted" },
+    },
+    "add-by-phone": {
+        key: "add_friend_via_phone",
+        label: "Find by phone number",
+        values: { 0: "disabled", 1: "enabled" },
+    },
+    "add-by-qr": {
+        key: "add_friend_via_qr",
+        label: "Find by QR code",
+        values: { 0: "disabled", 1: "enabled" },
+    },
+    "add-by-group": {
+        key: "add_friend_via_group",
+        label: "Find via group",
+        values: { 0: "disabled", 1: "enabled" },
+    },
+    recommend: {
+        key: "display_on_recommend_friend",
+        label: "Show in friend recommendations",
+        values: { 0: "disabled", 1: "enabled" },
+    },
+};
+
+export function registerProfileCommands(program) {
+    const profile = program.command("profile").description("View and update your Zalo profile and settings");
+
+    profile
+        .command("me")
+        .description("Show current account profile")
+        .action(async () => {
+            try {
+                const result = await getApi().fetchAccountInfo();
+                const p = result?.profile || {};
+                output(result, program.opts().json, () => {
+                    info(`Name: ${p.displayName || p.zaloName || "?"}`);
+                    info(`User ID: ${p.userId || "?"}`);
+                    info(`Phone: ${p.phoneNumber || "?"}`);
+                    info(`Gender: ${p.gender === 0 ? "Male" : p.gender === 1 ? "Female" : "?"}`);
+                    info(`DOB: ${p.sdob || "?"}`);
+                    info(`Status: ${p.status || "(none)"}`);
+                    info(`Avatar: ${p.avatar || "?"}`);
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    profile
+        .command("avatar <imagePath>")
+        .description("Change your profile avatar")
+        .action(async (imagePath) => {
+            try {
+                const absPath = resolve(imagePath);
+                const result = await getApi().changeAccountAvatar(absPath);
+                output(result, program.opts().json, () => success("Avatar updated"));
+            } catch (e) {
+                error(`Avatar update failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("bio [text]")
+        .description("View or update your profile bio/status")
+        .action(async (text) => {
+            try {
+                if (text === undefined) {
+                    const result = await getApi().fetchAccountInfo();
+                    const bio = result?.profile?.status || "(empty)";
+                    output({ bio }, program.opts().json, () => info(`Bio: ${bio}`));
+                } else {
+                    await getApi().updateProfileBio(text);
+                    // Verify by reading back (Zalo may cache, so check)
+                    const verify = await getApi().fetchAccountInfo();
+                    const newBio = verify?.profile?.status || "";
+                    if (newBio === text) {
+                        output({ bio: newBio }, program.opts().json, () => success(`Bio updated to: "${text}"`));
+                    } else {
+                        output({ bio: newBio, requested: text }, program.opts().json, () => {
+                            success(`Bio update request sent: "${text}"`);
+                            info(
+                                "Note: Zalo may take time to reflect changes, or bio may not be supported for your account type.",
+                            );
+                        });
+                    }
+                }
+            } catch (e) {
+                error(`Bio update failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("update")
+        .description("Update profile name, birthday, or gender")
+        .option("-n, --name <name>", "Display name")
+        .option("-d, --dob <YYYY-MM-DD>", "Date of birth")
+        .option("-g, --gender <0|1>", "Gender: 0=Male, 1=Female")
+        .action(async (opts) => {
+            try {
+                if (!opts.name && !opts.dob && !opts.gender) {
+                    error("Provide at least one: --name, --dob, or --gender");
+                    return;
+                }
+                // Fetch current profile to fill missing fields (API requires all 3)
+                const current = await getApi().fetchAccountInfo();
+                const p = current?.profile || {};
+                // Convert sdob (DD/MM/YYYY) to YYYY-MM-DD format required by API
+                let currentDob = "2000-01-01";
+                if (p.sdob) {
+                    const parts = p.sdob.split("/");
+                    if (parts.length === 3) currentDob = `${parts[2]}-${parts[1]}-${parts[0]}`;
+                }
+                const payload = {
+                    profile: {
+                        name: opts.name || p.displayName || p.zaloName,
+                        dob: opts.dob || currentDob,
+                        gender: opts.gender !== undefined ? Number(opts.gender) : (p.gender ?? 0),
+                    },
+                };
+                const result = await getApi().updateProfile(payload);
+                output(result, program.opts().json, () => success("Profile updated"));
+            } catch (e) {
+                error(`Profile update failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("settings")
+        .description("View current privacy settings")
+        .action(async () => {
+            try {
+                const result = await getApi().getSettings();
+                output(result, program.opts().json, () => {
+                    info("Privacy settings:");
+                    console.log();
+                    for (const [slug, meta] of Object.entries(SETTING_MAP)) {
+                        const raw = result[meta.key];
+                        // Normalize booleans to 0/1 (API returns bool for some settings)
+                        const val = raw === true ? 1 : raw === false ? 0 : raw;
+                        const label = meta.values[val] || String(val);
+                        console.log(`  ${meta.label.padEnd(30)} ${label}  (${slug}=${val})`);
+                    }
+                    console.log();
+                    info("Update: zalo-agent profile set <setting> <value>");
+                    info("Example: zalo-agent profile set online-status 0");
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    profile
+        .command("avatars")
+        .description("List your avatar gallery")
+        .option("-c, --count <n>", "Page size", parseInt, 50)
+        .option("-p, --page <n>", "Page number", parseInt, 1)
+        .action(async (opts) => {
+            try {
+                const result = await getApi().getAvatarList(opts.count, opts.page);
+                output(result, program.opts().json);
+            } catch (e) {
+                error(`Get avatars failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("full-avatar <friendId>")
+        .description("Get full-size avatar URL for a user")
+        .action(async (friendId) => {
+            try {
+                const result = await getApi().getFullAvatar(friendId);
+                output(result, program.opts().json, () => {
+                    info(`Avatar: ${result?.avatar || "?"}`);
+                });
+            } catch (e) {
+                error(`Get full avatar failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("avatar-url <friendIds...>")
+        .description("Get avatar URLs for one or more users")
+        .action(async (friendIds) => {
+            try {
+                const result = await getApi().getAvatarUrlProfile(friendIds);
+                output(result, program.opts().json);
+            } catch (e) {
+                error(`Get avatar URLs failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("delete-avatar <photoIds...>")
+        .description("Delete avatar(s) from your gallery")
+        .action(async (photoIds) => {
+            try {
+                const result = await getApi().deleteAvatar(photoIds);
+                output(result, program.opts().json, () => success(`Deleted ${photoIds.length} avatar(s)`));
+            } catch (e) {
+                error(`Delete avatar failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("reuse-avatar <photoId>")
+        .description("Reuse a previous avatar from your gallery")
+        .action(async (photoId) => {
+            try {
+                const result = await getApi().reuseAvatar(photoId);
+                output(result, program.opts().json, () => success("Avatar reused"));
+            } catch (e) {
+                error(`Reuse avatar failed: ${e.message}`);
+            }
+        });
+
+    profile
+        .command("set <setting> <value>")
+        .description("Update a privacy setting (use 'profile settings' to see options)")
+        .action(async (setting, value) => {
+            try {
+                const meta = SETTING_MAP[setting];
+                if (!meta) {
+                    error(`Unknown setting: "${setting}". Valid: ${Object.keys(SETTING_MAP).join(", ")}`);
+                    return;
+                }
+                const numVal = Number(value);
+                if (!(numVal in meta.values)) {
+                    error(
+                        `Invalid value for ${setting}. Valid: ${Object.entries(meta.values)
+                            .map(([k, v]) => `${k}=${v}`)
+                            .join(", ")}`,
+                    );
+                    return;
+                }
+                const result = await getApi().updateSettings(meta.key, numVal);
+                output(result, program.opts().json, () => success(`${meta.label}: ${meta.values[numVal]} (${numVal})`));
+            } catch (e) {
+                error(`Setting update failed: ${e.message}`);
+            }
+        });
+}

package/src/commands/quick-msg.js

@@ -0,0 +1,55 @@
+/**
+ * Quick message commands — list, add, update, remove saved quick messages.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, output } from "../utils/output.js";
+
+export function registerQuickMsgCommands(program) {
+    const qm = program.command("quick-msg").description("Manage quick/saved messages");
+
+    qm.command("list")
+        .description("List all quick messages")
+        .action(async () => {
+            try {
+                const result = await getApi().getQuickMessageList();
+                output(result, program.opts().json);
+            } catch (e) {
+                error(`Get quick messages failed: ${e.message}`);
+            }
+        });
+
+    qm.command("add <keyword> <title>")
+        .description("Add a quick message")
+        .action(async (keyword, title) => {
+            try {
+                const result = await getApi().addQuickMessage({ keyword, title });
+                output(result, program.opts().json, () => success(`Quick message added: "${keyword}" → "${title}"`));
+            } catch (e) {
+                error(`Add quick message failed: ${e.message}`);
+            }
+        });
+
+    qm.command("update <itemId> <keyword> <title>")
+        .description("Update a quick message")
+        .action(async (itemId, keyword, title) => {
+            try {
+                const result = await getApi().updateQuickMessage({ keyword, title }, Number(itemId));
+                output(result, program.opts().json, () => success(`Quick message ${itemId} updated`));
+            } catch (e) {
+                error(`Update quick message failed: ${e.message}`);
+            }
+        });
+
+    qm.command("remove <itemIds...>")
+        .description("Remove quick message(s)")
+        .action(async (itemIds) => {
+            try {
+                const ids = itemIds.map(Number);
+                const result = await getApi().removeQuickMessage(ids);
+                output(result, program.opts().json, () => success(`Removed ${ids.length} quick message(s)`));
+            } catch (e) {
+                error(`Remove quick message failed: ${e.message}`);
+            }
+        });
+}

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}`);
+            }
+        });
+}