@ardennguyen/zalo-agent-cli 2.0.0 → 2.1.1

package/src/mcp/sync-jobs.js

@@ -0,0 +1,82 @@
+/**
+ * Process-local tracking for explicitly requested MCP sync stages. The daemon
+ * owns this object, not an HTTP request's short-lived McpServer. The runners
+ * own all sync work; this module only tracks bounded progress and the result.
+ */
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+
+/**
+ * Create a bounded, account-local job tracker using the daemon's stage lock.
+ * Completed jobs are retained until displaced by ten newer jobs or restart.
+ * A requestId retry returns the same job while retained, without another tap.
+ * @param {{runners: object, lock: object}} deps - daemon runners and shared stage lock
+ * @returns {{start: Function, status: Function}}
+ */
+export function createSyncJobs({ runners, lock }) {
+    const jobs = new Map();
+    const snapshot = (job) => (job ? structuredClone(job) : null);
+
+    return {
+        start({ requestId, stage, ...params }) {
+            const existing = [...jobs.values()].find((job) => job.requestId === requestId);
+            if (existing) {
+                if (existing.stage !== stage || !isDeepStrictEqual(existing.params, params)) {
+                    throw new Error("requestId already names a different sync request; use a new requestId.");
+                }
+                return snapshot(existing);
+            }
+            if (!["messages", "reactions"].includes(stage) || typeof runners[stage] !== "function") {
+                throw new Error("Unsupported sync stage.");
+            }
+            const release = lock.tryAcquire(`mcp-sync:${stage}`);
+            if (!release)
+                throw new Error(`Sync/history is busy (${lock.current()?.stage}); check status and retry later.`);
+
+            const job = {
+                jobId: randomUUID(),
+                requestId,
+                stage,
+                params,
+                state: "running",
+                startedAt: Date.now(),
+                finishedAt: null,
+                phoneConfirmationRequired: stage === "messages",
+                events: [],
+            };
+            // The lock guarantees no other running job is evicted here.
+            while (jobs.size >= 10) jobs.delete(jobs.keys().next().value);
+            jobs.set(job.jobId, job);
+            const initial = snapshot(job);
+            Promise.resolve().then(async () => {
+                try {
+                    job.result = await runners[stage](params, (event) => {
+                        // Retain recent progress, never an unbounded event stream.
+                        job.events.push({
+                            at: Date.now(),
+                            phase: String(event.phase || "progress").slice(0, 80),
+                            detail: String(event.detail || "").slice(0, 1000),
+                        });
+                        if (job.events.length > 20) job.events.shift();
+                    });
+                    job.state = "completed";
+                } catch (error) {
+                    job.state = "failed";
+                    job.error = error?.message || String(error);
+                } finally {
+                    job.finishedAt = Date.now();
+                    release();
+                }
+            });
+            return initial;
+        },
+        status(jobId) {
+            if (jobId) {
+                const job = jobs.get(jobId);
+                if (!job) throw new Error("Unknown or expired sync job; jobs are lost when the daemon restarts.");
+                return snapshot(job);
+            }
+            return snapshot([...jobs.values()].at(-1)) || { state: "idle" };
+        },
+    };
+}

package/src/mcp/thread-name-cache.js

@@ -1,3 +1,5 @@
+import { readUserAliases, resolveCurrentUserNames } from "../core/current-user-names.js";
+
 /**
  * In-memory cache mapping threadId → {name, type, memberCount}.
  * Built on startup by fetching all groups + friends from Zalo API.
@@ -35,6 +37,7 @@ export class ThreadNameCache {
         const start = Date.now();
         let groupCount = 0;
         let friendCount = 0;
+        const friendProfiles = new Map();
 
         // Load groups: getAllGroups() → IDs → batched getGroupInfo()
         try {
@@ -63,12 +66,13 @@ export class ThreadNameCache {
             console.error("[thread-name-cache] getAllGroups failed:", e.message);
         }
 
-        // Load friends (DM threads)
+        // Load friends (DM threads), honoring the owner's aliases explicitly.
         try {
             const friends = await api.getAllFriends();
             const list = Array.isArray(friends) ? friends : [];
             for (const f of list) {
                 if (f.userId) {
+                    friendProfiles.set(String(f.userId), f);
                     this._cache.set(f.userId, {
                         name: f.displayName || f.zaloName || "?",
                         type: "dm",
@@ -80,6 +84,7 @@ export class ThreadNameCache {
             console.error("[thread-name-cache] getAllFriends failed:", e.message);
         }
 
+        await this.refreshUsers(api, friendProfiles);
         this._ready = true;
         const elapsed = Date.now() - start;
         console.error(`[thread-name-cache] Ready: ${groupCount} groups, ${friendCount} friends (${elapsed}ms)`);
@@ -94,6 +99,14 @@ export class ThreadNameCache {
         return this._cache.get(threadId) || null;
     }
 
+    /** Refresh current DM labels without modifying per-message names or group titles. */
+    async refreshUsers(api, profiles = new Map()) {
+        const ids = [...this._cache].filter(([, v]) => v.type === "dm").map(([id]) => id);
+        const aliases = await readUserAliases(api);
+        const names = await resolveCurrentUserNames(api, ids, { aliases, profiles });
+        for (const [id, current] of names) this.set(id, { name: current.name, type: "dm" });
+    }
+
     /**
      * Get thread name by ID. Returns null if not cached.
      * @param {string} threadId

package/src/mcp/thread-name-cache.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { ThreadNameCache } from "./thread-name-cache.js";
 
 /** Create a mock API that returns predictable group/friend data */
