@ardennguyen/zalo-agent-cli 2.2.2 → 2.5.0

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

@@ -33,6 +33,7 @@ import {
     replaceLiveGroupEventPlaceholder,
     getThreadType,
     getRecentThreads,
+    findMessageByClientId,
 } from "../db.js";
 import { ensureAssets, loadCodecs } from "./assets.js";
 import { classifySyncMessage } from "./message-types.js";
@@ -403,12 +404,18 @@ export function isSessionComplete(state) {
  * where they overwrote one another through insertMessage's upsert.
  *
  * @param {object} msg - a decoded Sync2.Message.Message
+ * @param {string|null} [threadId=null] - thread id to match an already-stored live row by cliMsgId
  * @returns {string}
  */
-function syncMsgId(msg) {
+function syncMsgId(msg, threadId = null) {
     const gid = msg?.globalId;
     if (gid !== undefined && gid !== null && String(gid) !== "0" && String(gid) !== "") return String(gid);
-    return String(msg?.clientId ?? "");
+    const cid = String(msg?.clientId ?? "");
+    if (cid && cid !== "0" && threadId) {
+        const existing = findMessageByClientId(cid, threadId);
+        if (existing?.msgId) return String(existing.msgId);
+    }
+    return cid;
 }
 
 export class SyncV2 {
@@ -491,6 +498,22 @@ export class SyncV2 {
         }
     }
 
+    /** Refresh the active account's own display name via onSelfName if provided. */
+    async _refreshSelfName(onSelfName) {
+        if (typeof onSelfName !== "function") return;
+        const ownId = String(this.accountName || "");
+        if (!/^[1-9][0-9]*$/.test(ownId)) return;
+        try {
+            const names = await resolveCurrentUserNames(this.api, [ownId], { aliases: new Map() });
+            const self = names.get(ownId);
+            if (self && self.source === "zalo" && self.name) {
+                await onSelfName(self.name);
+            }
+        } catch {
+            /* best-effort registry sync */
+        }
+    }
+
     _send590(listener, kind, syncId, ek, ik, req) {
         listener.sendWs(
             {
@@ -564,6 +587,7 @@ export class SyncV2 {
         initDb(resolve(this.accountDir, "zalo.db"));
         this._refreshThreadNames(threadMap);
         await this._refreshDmNames(threadMap);
+        await this._refreshSelfName(opts.onSelfName);
 
         const L = this.api.listener;
         const sessions = new Map(); // syncId -> {kind, batches:[], statuses:[], done, err}
@@ -1142,7 +1166,7 @@ export class SyncV2 {
                                             // it does in a removal's
                                             // globalDelMsgId and a reaction's
                                             // gMsgID.
-                                            msgId: syncMsgId(msg),
+                                            msgId: syncMsgId(msg, threadId),
                                             threadId,
                                             senderId: senders.get(msg.senderId).id,
                                             senderName: senders.get(msg.senderId).name,

package/src/index.js

@@ -36,8 +36,11 @@ import { configureStoragePaths } from "./core/credentials.js";
 import { logoutNeedsSession } from "./core/logout.js";
 import { checkForUpdates, selfUpdate } from "./utils/update-check.js";
 import { applyCachedThreadType } from "./utils/thread-type.js";
+import { attachDaemonLogIfChild } from "./core/daemon-channel.js";
 import { success, error, warning } from "./utils/output.js";
 
+attachDaemonLogIfChild();
+
 const DISCLAIMER =
     "This tool uses unofficial Zalo APIs (zca-js) — your account may be banned. Use at your own risk. | Tool này dùng API Zalo không chính thức (zca-js) — account có thể bị ban. Tự chịu trách nhiệm.";
 

package/src/mcp/mcp-config.js

@@ -33,9 +33,72 @@ export function getDefaultConfig() {
             downloadDir: null, // unset -> the same per-account dir every other command uses
             autoOpen: true,
         },
+        tls: {
+            cert: null,
+            key: null,
+        },
+        oauth: {
+            clientId: null,
+            clientSecret: null,
+            issuerUrl: null,
+            clients: [],
+        },
+        webhookSecret: null,
+        httpPort: null,
+        host: null,
+    };
+}
+
+/**
+ * Deep-merge an override layer over a base MCP config object.
+ * @param {object} base
+ * @param {object} layer
+ * @returns {object}
+ */
+export function mergeMCPConfigLayer(base, layer) {
+    if (!layer || typeof layer !== "object") return base;
+    return {
+        ...base,
+        ...layer,
+        notify: { ...base.notify, ...(layer.notify || {}) },
+        limits: { ...base.limits, ...(layer.limits || {}) },
+        media: { ...base.media, ...(layer.media || {}) },
+        tls: { ...base.tls, ...(layer.tls || {}) },
+        oauth: {
+            ...base.oauth,
+            ...(layer.oauth || {}),
+            clients: Array.isArray(layer.oauth?.clients)
+                ? layer.oauth.clients
+                : Array.isArray(base.oauth?.clients)
+                  ? base.oauth.clients
+                  : [],
+        },
     };
 }
 
+/**
+ * Resolve an environment variable with per-account priority:
+ * checks `<baseKey>_<accountId>` first (when `accountId` is provided), then `<baseKey>`.
+ *
+ * @param {string} baseKey - Base environment variable name (e.g. "ZALO_MCP_AUTH_TOKEN")
+ * @param {string|null|undefined} accountId - Zalo account ID (`ownId`)
+ * @param {NodeJS.ProcessEnv} [env=process.env] - Environment dictionary
+ * @returns {string|null} Trimmed non-empty string, or null
+ */
+export function envForAccount(baseKey, accountId, env = process.env) {
+    if (accountId !== undefined && accountId !== null && String(accountId).trim()) {
+        const scoped = env?.[`${baseKey}_${String(accountId).trim()}`];
+        if (typeof scoped === "string" && scoped.trim()) {
+            return scoped.trim();
+        }
+    }
+    const globalVal = env?.[baseKey];
+    if (typeof globalVal === "string" && globalVal.trim()) {
+        return globalVal.trim();
+    }
+    return null;
+}
+
 /**
  * Load MCP config from disk, merged with defaults.
  *
@@ -52,14 +115,7 @@ export function loadMCPConfig(configPath) {
     try {
         const raw = readFileSync(configPath || mcpConfigFile(), "utf-8");
         const saved = JSON.parse(raw);
-        // Shallow merge: saved values override defaults
-        return {
-            ...defaults,
-            ...saved,
-            notify: { ...defaults.notify, ...saved.notify },
-            limits: { ...defaults.limits, ...saved.limits },
-            media: { ...defaults.media, ...saved.media },
-        };
+        return mergeMCPConfigLayer(defaults, saved);
     } catch {
         // File doesn't exist or invalid JSON — use defaults
         return defaults;
@@ -96,6 +152,52 @@ export function readMCPConfig(configPath) {
     return { config: loadMCPConfig(configPath), problem: null };
 }
 
+/**
+ * Resolve per-account MCP config overrides for `--account <ownId>`:
+ * 1. `baseConfig.accounts?.[accountId]` inside the main `mcp-config.json`
+ * 2. `<accountDir>/mcp-config.json` (when `explicitConfigPath` is not set and the file exists)
+ *
+ * If `<accountDir>/mcp-config.json` exists but is unreadable or invalid JSON, returns `problem`
+ * so `mcp start` refuses rather than falling back to defaults.
+ *
+ * @param {object} baseConfig - Config returned by `readMCPConfig`
+ * @param {{ accountId?: string|null, accountDir?: string|null, explicitConfigPath?: string|null }} [opts]
+ * @returns {{ config: object, problem: string|null }}
+ */
+export function resolveAccountMCPConfig(baseConfig, { accountId, accountDir, explicitConfigPath } = {}) {
+    let merged = baseConfig || getDefaultConfig();
+    const id = accountId !== undefined && accountId !== null ? String(accountId).trim() : "";
+    if (id && merged.accounts && typeof merged.accounts === "object" && merged.accounts[id]) {
+        merged = mergeMCPConfigLayer(merged, merged.accounts[id]);
+    }
+    if (!explicitConfigPath && accountDir) {
+        const perAccountFile = join(accountDir, "mcp-config.json");
+        let raw = null;
+        try {
+            raw = readFileSync(perAccountFile, "utf-8");
+        } catch (e) {
+            if (e.code !== "ENOENT") {
+                return {
+                    config: merged,
+                    problem: `cannot read the per-account config file ${perAccountFile} (${e.code || e.message})`,
+                };
+            }
+        }
+        if (raw !== null) {
+            try {
+                const parsed = JSON.parse(raw);
+                merged = mergeMCPConfigLayer(merged, parsed);
+            } catch (e) {
+                return {
+                    config: merged,
+                    problem: `the per-account config file ${perAccountFile} is not valid JSON (${e.message})`,
+                };
+            }
+        }
+    }
+    return { config: merged, problem: null };
+}
+
 /**
  * Save MCP config to disk.
  * @param {object} config