@ardennguyen/zalo-agent-cli 2.0.0 → 2.1.1

package/src/commands/sync.js

@@ -1,7 +1,7 @@
 import { join } from "path";
 import { getApi } from "../core/zalo-client.js";
 import { getActive } from "../core/accounts.js";
-import { CONFIG_DIR } from "../core/credentials.js";
+import { getAccountDir } from "../core/credentials.js";
 import { acquireLock, releaseLock, checkLock } from "../core/lock.js";
 import { error, info, success, warning, output } from "../utils/output.js";
 import { parseIntAtLeast, parseIntOption } from "../utils/parse-options.js";
@@ -344,7 +344,7 @@ const MB = 1024 * 1024;
 
 /** Download attachments recorded by an earlier sync. No phone, no socket. */
 async function runMediaDownload(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     let kinds;
@@ -464,7 +464,7 @@ async function runMediaDownload(activeAcc, opts) {
 
 /** Reclaim media held by conversations the account no longer has. */
 async function runPruneOrphans(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     // The recorded definition: the same set `sync`'s warning counts and
@@ -521,7 +521,7 @@ async function runPruneOrphans(activeAcc, opts) {
 
 /** Delete downloaded media older than N days. Never removes message rows. */
 async function runMediaPrune(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     // "all" is a mode, not a very large number of days: a cutoff computed from
@@ -570,7 +570,7 @@ async function runMediaPrune(activeAcc, opts) {
 
 /** Sync board items + reminders for the cached threads. No phone, no socket. */
 async function runBoardSync(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     let api;
@@ -664,7 +664,7 @@ async function boardPass(api, opts) {
  * @param {{wait?: number, pages?: number, applyRemovals?: boolean}} opts
  */
 async function runReactionSync(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     let api;
@@ -862,7 +862,7 @@ function reportReactionDrain(stats, opts) {
 
 /** Walk the zCloud index. No phone, no socket. */
 async function runCloudSync(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     let api;
@@ -998,7 +998,7 @@ async function reconnectListener(api, waitMs = 30000) {
  * @param {{force?: boolean, wait?: number, days?: number}} opts
  */
 async function runTransferSync(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
 
     let api;
     let syncManager;
@@ -1501,7 +1501,7 @@ function printPlan(plan, win, jsonMode) {
  * @param {boolean} jsonMode
  */
 async function runUnifiedSync(activeAcc, opts, jsonMode) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
     initDb(join(accountDir, "zalo.db"));
 
     let api;
@@ -1890,7 +1890,7 @@ async function runUnifiedSync(activeAcc, opts, jsonMode) {
  * @param {{wait?: number}} opts
  */
 async function runSocketBackfill(activeAcc, opts) {
-    const accountDir = join(CONFIG_DIR, "accounts", activeAcc.ownId);
+    const accountDir = getAccountDir(activeAcc.ownId);
 
     // Build the SyncManager first so we can consult the local sync-freshness
     // marker BEFORE touching the network. A redundant run should neither open

package/src/core/accounts.js

@@ -5,19 +5,22 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, rmSync } from "fs";
 import { join } from "path";
-import { CONFIG_DIR, deleteCredentials } from "./credentials.js";
+import { CONFIG_DIR, getAccountDir, deleteCredentials } from "./credentials.js";
 import { checkLock } from "./lock.js";
 
-const ACCOUNTS_FILE = `${CONFIG_DIR}/accounts.json`;
+function accountsFile() {
+    return join(CONFIG_DIR, "accounts.json");
+}
 
 function ensureDir() {
     mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
 function load() {
-    if (!existsSync(ACCOUNTS_FILE)) return [];
+    const file = accountsFile();
+    if (!existsSync(file)) return [];
     try {
-        return JSON.parse(readFileSync(ACCOUNTS_FILE, "utf-8"));
+        return JSON.parse(readFileSync(file, "utf-8"));
     } catch {
         return [];
     }
@@ -25,8 +28,9 @@ function load() {
 
 function save(accounts) {
     ensureDir();
-    writeFileSync(ACCOUNTS_FILE, JSON.stringify(accounts, null, 2), "utf-8");
-    chmodSync(ACCOUNTS_FILE, 0o600);
+    const file = accountsFile();
+    writeFileSync(file, JSON.stringify(accounts, null, 2), "utf-8");
+    chmodSync(file, 0o600);
 }
 
 /** List all registered accounts. */
@@ -102,7 +106,7 @@ export function addAccount(ownId, name = "", proxy = null) {
  * @returns {{wiped: boolean, skippedLocked?: {pid: number}}}
  */
 export function wipeAccountDir(ownId) {
-    const accountDir = join(CONFIG_DIR, "accounts", ownId);
+    const accountDir = getAccountDir(ownId);
     if (!existsSync(accountDir)) return { wiped: false };
 
     const lockStatus = checkLock(accountDir);

package/src/core/credentials.js

@@ -1,14 +1,162 @@
 /**
- * Per-account credential storage at ~/.zalo-agent-cli/credentials/
+ * Per-account credential storage and configurable runtime storage paths.
+ *
+ * Defaults:
+ *   CONFIG_DIR      = ~/.zalo-agent-cli             (env: ZALO_CONFIG_DIR,      flag: --config-dir)
+ *   CREDENTIALS_DIR = <CONFIG_DIR>/credentials      (env: ZALO_CREDENTIALS_DIR, flag: --credentials-dir)
+ *   DATA_DIR        = <CONFIG_DIR>/accounts         (env: ZALO_DATA_DIR,        flag: --data-dir)
+ *   MEDIA_DIR       = null (<DATA_DIR>/<id>/media)  (env: ZALO_MEDIA_DIR,       flag: --media-dir)
+ *
  * All credential files use 0600 permissions (owner read/write only).
  */
 
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, chmodSync } from "fs";
-import { join } from "path";
+import { join, resolve } from "path";
 import { homedir } from "os";
+import { parseEnv } from "node:util";
 
-export const CONFIG_DIR = join(homedir(), ".zalo-agent-cli");
-export const CREDENTIALS_DIR = join(CONFIG_DIR, "credentials");
+const defaultConfigDir = join(homedir(), ".zalo-agent-cli");
+
+/**
+ * Load environment variables from `.env` files without overwriting existing `process.env` keys.
+ * Search order (first defined value wins):
+ *   1. Explicit `envFile` (`--env-file <path>` or `ZALO_ENV_FILE`)
+ *   2. `<cwd>/.env` (skipped when `ZALO_SANDBOX_ACTIVE=1` so offline tests stay isolated)
+ *   3. `<configDir>/.env` (default `~/.zalo-agent-cli/.env`)
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.envFile]
+ * @param {string} [opts.configDir]
+ * @returns {string[]} Paths of `.env` files that were loaded
+ */
+export function loadDotEnvFiles(opts = {}) {
+    const candidates = [];
+    const explicit = opts.envFile || process.env.ZALO_ENV_FILE;
+    if (explicit) candidates.push(resolve(explicit));
+    if (process.env.ZALO_SANDBOX_ACTIVE !== "1") {
+        candidates.push(resolve(process.cwd(), ".env"));
+    }
+    const cfgRoot = opts.configDir
+        ? resolve(opts.configDir)
+        : process.env.ZALO_CONFIG_DIR
+          ? resolve(process.env.ZALO_CONFIG_DIR)
+          : defaultConfigDir;
+    candidates.push(join(cfgRoot, ".env"));
+
+    const loaded = [];
+    const seen = new Set();
+    for (const filePath of candidates) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        if (!existsSync(filePath)) continue;
+        try {
+            const parsed = parseEnv(readFileSync(filePath, "utf-8"));
+            for (const [k, v] of Object.entries(parsed)) {
+                if (process.env[k] === undefined) {
+                    process.env[k] = v;
+                }
+            }
+            loaded.push(filePath);
+        } catch {
+            /* ignore unreadable .env file */
+        }
+    }
+    return loaded;
+}
+
+export let CONFIG_DIR = process.env.ZALO_CONFIG_DIR ? resolve(process.env.ZALO_CONFIG_DIR) : defaultConfigDir;
+export let CREDENTIALS_DIR = process.env.ZALO_CREDENTIALS_DIR
+    ? resolve(process.env.ZALO_CREDENTIALS_DIR)
+    : join(CONFIG_DIR, "credentials");
+export let DATA_DIR =
+    process.env.ZALO_DATA_DIR || process.env.ZALO_DB_DIR
+        ? resolve(process.env.ZALO_DATA_DIR || process.env.ZALO_DB_DIR)
+        : join(CONFIG_DIR, "accounts");
+export let MEDIA_DIR = process.env.ZALO_MEDIA_DIR ? resolve(process.env.ZALO_MEDIA_DIR) : null;
+
+/**
+ * Override storage directories from CLI options, `.env` files, or runtime config.
+ * Updates live ESM bindings (CONFIG_DIR, CREDENTIALS_DIR, DATA_DIR, MEDIA_DIR)
+ * and synchronizes process.env so child helpers see the same paths.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.envFile] - Optional explicit `.env` file path (`--env-file` / `ZALO_ENV_FILE`)
+ * @param {boolean} [opts.loadEnv=true] - Whether to load `.env` files before resolving paths
+ * @param {string} [opts.configDir] - Root config directory (accounts.json, mcp-config.json, qr.png)
+ * @param {string} [opts.credentialsDir] - Credentials directory (cred_<ownId>.json)
+ * @param {string} [opts.dataDir] - Per-account runtime/database root (<dataDir>/<ownId>/zalo.db)
+ * @param {string} [opts.mediaDir] - Downloaded media root (<mediaDir>/<threadId>/)
+ * @param {string} [opts.oaDir] - Official Account credentials directory (oa-credentials.json)
+ */
+export function configureStoragePaths(opts = {}) {
+    if (opts.loadEnv !== false) {
+        loadDotEnvFiles({ envFile: opts.envFile, configDir: opts.configDir });
+    }
+
+    const nextConfig = opts.configDir || process.env.ZALO_CONFIG_DIR;
+    if (nextConfig) {
+        CONFIG_DIR = resolve(nextConfig);
+        if (opts.configDir) process.env.ZALO_CONFIG_DIR = CONFIG_DIR;
+    }
+
+    const nextCreds = opts.credentialsDir || process.env.ZALO_CREDENTIALS_DIR;
+    if (nextCreds) {
+        CREDENTIALS_DIR = resolve(nextCreds);
+        if (opts.credentialsDir) process.env.ZALO_CREDENTIALS_DIR = CREDENTIALS_DIR;
+    } else if (nextConfig) {
+        CREDENTIALS_DIR = join(CONFIG_DIR, "credentials");
+    }
+
+    const nextData = opts.dataDir || process.env.ZALO_DATA_DIR || process.env.ZALO_DB_DIR;
+    if (nextData) {
+        DATA_DIR = resolve(nextData);
+        if (opts.dataDir) process.env.ZALO_DATA_DIR = DATA_DIR;
+    } else if (nextConfig) {
+        DATA_DIR = join(CONFIG_DIR, "accounts");
+    }
+
+    if (opts.mediaDir !== undefined) {
+        MEDIA_DIR = opts.mediaDir ? resolve(opts.mediaDir) : null;
+        if (MEDIA_DIR) process.env.ZALO_MEDIA_DIR = MEDIA_DIR;
+        else delete process.env.ZALO_MEDIA_DIR;
+    } else if (process.env.ZALO_MEDIA_DIR) {
+        MEDIA_DIR = resolve(process.env.ZALO_MEDIA_DIR);
+    }
+
+    if (opts.oaDir) {
+        process.env.ZALO_OA_DIR = resolve(opts.oaDir);
+    }
+}
+
+/**
+ * Get the per-account runtime/database directory (<DATA_DIR>/<ownId>).
+ * @param {string} ownId
+ * @returns {string}
+ */
+export function getAccountDir(ownId) {
+    return join(DATA_DIR, String(ownId));
+}
+
+/**
+ * Get the per-account SQLite database path (<DATA_DIR>/<ownId>/zalo.db).
+ * @param {string} ownId
+ * @returns {string}
+ */
+export function getAccountDbPath(ownId) {
+    return join(getAccountDir(ownId), "zalo.db");
+}
+
+/**
+ * Resolve the media root directory for an account.
+ * Precedence: explicit override -> MEDIA_DIR (--media-dir / ZALO_MEDIA_DIR) -> <accountDir>/media.
+ * @param {string} accountDir
+ * @param {string|null} [overrideRoot]
+ * @returns {string}
+ */
+export function resolveMediaRoot(accountDir, overrideRoot = null) {
+    const custom = overrideRoot || MEDIA_DIR;
+    return custom ? resolve(custom) : resolve(accountDir, "media");
+}
 
 /** Ensure config directories exist. */
 function ensureDirs() {

package/src/core/current-user-names.js

@@ -0,0 +1,104 @@
+/**
+ * Read the account's complete alias snapshot. Do not reuse a previous snapshot:
+ * an absent entry means the owner removed that alias. Failed/partial reads do
+ * not pretend an old alias is current. Diagnostics never include identities.
+ * @param {object} api - current authenticated API
+ * @param {Function} [log] - diagnostic sink
+ * @returns {Promise<Map<string, string>>} UID -> account-owned alias
+ */
+export async function readUserAliases(api, log = () => {}) {
+    const aliases = new Map();
+    try {
+        if (typeof api?.getAliasList !== "function") return aliases;
+        for (let page = 1; page <= 1000; page++) {
+            const result = await api.getAliasList(100, page);
+            if (!Array.isArray(result?.items)) throw new Error("invalid alias page");
+            let added = 0;
+            for (const item of result.items) {
+                if (item.userId && typeof item.alias === "string" && item.alias.trim()) {
+                    const uid = String(item.userId);
+                    if (!aliases.has(uid)) added++;
+                    aliases.set(uid, item.alias);
+                }
+            }
+            if (result.items.length < 100) return aliases;
+            if (!added) throw new Error("alias pagination did not advance");
+        }
+        throw new Error("alias pagination limit reached");
+    } catch {
+        log("current aliases unavailable; falling back to profile names or UIDs");
+        return new Map();
+    }
+}
+
+/**
+ * Select a current label independently of any per-message historical name.
+ * @param {string} uid - canonical user ID
+ * @param {object} [profile] - fresh Zalo profile
+ * @param {Map<string, string>} [aliases] - account-owned aliases
+ * @returns {{name: string, source: string}} label and provenance
+ */
+export function currentUserName(uid, profile, aliases = new Map()) {
+    const id = String(uid || "");
+    const alias = aliases.get(id);
+    if (alias) return { name: alias, source: "alias" };
+    // displayName can itself be an alias. Only zaloName establishes the
+    // profile-name fallback independently of the owner's alias snapshot.
+    const name = profile?.zaloName;
+    return name ? { name, source: "zalo" } : { name: id, source: "uid" };
+}
+
+/**
+ * Resolve current names in batches, with no cross-request/account name cache.
+ * Failures degrade to UID, never to a historical senderName. Profiles can be
+ * supplied by a fresh friend-list response to avoid fetching them twice.
+ * @param {object} api - current authenticated API
+ * @param {string[]} uids - IDs to display
+ * @param {object} [options]
+ * @returns {Promise<Map<string, {name: string, source: string}>>} UID -> current label
+ */
+export async function resolveCurrentUserNames(api, uids, { aliases, profiles = new Map(), log = () => {} } = {}) {
+    const ids = [...new Set(uids.filter(Boolean).map(String))];
+    if (!ids.length) return new Map();
+    const aliasRequest = aliases ? Promise.resolve(aliases) : readUserAliases(api, log);
+    const fresh = new Map(profiles);
+    const missing = ids.filter((id) => /^[1-9][0-9]*$/.test(id) && !fresh.has(id));
+    for (let i = 0; i < missing.length; i += 100) {
+        try {
+            if (typeof api?.getUserInfo !== "function") break;
+            const result = await api.getUserInfo(missing.slice(i, i + 100));
+            for (const bag of [result?.changed_profiles, result?.unchanged_profiles]) {
+                for (const [uid, profile] of Object.entries(bag || {})) {
+                    if (profile) fresh.set(uid, profile);
+                }
+            }
+        } catch {
+            log("current profiles unavailable; falling back to aliases or UIDs");
+        }
+    }
+    const ownedAliases = await aliasRequest;
+    return new Map(ids.map((id) => [id, currentUserName(id, fresh.get(id), ownedAliases)]));
+}
+
+/**
+ * Decorate copied messages with current labels; senderName stays historical.
+ * DM titles use the peer's UID, including for an outgoing message from self.
+ * @param {object} api - current authenticated API
+ * @param {object[]} messages - cached or live rows
+ * @param {string[]} [dmThreadIds] - known DM peer IDs, never group IDs
+ * @returns {Promise<object[]>} detached display rows
+ */
+export async function withCurrentSenderNames(api, messages, dmThreadIds = []) {
+    const peers = new Set(dmThreadIds.map(String));
+    const names = await resolveCurrentUserNames(api, [...messages.map((m) => m.senderId), ...peers]);
+    return messages.map((m) => {
+        const sender = names.get(String(m.senderId)) || { name: null, source: "uid" };
+        const peer = peers.has(String(m.threadId)) && names.get(String(m.threadId));
+        return {
+            ...m,
+            senderDisplayName: sender.name,
+            senderDisplayNameSource: sender.source,
+            ...(peer && { threadName: peer.name }),
+        };
+    });
+}

package/src/core/daemon-account.js

@@ -0,0 +1,61 @@
+import { InvalidArgumentError } from "commander";
+import { getActive, getAccount } from "./accounts.js";
+import { loadCredentials } from "./credentials.js";
+import { loginWithCredentials, clearSession } from "./zalo-client.js";
+
+/** Validate a full numeric account ID without number coercion, names, or prefix matching. */
+export function parseAccountId(value) {
+    if (typeof value !== "string" || !/^[1-9][0-9]*$/.test(value)) {
+        throw new InvalidArgumentError("--account requires a full numeric account ID, not a name or partial ID");
+    }
+    return value;
+}
+
+/**
+ * Snapshot one daemon's account at startup without changing the shared registry.
+ * Even an implicit active-account selection stays pinned for this process.
+ * @param {string} [id] - exact registered account ID, never a display name
+ * @param {object} [deps] - offline-test collaborators
+ * @returns {Readonly<object>} frozen account identity and proxy configuration
+ */
+export function selectDaemonAccount(id, { active = getActive, lookup = getAccount } = {}) {
+    const selected = id === undefined ? active() : lookup(parseAccountId(id));
+    if (!selected) {
+        throw new Error(
+            id === undefined
+                ? "No active account. Please login first. You can also pass --account <ID>."
+                : "Account ID is not registered. Use `zalo-agent account list` to find the full ID.",
+        );
+    }
+    const ownId = parseAccountId(selected.ownId);
+    if (id !== undefined && ownId !== id) throw new Error("Account lookup returned a different ID; refusing to start");
+    return Object.freeze({ ...selected, ownId });
+}
+
+/**
+ * Authenticate only the daemon's pinned account, including after a disconnect.
+ * Never consult the active registry or retain a session for a different user.
+ * The caller must hold this account's daemon lock before invoking this function.
+ * @param {object} account - selectDaemonAccount() snapshot
+ * @param {object} [deps] - offline-test collaborators
+ * @returns {Promise<object>} authenticated API/ownId result
+ */
+export async function loginDaemonAccount(
+    account,
+    { read = loadCredentials, login = loginWithCredentials, reset = clearSession } = {},
+) {
+    const id = parseAccountId(account.ownId);
+    reset();
+    const credentials = read(id);
+    if (!credentials) throw new Error("No saved credentials for the pinned account. Log in to that account first.");
+    try {
+        const session = await login(credentials, account.proxy || null);
+        if (String(session?.ownId || "") !== id) {
+            throw new Error("Authenticated account does not match the pinned ID; refusing to attach its listener");
+        }
+        return session;
+    } catch (e) {
+        reset();
+        throw e;
+    }
+}

package/src/core/daemon-sync.js

@@ -69,8 +69,8 @@ export function createSyncRunners({ getApi, accountName }) {
          *
          * Still prompts the owner's phone exactly once — routing through the
          * daemon removes the second WebSocket, not the confirmation. The
-         * daemon never calls this on its own; only a `zalo-agent sync` the
-         * owner typed reaches it.
+         * daemon never calls this on its own; an explicit CLI sync or MCP
+         * sync request authorized by the owner reaches it.
          *
          * @param {{days?: number|null, from?: string|number, waitMs?: number,
          *   shardSize?: number, waveSize?: number}} params

package/src/core/db.js

@@ -446,10 +446,25 @@ export function runInTransaction(fn) {
 export function insertMessage(msg) {
     if (!db) throw new Error("Database not initialized");
 
+    // A replay may resolve an opaque sender from an older sync. Never let an
+    // unresolved replay replace a canonical live UID, or a different numeric
+    // sender overwrite an already established identity.
+    const canResolveSender = `(
+      COALESCE(messages.senderId, '') = '' OR
+      (messages.senderId GLOB '*[^0-9]*' AND
+       excluded.senderId <> '' AND excluded.senderId <> '0' AND
+       excluded.senderId NOT GLOB '*[^0-9]*')
+    )`;
     const stmt = db.prepare(`
     INSERT INTO messages (msgId, threadId, senderId, senderName, text, timestamp, type, raw_data, localPath, has_attachment, msgStatus)
     VALUES (@msgId, @threadId, @senderId, @senderName, @text, @timestamp, @type, @raw_data, @localPath, @has_attachment, @msgStatus)
     ON CONFLICT(msgId) DO UPDATE SET
+      senderId = CASE WHEN ${canResolveSender} THEN excluded.senderId ELSE messages.senderId END,
+      senderName = CASE
+        WHEN COALESCE(messages.senderName, '') = '' AND
+             (messages.senderId = excluded.senderId OR ${canResolveSender})
+        THEN COALESCE(NULLIF(excluded.senderName, ''), messages.senderName)
+        ELSE messages.senderName END,
       -- A removal is terminal. Once a row is a tombstone, a later write of the
       -- same msgId -- a re-sync, a history replay, a backfill -- must not bring
       -- the message back or replace the tombstone's record of HOW it was

package/src/core/logout.js

@@ -21,7 +21,7 @@
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { existsSync, rmSync } from "node:fs";
-import { CONFIG_DIR, deleteCredentials } from "./credentials.js";
+import { getAccountDir, deleteCredentials } from "./credentials.js";
 import { checkLock } from "./lock.js";
 
 const require = createRequire(import.meta.url);
@@ -164,7 +164,7 @@ const EMPTY_REPLY = /Failed to parse response data/;
  * @returns {{dbDeleted: boolean, mediaDeleted: boolean}}
  */
 export function deleteLocalHistory(ownId) {
-    const accountDir = join(CONFIG_DIR, "accounts", ownId);
+    const accountDir = getAccountDir(ownId);
     let dbDeleted = false;
     let mediaDeleted = false;
     if (existsSync(accountDir)) {
@@ -194,7 +194,7 @@ export function deleteLocalHistory(ownId) {
  * @returns {number|null}
  */
 export function lockHolder(ownId) {
-    const lock = checkLock(join(CONFIG_DIR, "accounts", ownId));
+    const lock = checkLock(getAccountDir(ownId));
     return lock.locked ? lock.pid : null;
 }
 

package/src/core/oa-client.js

@@ -1,22 +1,32 @@
 /**
  * Zalo Official Account API v3.0 client.
- * Wraps OA REST endpoints with node-fetch. No dependency on zca-js.
+ * Wraps OA REST endpoints with native fetch. No dependency on zca-js.
  * Credentials stored in ~/.zalo-agent/oa-credentials.json.
  */
 
 import fs from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import nodefetch from "node-fetch";
 
 const V3_BASE = "https://openapi.zalo.me/v3.0/oa";
 const V2_BASE = "https://openapi.zalo.me/v2.0/oa";
-const DATA_DIR = join(homedir(), ".zalo-agent");
-const OA_CREDS_FILE = join(DATA_DIR, "oa-credentials.json");
+
+/**
+ * Resolve the Official Account data directory (defaults to ~/.zalo-agent, or ZALO_OA_DIR).
+ * @returns {string}
+ */
+export function getOADataDir() {
+    return process.env.ZALO_OA_DIR ? resolve(process.env.ZALO_OA_DIR) : join(homedir(), ".zalo-agent");
+}
+
+function getOACredsFile() {
+    return join(getOADataDir(), "oa-credentials.json");
+}
 
 /** Ensure data directory exists. */
 function ensureDir() {
-    if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+    const dir = getOADataDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
 const OAUTH_URL = "https://oauth.zaloapp.com/v4/oa/permission";
@@ -25,12 +35,13 @@ const TOKEN_URL = "https://oauth.zaloapp.com/v4/oa/access_token";
 /** Save full OA credentials to disk with restricted file permissions. */
 export function saveOACreds(data, oaId = "default") {
     ensureDir();
+    const credsFile = getOACredsFile();
     let creds = {};
-    if (fs.existsSync(OA_CREDS_FILE)) {
-        creds = JSON.parse(fs.readFileSync(OA_CREDS_FILE, "utf8"));
+    if (fs.existsSync(credsFile)) {
+        creds = JSON.parse(fs.readFileSync(credsFile, "utf8"));
     }
     creds[oaId] = { ...creds[oaId], ...data, updatedAt: new Date().toISOString() };
-    fs.writeFileSync(OA_CREDS_FILE, JSON.stringify(creds, null, 2), { mode: 0o600 });
+    fs.writeFileSync(credsFile, JSON.stringify(creds, null, 2), { mode: 0o600 });
 }
 
 /** Save OA access token to disk (backward compat). */
@@ -40,8 +51,9 @@ export function saveOAToken(accessToken, oaId = "default") {
 
 /** Load full OA credentials from disk. */
 export function loadOACreds(oaId = "default") {
-    if (!fs.existsSync(OA_CREDS_FILE)) return null;
-    const creds = JSON.parse(fs.readFileSync(OA_CREDS_FILE, "utf8"));
+    const credsFile = getOACredsFile();
+    if (!fs.existsSync(credsFile)) return null;
+    const creds = JSON.parse(fs.readFileSync(credsFile, "utf8"));
     return creds[oaId] || null;
 }
 
@@ -70,7 +82,7 @@ export function getOAuthUrl(appId, redirectUri = "http://localhost:3456/callback
 
 /** Exchange authorization code for access + refresh tokens. */
 export async function exchangeCode(code, appId, secretKey, redirectUri = "http://localhost:3456/callback") {
-    const res = await nodefetch(TOKEN_URL, {
+    const res = await fetch(TOKEN_URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded", secret_key: secretKey },
         body: new URLSearchParams({
@@ -85,7 +97,7 @@ export async function exchangeCode(code, appId, secretKey, redirectUri = "http:/
 
 /** Refresh access token using refresh token. */
 export async function refreshAccessToken(refreshToken, appId, secretKey) {
-    const res = await nodefetch(TOKEN_URL, {
+    const res = await fetch(TOKEN_URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded", secret_key: secretKey },
         body: new URLSearchParams({
@@ -106,7 +118,7 @@ async function oaFetch(url, { method = "GET", body, token, isFormData = false }
     if (body && !isFormData) opts.body = JSON.stringify(body);
     if (body && isFormData) opts.body = body;
 
-    const res = await nodefetch(url, opts);
+    const res = await fetch(url, opts);
     const data = await res.json();
     if (data.error && data.error !== 0) {
         throw new Error(`OA API error ${data.error}: ${data.message || JSON.stringify(data)}`);
@@ -281,7 +293,7 @@ export async function removeFollowerFromTag(userId, tagName, oaId = "default") {
 /** Upload image to OA (returns attachment_id). */
 export async function uploadImage(filePath, oaId = "default") {
     const token = getToken(oaId);
-    // Use native FormData-like via node-fetch's Blob
+    // Use native Blob and FormData
     const fileData = fs.readFileSync(filePath);
     const blob = new (await import("node:buffer")).Blob([fileData]);
     const form = new globalThis.FormData();

package/src/core/sync-v2/gid.js

@@ -83,6 +83,7 @@ export async function resolveNonFriendDms(api, globalIds, log = () => {}) {
 
     // 2. userId -> display name via getUserInfo (batched). Best-effort.
     const names = new Map();
+    const zaloNames = new Map();
     const uids = [...new Set([...idToUser.values()])];
     for (let i = 0; i < uids.length; i += NAME_BATCH) {
         const batch = uids.slice(i, i + NAME_BATCH);
@@ -90,7 +91,8 @@ export async function resolveNonFriendDms(api, globalIds, log = () => {}) {
             const info = await api.getUserInfo(batch);
             for (const bag of [info?.changed_profiles, info?.unchanged_profiles]) {
                 for (const [uid, p] of Object.entries(bag || {})) {
-                    if (!names.has(uid) && p) names.set(uid, p.displayName || p.zaloName || "");
+                    if (!names.has(uid) && p) names.set(uid, p.zaloName || p.displayName || "");
+                    if (p?.zaloName) zaloNames.set(uid, p.zaloName);
                 }
             }
         } catch (e) {
@@ -98,6 +100,7 @@ export async function resolveNonFriendDms(api, globalIds, log = () => {}) {
         }
     }
 
-    for (const [gid, uid] of idToUser) out.set(gid, { id: uid, name: names.get(uid) || "" });
+    for (const [gid, uid] of idToUser)
+        out.set(gid, { id: uid, name: names.get(uid) || "", zaloName: zaloNames.get(uid) || "" });
     return out;
 }