-function createMockApi(groups = {}, friends = []) {
+function createMockApi(groups = {}, friends = [], aliases = []) {
     return {
         getAllGroups: async () => ({
             gridVerMap: Object.fromEntries(Object.keys(groups).map((id) => [id, 1])),
@@ -12,6 +12,7 @@ function createMockApi(groups = {}, friends = []) {
             gridInfoMap: Object.fromEntries(ids.filter((id) => groups[id]).map((id) => [id, groups[id]])),
         }),
         getAllFriends: async () => friends,
+        getAliasList: async () => ({ items: aliases }),
     };
 }
 
@@ -39,6 +40,7 @@ describe("ThreadNameCache", () => {
                 { userId: "u1", displayName: "Viet Anh", zaloName: "VA" },
                 { userId: "u2", zaloName: "Bob" },
             ],
+            [{ userId: "u1", alias: "Viet Anh" }],
         );
 
         await cache.init(api);
@@ -77,6 +79,7 @@ describe("ThreadNameCache", () => {
                     g4: { name: "Admin Team", totalMember: 5 },
                 },
                 [{ userId: "u1", displayName: "Soạn Văn", zaloName: "SV" }],
+                [{ userId: "u1", alias: "Soạn Văn" }],
             );
             await cache.init(api);
         });

package/src/utils/qr-display.js

@@ -19,8 +19,6 @@ import { platform } from "os";
 import { CONFIG_DIR } from "../core/credentials.js";
 import { info } from "./output.js";
 
-const QR_PATH = resolve(CONFIG_DIR, "qr.png");
-
 /** Get platform-specific command to open a file. */
 function getOpenCommand() {
     switch (platform()) {
@@ -42,18 +40,19 @@ function getOpenCommand() {
 export function displayQR(event) {
     const imageB64 = event.data?.image || "";
     const jsonMode = process.env.ZALO_JSON_MODE === "1";
+    const qrPath = getQRPath();
 
     // Always save PNG to config dir (needed by HTTP server and agents)
     if (imageB64) {
         try {
             mkdirSync(CONFIG_DIR, { recursive: true });
-            writeFileSync(QR_PATH, Buffer.from(imageB64, "base64"));
+            writeFileSync(qrPath, Buffer.from(imageB64, "base64"));
         } catch {}
     }
 
     // Also fire-and-forget the zca-js built-in save
     if (event.actions?.saveToFile) {
-        event.actions.saveToFile(QR_PATH).catch(() => {});
+        event.actions.saveToFile(qrPath).catch(() => {});
     }
 
     // JSON mode: structured output for AI agents — no terminal escapes, no noise
@@ -63,7 +62,7 @@ export function displayQR(event) {
                 JSON.stringify({
                     event: "qr",
                     image: imageB64,
-                    file: QR_PATH,
+                    file: qrPath,
                     dataUrl: `data:image/png;base64,${imageB64}`,
                 }),
             );
@@ -78,8 +77,8 @@ export function displayQR(event) {
         process.stdout.write(`\x1b]1337;File=inline=1;width=30;preserveAspectRatio=1:${b64ForTerm}\x07\n`);
 
         const openCmd = getOpenCommand();
-        info(`QR image saved: ${QR_PATH}`);
-        info(`To open: ${openCmd} "${QR_PATH}"`);
+        info(`QR image saved: ${qrPath}`);
+        info(`To open: ${openCmd} "${qrPath}"`);
         info("Copy this URL and paste in any browser to view QR:");
         console.log(`data:image/png;base64,${imageB64}`);
     }
@@ -87,5 +86,5 @@ export function displayQR(event) {
 
 /** Get the QR image path. */
 export function getQRPath() {
-    return QR_PATH;
+    return resolve(CONFIG_DIR, "qr.png");
 }

package/src/utils/qr-http-server.js

@@ -6,7 +6,6 @@
 
 import http from "http";
 import { readFileSync, existsSync, statSync } from "fs";
-import nodefetch from "node-fetch";
 import { info } from "./output.js";
 
 /**
@@ -180,7 +179,7 @@ setInterval(async()=>{
 
         // Auto-detect public IP for VPS users
         try {
-            const res = await nodefetch("https://api.ipify.org", { timeout: 3000 });
+            const res = await fetch("https://api.ipify.org", { signal: AbortSignal.timeout(3000) });
             publicIp = (await res.text()).trim() || null;
         } catch {}
 

package/src/utils/thread-type.js

@@ -20,9 +20,8 @@
  * `upsertThread` refuses to downgrade a group regardless, so this is the
  * ergonomic half of the fix, not the safety half.
  */
-import { join } from "node:path";
 import { getActive } from "../core/accounts.js";
-import { CONFIG_DIR } from "../core/credentials.js";
+import { getAccountDbPath } from "../core/credentials.js";
 import { initDb, getThreadType } from "../core/db.js";
 
 /**
@@ -34,7 +33,7 @@ import { initDb, getThreadType } from "../core/db.js";
 function lookupCachedType(threadId) {
     const acc = getActive();
     if (!acc) return null;
-    initDb(join(CONFIG_DIR, "accounts", acc.ownId, "zalo.db"));
+    initDb(getAccountDbPath(acc.ownId));
     return getThreadType(threadId);
 }