@ardennguyen/zalo-agent-cli 1.0.7 → 2.1.0

package/src/commands/friend.js

@@ -4,6 +4,7 @@
 
 import { getApi } from "../core/zalo-client.js";
 import { success, error, info, output } from "../utils/output.js";
+import { parseIntOption } from "../utils/parse-options.js";
 
 /** Extract numeric error code from zca-js error message string. */
 function extractErrorCode(msg) {
@@ -21,11 +22,22 @@ export function registerFriendCommands(program) {
             try {
                 const result = await getApi().getAllFriends();
                 output(result, program.opts().json, () => {
-                    const profiles = result?.changed_profiles || result || {};
-                    const entries = Object.entries(profiles);
-                    info(`${entries.length} friends`);
-                    for (const [uid, p] of entries) {
-                        console.log(`  ${uid}  ${p.displayName || p.zaloName || "?"}`);
+                    const friends = Array.isArray(result) ? result : [];
+
+                    // Sort by lastActionTime (most recent interaction first)
+                    const sorted = [...friends].sort((a, b) => {
+                        const tA = a.lastActionTime || 0;
+                        const tB = b.lastActionTime || 0;
+                        return tB - tA;
+                    });
+
+                    info(`${sorted.length} friend(s)`);
+                    for (const p of sorted) {
+                        // epoch MILLISECONDS — the old x1000 printed year 58687
+                        const dateStr = p.lastActionTime ? new Date(p.lastActionTime).toLocaleString() : "Never";
+                        console.log(
+                            `  ${p.userId.padEnd(20)}  ${(p.displayName || p.zaloName || "?").padEnd(25)} [Last Activity: ${dateStr}]`,
+                        );
                     }
                 });
             } catch (e) {
@@ -234,8 +246,8 @@ export function registerFriendCommands(program) {
     friend
         .command("alias-list")
         .description("List all friend aliases")
-        .option("-c, --count <n>", "Page size", parseInt, 100)
-        .option("-p, --page <n>", "Page number", parseInt, 1)
+        .option("-c, --count <n>", "Page size", parseIntOption, 100)
+        .option("-p, --page <n>", "Page number", parseIntOption, 1)
         .action(async (opts) => {
             try {
                 const result = await getApi().getAliasList(opts.count, opts.page);

package/src/commands/group.js

@@ -5,7 +5,10 @@
 
 import { resolve } from "path";
 import { getApi } from "../core/zalo-client.js";
-import { success, error, info, output } from "../utils/output.js";
+import { getGroupHistory } from "../core/group-history.js";
+import { groupMemberUids } from "../core/group-members.js";
+import { success, error, info, warning, output } from "../utils/output.js";
+import { parseIntOption, parseIntAtLeast } from "../utils/parse-options.js";
 
 export function registerGroupCommands(program) {
     const group = program.command("group").description("Manage groups");
@@ -116,13 +119,18 @@ export function registerGroupCommands(program) {
         .option("-n, --count <n>", "Number of messages to fetch", "20")
         .action(async (groupId, opts) => {
             try {
-                const result = await getApi().getGroupChatHistory(groupId, Number(opts.count));
+                const count = parseIntAtLeast(1)(opts.count);
+                // Zalo's cloud-message store (/api/cm/getrecentv2), which is
+                // what Zalo Web reads. zca-js's getGroupChatHistory asks
+                // /api/group/history, which Zalo answers with 404.
+                const result = await getGroupHistory(getApi(), groupId, count);
                 const msgs = result?.groupMsgs || [];
 
                 // Normalize messages into clean, storage-friendly JSON
                 const normalized = msgs.map((m) => {
                     const d = m.data || m;
                     const content = typeof d.content === "string" ? d.content : d.content;
+                    const ts = Number(d.ts);
                     return {
                         msgId: d.msgId,
                         cliMsgId: d.cliMsgId,
@@ -130,8 +138,9 @@ export function registerGroupCommands(program) {
                         groupId: d.idTo,
                         msgType: d.msgType,
                         content: typeof content === "string" ? content : content,
-                        timestamp: Number(d.ts),
-                        isoTime: new Date(Number(d.ts)).toISOString(),
+                        timestamp: Number.isFinite(ts) ? ts : null,
+                        // A row without a timestamp must not abort the whole listing.
+                        isoTime: Number.isFinite(ts) ? new Date(ts).toISOString() : null,
                         isSelf: m.isSelf ?? false,
                         ...(d.mentions && { mentions: d.mentions }),
                         ...(d.quote && {
@@ -148,15 +157,25 @@ export function registerGroupCommands(program) {
                     groupId,
                     count: normalized.length,
                     hasMore: result?.more === 1,
+                    // Older messages exist, but Zalo's store withholds them:
+                    // it serves only messages since this login.
+                    filtered: result?.filtered === true,
                     messages: normalized,
                 };
 
                 output(payload, program.opts().json, () => {
                     info(`${normalized.length} message(s) in group ${groupId}`);
                     if (result?.more === 1) info("(more messages available)");
+                    if (result?.filtered) {
+                        info(
+                            "Zalo's message store serves only messages since this login; older ones are withheld. " +
+                                "`zalo-agent sync` restores them from your phone (it asks for a tap), and " +
+                                `\`zalo-agent msg history ${groupId} -t 1\` then reads them from the local cache.`,
+                        );
+                    }
                     console.log();
                     for (const m of normalized) {
-                        const time = new Date(m.timestamp).toLocaleTimeString();
+                        const time = m.timestamp === null ? "?" : new Date(m.timestamp).toLocaleTimeString();
                         const dir = m.isSelf ? "→" : "←";
                         const text =
                             typeof m.content === "string" ? m.content.slice(0, 80) : `[${m.msgType || "attachment"}]`;
@@ -173,14 +192,9 @@ export function registerGroupCommands(program) {
         .description("List group members")
         .action(async (groupId) => {
             try {
-                // getGroupInfo requires an array, not a bare string
-                const result = await getApi().getGroupInfo([groupId]);
-                const groupData = result?.gridInfoMap?.[groupId];
-                // memberIds is always [] from the API; member UIDs are in memVerList
-                // as "uid_version" strings (e.g. "1911679535470292669_0")
-                const memVerList = groupData?.memVerList || [];
-                const memberUids = memVerList.map((mv) => mv.split("_")[0]).filter(Boolean);
-                const totalMember = groupData?.totalMember ?? memberUids.length;
+                // Shared with zalo_get_group_members (src/core/group-members.js):
+                // the uids come out of memVerList, since memberIds is always [].
+                const { uids: memberUids, totalMember } = await groupMemberUids(getApi(), groupId);
                 output(memberUids, program.opts().json, () => {
                     if (memberUids.length === 0) {
                         info(`0 members`);
@@ -223,7 +237,12 @@ export function registerGroupCommands(program) {
         .description("Rename a group")
         .action(async (groupId, name) => {
             try {
-                const result = await getApi().changeGroupName(groupId, name);
+                // zca-js declares changeGroupName(name, groupId) — name
+                // FIRST. Passing (groupId, name) handed Zalo the group id as
+                // the new name and the name as the group id, so every rename
+                // failed with "Tham số không hợp lệ". Note changeGroupAvatar
+                // below takes (source, groupId), which is the same shape.
+                const result = await getApi().changeGroupName(name, groupId);
                 output(result, program.opts().json, () => success(`Group renamed to "${name}"`));
             } catch (e) {
                 error(e.message);
@@ -331,7 +350,10 @@ export function registerGroupCommands(program) {
         .description("Join a group via invite link")
         .action(async (link) => {
             try {
-                const result = await getApi().joinGroup(link);
+                // zca-js calls this joinGroupLink. There is no joinGroup, so
+                // the command failed on "is not a function" before any network
+                // call -- found by tests/unit/zca-api-surface.test.js.
+                const result = await getApi().joinGroupLink(link);
                 output(result, program.opts().json, () => success("Joined group"));
             } catch (e) {
                 error(e.message);
@@ -359,7 +381,7 @@ export function registerGroupCommands(program) {
 
     group
         .command("settings <groupId>")
-        .description("Update group settings (flags: --block-name, --sign-admin, --join-appr, etc.)")
+        .description("Change group settings; every setting you don't pass a flag for keeps its current value")
         .option("--block-name", "Disallow members to change group name/avatar")
         .option("--no-block-name", "Allow members to change group name/avatar")
         .option("--sign-admin", "Highlight admin messages")
@@ -376,22 +398,51 @@ export function registerGroupCommands(program) {
         .option("--no-lock-msg", "Allow members to send messages")
         .option("--lock-view-member", "Hide full member list (community only)")
         .option("--no-lock-view-member", "Show full member list")
+        .option("--topic-only", "Only admins can pin messages, notes and polls to the top of the chat")
+        .option("--no-topic-only", "Let members pin messages, notes and polls to the top of the chat")
         .action(async (groupId, opts) => {
-            try {
-                const settings = {
-                    blockName: opts.blockName ?? false,
-                    signAdminMsg: opts.signAdmin ?? false,
-                    enableMsgHistory: opts.msgHistory ?? false,
-                    joinAppr: opts.joinAppr ?? false,
-                    lockCreatePost: opts.lockPost ?? false,
-                    lockCreatePoll: opts.lockPoll ?? false,
-                    lockSendMsg: opts.lockMsg ?? false,
-                    lockViewMember: opts.lockViewMember ?? false,
-                };
-                const result = await getApi().updateGroupSettings(settings, groupId);
-                output(result, program.opts().json, () => success(`Group settings updated for ${groupId}`));
+            // Zalo stores the whole setting object on every update, so this
+            // reads the current one and sends back everything the user did not
+            // name, unchanged. See src/core/group-settings.js for why, and for
+            // what Zalo Web sends.
+            try {
+                const { NOTHING_TO_CHANGE, settingChangesFromOptions, applyGroupSettingChanges } =
+                    await import("../core/group-settings.js");
+                const changes = settingChangesFromOptions(opts);
+                // Refused before the session is touched: there is nothing to send.
+                if (Object.keys(changes).length === 0) throw new Error(NOTHING_TO_CHANGE);
+                const outcome = await applyGroupSettingChanges(getApi(), groupId, changes);
+                output(outcome, program.opts().json, () => {
+                    const onOff = (v) => (Number(v) ? "on" : "off");
+                    if (!outcome.sent) {
+                        const already = Object.entries(outcome.unchanged).map(
+                            ([k, v]) => `${k} is already ${onOff(v)}`,
+                        );
+                        info(`Nothing to change for ${groupId}: ${already.join(", ")}. Nothing was sent.`);
+                        return;
+                    }
+                    success(`Group settings updated for ${groupId}`);
+                    for (const [key, { from, to }] of Object.entries(outcome.changed)) {
+                        info(`${key}: ${onOff(from)} -> ${onOff(to)}`);
+                    }
+                    for (const [key, value] of Object.entries(outcome.unchanged)) {
+                        info(`${key}: already ${onOff(value)}`);
+                    }
+                    // What the read-back found that the request did not ask for.
+                    for (const [key, { from, to }] of Object.entries(outcome.sideEffects ?? {})) {
+                        info(`${key}: ${onOff(from)} -> ${onOff(to)} (changed by Zalo alongside this update)`);
+                    }
+                    for (const [key, { asked, now }] of Object.entries(outcome.notApplied ?? {})) {
+                        warning(`${key}: asked for ${onOff(asked)}, but Zalo still reports ${onOff(now)}`);
+                    }
+                    if (outcome.verified === false) {
+                        info("Could not read the group back to confirm the result.");
+                    }
+                });
+                if (Object.keys(outcome.notApplied ?? {}).length) process.exitCode = 1;
             } catch (e) {
                 error(`Update settings failed: ${e.message}`);
+                process.exitCode = 1;
             }
         });
 
@@ -489,8 +540,8 @@ export function registerGroupCommands(program) {
     group
         .command("blocked <groupId>")
         .description("List blocked members in a group")
-        .option("-c, --count <n>", "Items per page", parseInt, 50)
-        .option("-p, --page <n>", "Page number", parseInt, 1)
+        .option("-c, --count <n>", "Items per page", parseIntOption, 50)
+        .option("-p, --page <n>", "Page number", parseIntOption, 1)
         .action(async (groupId, opts) => {
             try {
                 const result = await getApi().getGroupBlockedMember({ page: opts.page, count: opts.count }, groupId);