zalo-agent-cli 1.0.0

package/src/commands/msg.js

@@ -0,0 +1,225 @@
+/**
+ * Message commands — send text, images, files, cards, bank cards, QR transfers,
+ * stickers, reactions, delete, forward.
+ */
+
+import { resolve } from "path";
+import { getApi } from "../core/zalo-client.js";
+import { success, error, info, output } from "../utils/output.js";
+
+export function registerMsgCommands(program) {
+    const msg = program.command("msg").description("Send and manage messages");
+
+    msg.command("send <threadId> <message>")
+        .description("Send a text message")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, message, opts) => {
+            try {
+                const result = await getApi().sendMessage(message, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Message sent"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("send-image <threadId> <paths...>")
+        .description("Send one or more images")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("-m, --caption <text>", "Caption text", "")
+        .action(async (threadId, paths, opts) => {
+            try {
+                const absPaths = paths.map((p) => resolve(p));
+                const result = await getApi().sendMessage(
+                    { msg: opts.caption, attachments: absPaths },
+                    threadId,
+                    Number(opts.type),
+                );
+                output(result, program.opts().json, () => success(`Image(s) sent to ${threadId}`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("send-file <threadId> <paths...>")
+        .description("Send files (docx, pdf, zip, etc.)")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("-m, --caption <text>", "Caption text", "")
+        .action(async (threadId, paths, opts) => {
+            try {
+                const absPaths = paths.map((p) => resolve(p));
+                const result = await getApi().sendMessage(
+                    { msg: opts.caption, attachments: absPaths },
+                    threadId,
+                    Number(opts.type),
+                );
+                output(result, program.opts().json, () => success(`File(s) sent to ${threadId}`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("send-card <threadId> <userId>")
+        .description("Send a contact card (danh thiếp)")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("--phone <num>", "Phone number (auto-fetched if omitted)")
+        .action(async (threadId, userId, opts) => {
+            try {
+                const api = getApi();
+                let phone = opts.phone;
+                if (!phone) {
+                    const userInfo = await api.getUserInfo(userId);
+                    const profiles = userInfo?.changed_profiles || {};
+                    phone = profiles[userId]?.phoneNumber || "";
+                    if (phone) info(`Auto-detected phone: ${phone}`);
+                }
+                const cardOpts = { userId };
+                if (phone) cardOpts.phoneNumber = phone;
+                const result = await api.sendCard(cardOpts, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Card sent"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("send-bank <threadId> <accountNumber>")
+        .description("Send a bank card (số tài khoản)")
+        .requiredOption("-b, --bank <name>", "Bank name (ocb, vcb, bidv) or BIN code")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .option("-n, --name <holder>", "Account holder name")
+        .action(async (threadId, accountNumber, opts) => {
+            try {
+                const { resolveBankBin, BIN_TO_DISPLAY } = await import("../utils/bank-helpers.js");
+                const bin = resolveBankBin(opts.bank);
+                if (!bin) {
+                    error(`Unknown bank: '${opts.bank}'`);
+                    return;
+                }
+                info(`Bank: ${BIN_TO_DISPLAY[bin] || bin} (BIN ${bin})`);
+
+                const payload = { binBank: bin, numAccBank: accountNumber };
+                if (opts.name) payload.nameAccBank = opts.name;
+                const result = await getApi().sendBankCard(payload, threadId, Number(opts.type));
+                output(result, program.opts().json, () =>
+                    success(`Bank card sent: ${BIN_TO_DISPLAY[bin]} / ${accountNumber}`),
+                );
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("send-qr-transfer <threadId> <accountNumber>")
+        .description("Generate VietQR and send as image")
+        .requiredOption("-b, --bank <name>", "Bank name or BIN code")
+        .option("-a, --amount <n>", "Transfer amount in VND", parseInt)
+        .option("-m, --content <text>", "Transfer content (max 50 chars)")
+        .option("--template <tpl>", "QR style: compact, print, qronly", "compact")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, accountNumber, opts) => {
+            try {
+                const { resolveBankBin, BIN_TO_DISPLAY, generateQrTransferImage } =
+                    await import("../utils/bank-helpers.js");
+                const bin = resolveBankBin(opts.bank);
+                if (!bin) {
+                    error(`Unknown bank: '${opts.bank}'`);
+                    return;
+                }
+                if (opts.content && opts.content.length > 50) {
+                    error(`Content too long (${opts.content.length} chars). VietQR max is 50.`);
+                    return;
+                }
+                info(
+                    `Generating QR: ${BIN_TO_DISPLAY[bin]} / ${accountNumber}${opts.amount ? ` / ${opts.amount.toLocaleString()}đ` : ""}`,
+                );
+
+                const qrPath = await generateQrTransferImage(
+                    bin,
+                    accountNumber,
+                    opts.amount,
+                    opts.content,
+                    opts.template,
+                );
+                if (!qrPath) {
+                    error("Failed to generate QR image");
+                    return;
+                }
+
+                const caption = [
+                    `QR chuyển khoản ${BIN_TO_DISPLAY[bin]} - ${accountNumber}`,
+                    opts.amount ? `${opts.amount.toLocaleString()}đ` : null,
+                    opts.content || null,
+                ]
+                    .filter(Boolean)
+                    .join(" - ");
+
+                const result = await getApi().sendMessage(
+                    { msg: caption, attachments: [qrPath] },
+                    threadId,
+                    Number(opts.type),
+                );
+
+                // Cleanup temp file
+                try {
+                    (await import("fs")).unlinkSync(qrPath);
+                } catch {}
+
+                output(result, program.opts().json, () => success(`QR transfer sent to ${threadId}`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("sticker <threadId> <keyword>")
+        .description("Search and send a sticker")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (threadId, keyword, opts) => {
+            try {
+                const api = getApi();
+                const search = await api.searchSticker(keyword);
+                const stickerId = search?.[0]?.stickerId || "";
+                if (!stickerId) {
+                    error("No sticker found");
+                    return;
+                }
+                const result = await api.sendSticker(stickerId, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Sticker sent"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("react <msgId> <threadId> <reaction>")
+        .description("React to a message with an emoji")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (msgId, threadId, reaction, opts) => {
+            try {
+                const result = await getApi().addReaction(reaction, msgId, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success(`Reacted with '${reaction}'`));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("delete <msgId> <threadId>")
+        .description("Delete a message you sent")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (msgId, threadId, opts) => {
+            try {
+                const result = await getApi().deleteMessage(msgId, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Message deleted"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+
+    msg.command("forward <msgId> <threadId>")
+        .description("Forward a message to another thread")
+        .option("-t, --type <n>", "Thread type: 0=User, 1=Group", "0")
+        .action(async (msgId, threadId, opts) => {
+            try {
+                const result = await getApi().forwardMessage(msgId, threadId, Number(opts.type));
+                output(result, program.opts().json, () => success("Message forwarded"));
+            } catch (e) {
+                error(e.message);
+            }
+        });
+}

package/src/core/accounts.js

@@ -0,0 +1,93 @@
+/**
+ * Multi-account registry at ~/.zalo-agent-cli/accounts.json
+ * Maps each account to its own proxy (1:1) and tracks active account.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { CONFIG_DIR, deleteCredentials } from "./credentials.js";
+
+const ACCOUNTS_FILE = `${CONFIG_DIR}/accounts.json`;
+
+function ensureDir() {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function load() {
+    if (!existsSync(ACCOUNTS_FILE)) return [];
+    try {
+        return JSON.parse(readFileSync(ACCOUNTS_FILE, "utf-8"));
+    } catch {
+        return [];
+    }
+}
+
+function save(accounts) {
+    ensureDir();
+    writeFileSync(ACCOUNTS_FILE, JSON.stringify(accounts, null, 2), "utf-8");
+    chmodSync(ACCOUNTS_FILE, 0o600);
+}
+
+/** List all registered accounts. */
+export function listAccounts() {
+    return load();
+}
+
+/** Get currently active account or null. */
+export function getActive() {
+    return load().find((a) => a.active) || null;
+}
+
+/** Set an account as active (deactivates others). Returns false if not found. */
+export function setActive(ownId) {
+    const accounts = load();
+    let found = false;
+    for (const a of accounts) {
+        if (a.ownId === ownId) {
+            a.active = true;
+            found = true;
+        } else {
+            a.active = false;
+        }
+    }
+    if (found) save(accounts);
+    return found;
+}
+
+/** Register a new account or update existing. New account becomes active. */
+export function addAccount(ownId, name = "", proxy = null) {
+    const accounts = load();
+    const existing = accounts.find((a) => a.ownId === ownId);
+    if (existing) {
+        existing.name = name || existing.name || "";
+        existing.proxy = proxy;
+    } else {
+        for (const a of accounts) a.active = false;
+        accounts.push({ ownId, name, proxy, active: true });
+    }
+    save(accounts);
+}
+
+/** Remove account from registry and delete its credentials. */
+export function removeAccount(ownId) {
+    const accounts = load();
+    const filtered = accounts.filter((a) => a.ownId !== ownId);
+    if (filtered.length === accounts.length) return false;
+    // If removed was active, activate first remaining
+    if (filtered.length && !filtered.some((a) => a.active)) {
+        filtered[0].active = true;
+    }
+    save(filtered);
+    deleteCredentials(ownId);
+    return true;
+}
+
+/** Get account by ownId. */
+export function getAccount(ownId) {
+    return load().find((a) => a.ownId === ownId) || null;
+}
+
+/** Get proxy URL for a specific account. */
+export function getProxyFor(ownId) {
+    const acc = getAccount(ownId);
+    return acc?.proxy || null;
+}

package/src/core/credentials.js

@@ -0,0 +1,63 @@
+/**
+ * Per-account credential storage at ~/.zalo-agent-cli/credentials/
+ * All credential files use 0600 permissions (owner read/write only).
+ */
+
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const CONFIG_DIR = join(homedir(), ".zalo-agent-cli");
+export const CREDENTIALS_DIR = join(CONFIG_DIR, "credentials");
+
+/** Ensure config directories exist. */
+function ensureDirs() {
+    mkdirSync(CREDENTIALS_DIR, { recursive: true });
+}
+
+function credPath(ownId) {
+    return join(CREDENTIALS_DIR, `cred_${ownId}.json`);
+}
+
+/**
+ * Save credentials for a specific account.
+ * @param {string} ownId
+ * @param {object} creds - {imei, cookie, userAgent, language?}
+ * @returns {string} File path
+ */
+export function saveCredentials(ownId, creds) {
+    ensureDirs();
+    const target = credPath(ownId);
+    writeFileSync(target, JSON.stringify(creds, null, 2), "utf-8");
+    chmodSync(target, 0o600);
+    return target;
+}
+
+/**
+ * Load credentials for a specific account.
+ * @param {string} ownId
+ * @returns {object|null}
+ */
+export function loadCredentials(ownId) {
+    const target = credPath(ownId);
+    if (!existsSync(target)) return null;
+    try {
+        return JSON.parse(readFileSync(target, "utf-8"));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Delete credentials for a specific account.
+ * @param {string} ownId
+ * @returns {boolean}
+ */
+export function deleteCredentials(ownId) {
+    const target = credPath(ownId);
+    if (existsSync(target)) {
+        unlinkSync(target);
+        return true;
+    }
+    return false;
+}

package/src/core/zalo-client.js

@@ -0,0 +1,128 @@
+/**
+ * Zalo client wrapper — direct zca-js API calls with proxy support.
+ * Manages a single Zalo instance per process. Swap on account switch.
+ */
+
+import { Zalo, LoginQRCallbackEventType } from "zca-js";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import nodefetch from "node-fetch";
+import { getActive } from "./accounts.js";
+import { loadCredentials } from "./credentials.js";
+import { info } from "../utils/output.js";
+
+let _api = null;
+let _ownId = null;
+
+/** Get the current API instance or throw. */
+export function getApi() {
+    if (!_api) throw new Error("Not logged in. Run: zalo-agent login");
+    return _api;
+}
+
+/** Get current owner ID. */
+export function getOwnId() {
+    return _ownId;
+}
+
+/** Check if logged in. */
+export function isLoggedIn() {
+    return _api !== null;
+}
+
+/** Create a Zalo instance with optional proxy. Suppress logs in JSON mode. */
+function createZalo(proxyUrl) {
+    const opts = {
+        // Suppress zca-js internal INFO logs when --json to keep stdout clean
+        logging: !process.env.ZALO_JSON_MODE,
+    };
+    if (proxyUrl) {
+        opts.agent = new HttpsProxyAgent(proxyUrl);
+        opts.polyfill = nodefetch;
+    }
+    return new Zalo(opts);
+}
+
+/** Set the active API + ownId (used after login). */
+function setSession(api, ownId) {
+    _api = api;
+    _ownId = ownId;
+}
+
+/** Clear current session. */
+export function clearSession() {
+    _api = null;
+    _ownId = null;
+}
+
+/**
+ * Login with saved credentials + proxy.
+ * @param {object} creds - {imei, cookie, userAgent, language?}
+ * @param {string|null} proxyUrl
+ * @returns {object} - {api, ownId}
+ */
+export async function loginWithCredentials(creds, proxyUrl = null) {
+    const zalo = createZalo(proxyUrl);
+    const api = await zalo.login(creds);
+    const ownId = api.getOwnId?.() || null;
+    setSession(api, ownId);
+    return { api, ownId };
+}
+
+/**
+ * Login via QR code with optional proxy.
+ * @param {string|null} proxyUrl
+ * @param {function} onQrGenerated - callback(qrData) when QR is ready
+ * @returns {object} - {api, ownId}
+ */
+export async function loginWithQR(proxyUrl = null, onQrGenerated = null) {
+    const zalo = createZalo(proxyUrl);
+
+    const api = await zalo.loginQR(null, (event) => {
+        if (event.type === LoginQRCallbackEventType.QRCodeGenerated && onQrGenerated) {
+            onQrGenerated(event);
+        }
+    });
+
+    const ownId = api.getOwnId?.() || null;
+    setSession(api, ownId);
+    return { api, ownId };
+}
+
+/**
+ * Extract credentials from current session for saving.
+ * @returns {object} - {imei, cookie, userAgent, language}
+ */
+export function extractCredentials() {
+    const api = getApi();
+    const ctx = api.getContext();
+    return {
+        imei: ctx.imei,
+        cookie: ctx.cookie,
+        userAgent: ctx.userAgent,
+        language: ctx.language,
+    };
+}
+
+/**
+ * Auto-login using active account from registry.
+ * Called before commands that need authentication.
+ * @param {boolean} jsonMode - suppress output in JSON mode
+ */
+export async function autoLogin(jsonMode = false) {
+    if (_api) return; // Already logged in
+
+    const active = getActive();
+    if (!active) return;
+
+    const creds = loadCredentials(active.ownId);
+    if (!creds) return;
+
+    try {
+        await loginWithCredentials(creds, active.proxy || null);
+        if (!jsonMode) {
+            info(`Auto-login: ${active.name || active.ownId}`);
+        }
+    } catch {
+        // Silent failure — user can login manually
+    }
+}

package/src/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+/**
+ * zalo-agent-cli — CLI for Zalo automation with multi-account + proxy support.
+ * Entry point: registers all command groups via Commander.js.
+ */
+
+import { Command } from "commander";
+import { registerLoginCommands } from "./commands/login.js";
+import { registerMsgCommands } from "./commands/msg.js";
+import { registerFriendCommands } from "./commands/friend.js";
+import { registerGroupCommands } from "./commands/group.js";
+import { registerConvCommands } from "./commands/conv.js";
+import { registerAccountCommands } from "./commands/account.js";
+import { autoLogin } from "./core/zalo-client.js";
+
+const program = new Command();
+
+program
+    .name("zalo-agent")
+    .description("CLI tool for Zalo automation — multi-account, proxy, bank transfers, QR payments")
+    .version("1.0.0")
+    .option("--json", "Output results as JSON (machine-readable)")
+    .hook("preAction", async (thisCommand) => {
+        // Suppress zca-js internal logs in JSON mode to keep stdout clean for piping
+        if (program.opts().json) {
+            process.env.ZALO_JSON_MODE = "1";
+        }
+        // Auto-login before any command that needs it (skip for login/account commands)
+        const cmdName = thisCommand.args?.[0] || thisCommand.name();
+        const skipAutoLogin = ["login", "account", "help", "version"].includes(cmdName);
+        if (!skipAutoLogin) {
+            await autoLogin(program.opts().json);
+        }
+    });
+
+// Register all command groups
+registerLoginCommands(program);
+registerMsgCommands(program);
+registerFriendCommands(program);
+registerGroupCommands(program);
+registerConvCommands(program);
+registerAccountCommands(program);
+
+program.parse();