zalo-agent-cli 1.0.0

package/src/commands/account.js

@@ -0,0 +1,178 @@
+/**
+ * Account commands — multi-account management with per-account proxy.
+ * Includes export for headless/CI credential transfer.
+ */
+
+import { writeFileSync, chmodSync } from "fs";
+import { resolve } from "path";
+import { loginWithQR, loginWithCredentials, extractCredentials, clearSession } from "../core/zalo-client.js";
+import { saveCredentials, loadCredentials } from "../core/credentials.js";
+import { listAccounts, getActive, setActive, addAccount, removeAccount, getAccount } from "../core/accounts.js";
+import { maskProxy } from "../utils/proxy-helpers.js";
+import { displayQR, getQRPath } from "../utils/qr-display.js";
+import { startQrServer } from "../utils/qr-http-server.js";
+import { success, error, info, warning, output } from "../utils/output.js";
+
+export function registerAccountCommands(program) {
+    const account = program.command("account").description("Manage multiple Zalo accounts with proxy");
+
+    account
+        .command("list")
+        .description("List all registered accounts")
+        .action(() => {
+            const accounts = listAccounts();
+            const safe = accounts.map((a) => ({ ...a, proxy: maskProxy(a.proxy) }));
+            output(safe, program.opts().json, () => {
+                if (!accounts.length) {
+                    info("No accounts. Use: zalo-agent account login");
+                    return;
+                }
+                console.log(`  ${"Active".padEnd(8)} ${"Owner ID".padEnd(22)} ${"Name".padEnd(20)} Proxy`);
+                console.log(`  ${"─".repeat(75)}`);
+                for (const a of accounts) {
+                    const marker = a.active ? "  ★" : "   ";
+                    console.log(
+                        `  ${marker.padEnd(8)} ${a.ownId.padEnd(22)} ${(a.name || "").padEnd(20)} ${maskProxy(a.proxy)}`,
+                    );
+                }
+            });
+        });
+
+    account
+        .command("login")
+        .description("Login a new Zalo account via QR code")
+        .option("-p, --proxy <url>", "Dedicated proxy URL for this account")
+        .option("-n, --name <label>", "Friendly label", "")
+        .option("--qr-url", "Start local HTTP server to view QR in browser (for VPS/headless)")
+        .action(async (opts) => {
+            if (opts.proxy) info(`Using proxy: ${maskProxy(opts.proxy)}`);
+            info("Generating QR code... Scan with Zalo mobile app.");
+
+            let qrServer = null;
+            try {
+                const { ownId } = await loginWithQR(opts.proxy, (event) => {
+                    displayQR(event);
+                    if (!qrServer) {
+                        qrServer = startQrServer(getQRPath());
+                    }
+                });
+
+                // Fetch display name from Zalo profile
+                let displayName = opts.name || "";
+                try {
+                    const { getApi } = await import("../core/zalo-client.js");
+                    const accountInfo = await getApi().fetchAccountInfo();
+                    displayName = accountInfo?.profile?.displayName || displayName || ownId;
+                } catch {}
+
+                const creds = extractCredentials();
+                saveCredentials(ownId, creds);
+                addAccount(ownId, displayName, opts.proxy);
+                success(
+                    `Account logged in: ${displayName} (${ownId})${opts.proxy ? ` via ${maskProxy(opts.proxy)}` : ""}`,
+                );
+            } catch (e) {
+                error(`Login failed: ${e.message}`);
+            } finally {
+                if (qrServer) qrServer.close();
+            }
+        });
+
+    account
+        .command("switch <ownerId>")
+        .description("Switch active account (restarts connection with account proxy)")
+        .action(async (ownerId) => {
+            let acc = getAccount(ownerId);
+            if (!acc) {
+                const all = listAccounts();
+                const matches = all.filter((a) => a.ownId.includes(ownerId) || (a.name || "").includes(ownerId));
+                if (matches.length === 1) {
+                    ownerId = matches[0].ownId;
+                    acc = matches[0];
+                } else {
+                    error(`Account not found: ${ownerId}`);
+                    return;
+                }
+            }
+
+            const creds = loadCredentials(ownerId);
+            if (!creds) {
+                error(`No credentials for ${ownerId}. Re-login needed.`);
+                return;
+            }
+
+            info(`Switching to ${ownerId} (${acc?.name || ""})`);
+            if (acc?.proxy) info(`Proxy: ${maskProxy(acc.proxy)}`);
+
+            clearSession();
+            try {
+                await loginWithCredentials(creds, acc?.proxy || null);
+                setActive(ownerId);
+                success(`Switched to ${ownerId}`);
+            } catch (e) {
+                error(`Switch failed: ${e.message}`);
+            }
+        });
+
+    account
+        .command("remove <ownerId>")
+        .description("Remove account and delete its credentials")
+        .action((ownerId) => {
+            if (removeAccount(ownerId)) {
+                success(`Account ${ownerId} removed`);
+            } else {
+                error(`Account not found: ${ownerId}`);
+            }
+        });
+
+    account
+        .command("info")
+        .description("Show currently active account")
+        .action(() => {
+            const active = getActive();
+            const safe = active ? { ...active, proxy: maskProxy(active.proxy) } : null;
+            output(safe, program.opts().json, () => {
+                if (!active) {
+                    info("No active account.");
+                    return;
+                }
+                console.log(`  Owner ID: ${active.ownId}`);
+                console.log(`  Name:     ${active.name || "-"}`);
+                console.log(`  Proxy:    ${maskProxy(active.proxy)}`);
+                console.log(`  Active:   yes`);
+            });
+        });
+
+    account
+        .command("export [ownerId]")
+        .description("Export account credentials for transfer to another machine")
+        .option("-o, --output <path>", "Output file path", "./zalo-creds.json")
+        .action((ownerId, opts) => {
+            const acc = ownerId ? getAccount(ownerId) : getActive();
+            if (!acc) {
+                error("No account found to export.");
+                return;
+            }
+
+            const creds = loadCredentials(acc.ownId);
+            if (!creds) {
+                error(`No credentials for ${acc.ownId}.`);
+                return;
+            }
+
+            const exportData = {
+                ...creds,
+                proxy: acc.proxy || null,
+                ownId: acc.ownId,
+                name: acc.name || "",
+            };
+
+            const outPath = resolve(opts.output);
+            writeFileSync(outPath, JSON.stringify(exportData, null, 2), "utf-8");
+            chmodSync(outPath, 0o600);
+
+            success(`Exported to ${outPath}`);
+            warning("This file contains login credentials. Keep it secure and do not commit to git.");
+            info(`Import on another machine: zalo-agent login --credentials ${opts.output}`);
+        });
+}

package/src/commands/conv.js

@@ -0,0 +1,93 @@
+/**
+ * Conversation commands — pinned, archived, mute, unmute, read, unread, delete.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, output } from "../utils/output.js";
+
+export function registerConvCommands(program) {
+    const conv = program.command("conv").description("Manage conversations");
+
+    conv.command("pinned")
+        .description("List pinned conversations")
+        .action(async () => {
+            try {
+                const result = await getApi().getPinnedConversations();
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("archived")
+        .description("List archived conversations")
+        .action(async () => {
+            try {
+                const result = await getApi().getArchivedConversations();
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("mute <threadId>")
+        .description("Mute a conversation")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("-d, --duration <secs>", "Duration in seconds (-1 = forever)", "-1")
+        .action(async (threadId, opts) => {
+            try {
+                const result = await getApi().setMute(threadId, Number(opts.type), Number(opts.duration));
+                output(result, program.opts().json, () => success("Conversation muted"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("unmute <threadId>")
+        .description("Unmute a conversation")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, opts) => {
+            try {
+                const result = await getApi().setMute(threadId, Number(opts.type), 0);
+                output(result, program.opts().json, () => success("Conversation unmuted"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("read <threadId>")
+        .description("Mark conversation as read")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, opts) => {
+            try {
+                const result = await getApi().sendSeenEvent(threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Marked as read"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("unread <threadId>")
+        .description("Mark conversation as unread")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, opts) => {
+            try {
+                const result = await getApi().markAsUnread(threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Marked as unread"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    conv.command("delete <threadId>")
+        .description("Delete conversation history")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, opts) => {
+            try {
+                const result = await getApi().deleteConversation(threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Conversation deleted"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}

package/src/commands/friend.js

@@ -0,0 +1,148 @@
+/**
+ * Friend commands — list, find, info, add, accept, remove, block, unblock, last-online, online.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerFriendCommands(program) {
+    const friend = program.command("friend").description("Manage friends and contacts");
+
+    friend
+        .command("list")
+        .description("List all friends")
+        .action(async () => {
+            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 || "?"}`);
+                    }
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("online")
+        .description("List currently online friends")
+        .action(async () => {
+            try {
+                const result = await getApi().getFriendOnlines();
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("find <query>")
+        .description("Find user by phone number or Zalo ID")
+        .action(async (query) => {
+            try {
+                const result = await getApi().findUser(query);
+                output(result, program.opts().json, () => {
+                    const u = result?.uid ? result : result?.data || result;
+                    info(`User ID: ${u.uid || "?"}`);
+                    info(`Name: ${u.displayName || u.zaloName || "?"}`);
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("info <userId>")
+        .description("Get user profile information")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().getUserInfo(userId);
+                output(result, program.opts().json, () => {
+                    const profiles = result?.changed_profiles || {};
+                    const p = profiles[userId] || {};
+                    info(`Name: ${p.displayName || p.zaloName || "?"}`);
+                    info(`Phone: ${p.phoneNumber || "?"}`);
+                    info(`Avatar: ${p.avatar || "?"}`);
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("add <userId>")
+        .description("Send a friend request")
+        .option("-m, --msg <text>", "Message to include", "")
+        .action(async (userId, opts) => {
+            try {
+                const result = await getApi().sendFriendRequest(userId, opts.msg);
+                output(result, program.opts().json, () => success("Friend request sent"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("accept <userId>")
+        .description("Accept a friend request")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().acceptFriendRequest(userId);
+                output(result, program.opts().json, () => success("Friend request accepted"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("remove <userId>")
+        .description("Remove a friend")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().removeFriend(userId);
+                output(result, program.opts().json, () => success("Friend removed"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("block <userId>")
+        .description("Block a user")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().blockUser(userId);
+                output(result, program.opts().json, () => success("User blocked"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("unblock <userId>")
+        .description("Unblock a user")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().unblockUser(userId);
+                output(result, program.opts().json, () => success("User unblocked"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    friend
+        .command("last-online <userId>")
+        .description("Check when user was last online")
+        .action(async (userId) => {
+            try {
+                const result = await getApi().getLastOnline(userId);
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}

package/src/commands/group.js

@@ -0,0 +1,123 @@
+/**
+ * Group commands — list, create, info, members, add/remove-member, rename, leave, join.
+ */
+
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerGroupCommands(program) {
+    const group = program.command("group").description("Manage groups");
+
+    group
+        .command("list")
+        .description("List all groups")
+        .action(async () => {
+            try {
+                const result = await getApi().getAllGroups();
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("create <name> <memberIds...>")
+        .description("Create a new group")
+        .action(async (name, memberIds) => {
+            try {
+                const result = await getApi().createGroup({ members: memberIds, name });
+                output(result, program.opts().json, () => success(`Group "${name}" created`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("info <groupId>")
+        .description("Show group details")
+        .action(async (groupId) => {
+            try {
+                const result = await getApi().getGroupInfo(groupId);
+                output(result, program.opts().json);
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("members <groupId>")
+        .description("List group members")
+        .action(async (groupId) => {
+            try {
+                const result = await getApi().getGroupInfo(groupId);
+                const members = result?.gridInfoMap?.[groupId]?.memberIds || {};
+                output(members, program.opts().json, () => {
+                    const ids = Object.keys(members);
+                    info(`${ids.length} members`);
+                    ids.forEach((id) => console.log(`  ${id}`));
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("add-member <groupId> <userIds...>")
+        .description("Add members to a group")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().addUserToGroup(userIds, groupId);
+                output(result, program.opts().json, () => success("Member(s) added"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("remove-member <groupId> <userIds...>")
+        .description("Remove members from a group")
+        .action(async (groupId, userIds) => {
+            try {
+                const result = await getApi().removeUserFromGroup(userIds, groupId);
+                output(result, program.opts().json, () => success("Member(s) removed"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("rename <groupId> <name>")
+        .description("Rename a group")
+        .action(async (groupId, name) => {
+            try {
+                const result = await getApi().changeGroupName(groupId, name);
+                output(result, program.opts().json, () => success(`Group renamed to "${name}"`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("leave <groupId>")
+        .description("Leave a group")
+        .action(async (groupId) => {
+            try {
+                const result = await getApi().leaveGroup(groupId);
+                output(result, program.opts().json, () => success("Left group"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    group
+        .command("join <link>")
+        .description("Join a group via invite link")
+        .action(async (link) => {
+            try {
+                const result = await getApi().joinGroup(link);
+                output(result, program.opts().json, () => success("Joined group"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}

package/src/commands/login.js

@@ -0,0 +1,154 @@
+/**
+ * Login commands — QR login, credential login, logout, status, whoami.
+ */
+
+import { readFileSync, unlinkSync } from "fs";
+import {
+    loginWithQR,
+    loginWithCredentials,
+    extractCredentials,
+    clearSession,
+    isLoggedIn,
+    getApi,
+    getOwnId,
+} from "../core/zalo-client.js";
+import { saveCredentials, deleteCredentials } from "../core/credentials.js";
+import { addAccount, getActive, removeAccount } from "../core/accounts.js";
+import { maskProxy } from "../utils/proxy-helpers.js";
+import { displayQR, getQRPath } from "../utils/qr-display.js";
+import { startQrServer } from "../utils/qr-http-server.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerLoginCommands(program) {
+    program
+        .command("login")
+        .description("Login to Zalo via QR code scan or from exported credentials")
+        .option("-p, --proxy <url>", "Proxy URL (http/https/socks5://[user:pass@]host:port)")
+        .option("-n, --name <label>", "Friendly name for this account", "")
+        .option("--qr-url", "Start local HTTP server to view QR in browser (for VPS/headless)")
+        .option("--credentials <path>", "Login from exported credentials file (skip QR)")
+        .action(async (opts) => {
+            // Credential-based login (headless/CI)
+            if (opts.credentials) {
+                try {
+                    const raw = JSON.parse(readFileSync(opts.credentials, "utf-8"));
+                    const proxy = opts.proxy || raw.proxy || null;
+                    if (proxy) info(`Using proxy: ${maskProxy(proxy)}`);
+
+                    const { ownId } = await loginWithCredentials(raw, proxy);
+
+                    let displayName = opts.name || raw.name || "";
+                    try {
+                        const accountInfo = await getApi().fetchAccountInfo();
+                        displayName = accountInfo?.profile?.displayName || displayName || ownId;
+                    } catch {}
+
+                    const creds = extractCredentials();
+                    saveCredentials(ownId, creds);
+                    addAccount(ownId, displayName, proxy);
+                    success(`Logged in as ${displayName} (${ownId})`);
+                } catch (e) {
+                    error(`Login from credentials failed: ${e.message}`);
+                    process.exit(1);
+                }
+                return;
+            }
+
+            // QR-based login
+            if (opts.proxy) info(`Using proxy: ${maskProxy(opts.proxy)}`);
+            info("Generating QR code... Scan with Zalo mobile app.");
+
+            let qrServer = null;
+            try {
+                const { ownId } = await loginWithQR(opts.proxy, (event) => {
+                    displayQR(event);
+
+                    // Always start HTTP server for QR scanning (no flag needed)
+                    if (!qrServer) {
+                        qrServer = startQrServer(getQRPath());
+                    }
+                });
+
+                // Fetch display name from Zalo profile
+                let displayName = opts.name || "";
+                try {
+                    const accountInfo = await getApi().fetchAccountInfo();
+                    displayName = accountInfo?.profile?.displayName || displayName || ownId;
+                } catch {}
+
+                const creds = extractCredentials();
+                saveCredentials(ownId, creds);
+                addAccount(ownId, displayName, opts.proxy);
+                success(`Logged in as ${displayName} (${ownId})`);
+            } catch (e) {
+                error(`Login failed: ${e.message}`);
+                process.exit(1);
+            } finally {
+                if (qrServer) qrServer.close();
+            }
+        });
+
+    program
+        .command("logout")
+        .description("Logout current account (keeps credentials for auto-login)")
+        .option("--purge", "Also delete saved credentials (must QR login again)")
+        .action((opts) => {
+            const active = getActive();
+            clearSession();
+
+            if (opts.purge && active) {
+                deleteCredentials(active.ownId);
+                removeAccount(active.ownId);
+                // Also remove QR image
+                try {
+                    unlinkSync(getQRPath());
+                } catch {}
+                success(`Logged out and purged credentials for ${active.name || active.ownId}`);
+            } else {
+                success("Logged out (credentials kept — will auto-login on next command)");
+                if (active) info(`To fully remove: zalo-agent account remove ${active.ownId}`);
+            }
+        });
+
+    program
+        .command("status")
+        .description("Show current login status")
+        .action(() => {
+            const active = getActive();
+            const data = {
+                loggedIn: isLoggedIn(),
+                ownId: getOwnId(),
+                activeAccount: active
+                    ? { ownId: active.ownId, name: active.name, proxy: maskProxy(active.proxy) }
+                    : null,
+            };
+            output(data, program.opts().json, () => {
+                if (data.loggedIn) {
+                    success(`Logged in as ${data.ownId}`);
+                    if (active) info(`Account: ${active.name || active.ownId} | Proxy: ${maskProxy(active.proxy)}`);
+                } else {
+                    info("Not logged in");
+                    if (active)
+                        info(`Active account: ${active.name || active.ownId} (will auto-login on next command)`);
+                }
+            });
+        });
+
+    program
+        .command("whoami")
+        .description("Show current user profile")
+        .action(async () => {
+            try {
+                const api = getApi();
+                const accountInfo = await api.fetchAccountInfo();
+                output(accountInfo, program.opts().json, () => {
+                    const p = accountInfo?.profile || {};
+                    info(`Name: ${p.displayName || "?"}`);
+                    info(`ID: ${p.userId || getOwnId()}`);
+                    info(`Phone: ${p.phoneNumber || "?"}`);
+                });
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}