@ardennguyen/zalo-agent-cli 2.5.5 → 2.5.6

package/src/core/accounts.js

@@ -1,12 +1,24 @@
 /**
  * Multi-account registry at ~/.zalo-agent-cli/accounts.json
  * Maps each account to its own proxy (1:1) and tracks active account.
+ *
+ * A fleet of daemons and the `account` / `login` commands share this one file, so it is written the
+ * way a shared file must be (src/utils/atomic-file.js):
+ *  - every change is read-modify-write under a lock file (`accounts.json.lock`), so two writers no
+ *    longer lose each other's change;
+ *  - every write is a temp file renamed over the target, so a reader never sees a half-written
+ *    registry and a crash leaves the previous one;
+ *  - the previous good registry is kept as `accounts.json.bak`;
+ *  - a file that exists but cannot be read is an ERROR, never "no accounts": the next `login` used
+ *    to replace it with a registry of one. Reads fall back to the `.bak`; with none, nothing is
+ *    touched and the message says what to do.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, rmSync } from "fs";
+import { readFileSync, existsSync, mkdirSync, rmSync, renameSync } from "fs";
 import { join } from "path";
 import { CONFIG_DIR, getAccountDir, deleteCredentials } from "./credentials.js";
 import { checkLock } from "./lock.js";
+import { sleepSync, sweepStaleTemps, withFileLock, writeFileAtomic } from "../utils/atomic-file.js";
 
 function accountsFile() {
     return join(CONFIG_DIR, "accounts.json");
@@ -16,21 +28,130 @@ function ensureDir() {
     mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
-function load() {
+/** The registry exists but cannot be used as the account list. Nothing has been changed. */
+export class RegistryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RegistryError";
+    }
+}
+
+/** Errors a read can raise on Windows for the instant a writer's rename replaces the file. */
+const TRANSIENT_READ = new Set(["EPERM", "EBUSY", "EACCES", "ENOENT"]);
+
+/** @param {string} text @returns {object[]} */
+function parseRegistry(text) {
+    const data = JSON.parse(text);
+    if (!Array.isArray(data)) throw new Error("it is not a JSON array of accounts");
+    return data;
+}
+
+/** @param {string} file */
+function readFileRetrying(file) {
+    for (let attempt = 0; ; attempt++) {
+        try {
+            return readFileSync(file, "utf-8");
+        } catch (e) {
+            if (!TRANSIENT_READ.has(e.code) || attempt >= 5) throw e;
+            sleepSync(10);
+        }
+    }
+}
+
+let _warnedBackup = false;
+
+/**
+ * Read the registry.
+ *
+ * @returns {{ accounts: object[], source: "missing"|"file"|"backup" }}
+ * @throws {RegistryError} when the file exists but is not a usable account list and there is no good backup
+ */
+function readRegistry() {
     const file = accountsFile();
-    if (!existsSync(file)) return [];
+    if (!existsSync(file)) return { accounts: [], source: "missing" };
+
+    let problem;
+    // A writer from before atomic writes can leave a half-written file for an instant: look again.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            return { accounts: parseRegistry(readFileRetrying(file)), source: "file" };
+        } catch (e) {
+            problem = e;
+            if (attempt < 2) sleepSync(20);
+        }
+    }
+
+    const backup = `${file}.bak`;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        const accounts = parseRegistry(readFileSync(backup, "utf-8"));
+        if (!_warnedBackup) {
+            _warnedBackup = true;
+            console.error(
+                `[accounts] ${file} is unreadable (${problem.message}); using its last good copy, ${backup}. ` +
+                    "The next change to the registry replaces the damaged file and keeps it as accounts.json.corrupt-*.",
+            );
+        }
+        return { accounts, source: "backup" };
     } catch {
-        return [];
+        throw new RegistryError(
+            `${file} exists but cannot be read as the account list (${problem.message}). It was left untouched. ` +
+                "Fix it, or move it aside to start with no accounts.",
+        );
     }
 }
 
+function load() {
+    return readRegistry().accounts;
+}
+
+/** Write the registry atomically, keeping the previous good one as accounts.json.bak. */
 function save(accounts) {
     ensureDir();
     const file = accountsFile();
-    writeFileSync(file, JSON.stringify(accounts, null, 2), "utf-8");
-    chmodSync(file, 0o600);
+    try {
+        const current = readFileSync(file, "utf-8");
+        parseRegistry(current);
+        writeFileAtomic(`${file}.bak`, current, { durable: false });
+    } catch {
+        /* no current registry worth keeping */
+    }
+    writeFileAtomic(file, JSON.stringify(accounts, null, 2));
+}
+
+/**
+ * Change the registry: lock, read the CURRENT contents, apply `fn`, write if it says it changed
+ * something. `fn` gets the account array and returns `{ changed, value }`.
+ *
+ * @template T
+ * @param {(accounts: object[]) => { changed: boolean, value: T }} fn
+ * @param {{ timeoutMs?: number }} [lockOptions]
+ * @returns {T}
+ */
+function mutate(fn, lockOptions) {
+    ensureDir();
+    return withFileLock(
+        `${accountsFile()}.lock`,
+        () => {
+            const { accounts, source } = readRegistry();
+            const result = fn(accounts);
+            if (result.changed) {
+                if (source === "backup") {
+                    // Keep the damaged file for whoever wants to know what happened to it.
+                    try {
+                        renameSync(accountsFile(), `${accountsFile()}.corrupt-${Date.now()}`);
+                    } catch {
+                        /* it is replaced either way */
+                    }
+                }
+                save(accounts);
+                // A writer killed between creating its temp file and renaming it leaves that file behind.
+                sweepStaleTemps(accountsFile());
+                sweepStaleTemps(`${accountsFile()}.bak`);
+            }
+            return result.value;
+        },
+        lockOptions,
+    );
 }
 
 let _pinnedAccountId = null;
@@ -68,18 +189,18 @@ export function getActive() {
 
 /** 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;
+    return mutate((accounts) => {
+        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;
+        return { changed: found, value: found };
+    });
 }
 
 /**
@@ -98,16 +219,17 @@ export function setActive(ownId) {
  * in line with it.)
  */
 export function addAccount(ownId, name = "", proxy = null) {
-    const accounts = load();
-    const existing = accounts.find((a) => a.ownId === ownId);
-    for (const a of accounts) a.active = a.ownId === ownId;
-    if (existing) {
-        existing.name = name || existing.name || "";
-        existing.proxy = proxy;
-    } else {
-        accounts.push({ ownId, name, proxy, active: true });
-    }
-    save(accounts);
+    mutate((accounts) => {
+        const existing = accounts.find((a) => a.ownId === ownId);
+        for (const a of accounts) a.active = a.ownId === ownId;
+        if (existing) {
+            existing.name = name || existing.name || "";
+            existing.proxy = proxy;
+        } else {
+            accounts.push({ ownId, name, proxy, active: true });
+        }
+        return { changed: true, value: undefined };
+    });
 }
 
 /**
@@ -161,12 +283,16 @@ export function removeAccount(ownId) {
         return { removed: false, skippedLocked };
     }
 
-    const filtered = accounts.filter((a) => a.ownId !== ownId);
-    // If removed was active, activate first remaining
-    if (filtered.length && !filtered.some((a) => a.active)) {
-        filtered[0].active = true;
-    }
-    save(filtered);
+    mutate((current) => {
+        const filtered = current.filter((a) => a.ownId !== ownId);
+        // If removed was active, activate first remaining
+        if (filtered.length && !filtered.some((a) => a.active)) {
+            filtered[0].active = true;
+        }
+        // The array is edited in place: `mutate` writes the one it handed us.
+        current.splice(0, current.length, ...filtered);
+        return { changed: true, value: undefined };
+    });
     deleteCredentials(ownId);
     return { removed: true, wiped };
 }
@@ -183,12 +309,28 @@ export function updateAccountName(ownId, name) {
     const id = ownId ? String(ownId).trim() : "";
     const trimmed = typeof name === "string" ? name.trim() : "";
     if (!id || !trimmed) return false;
-    const accounts = load();
-    const existing = accounts.find((a) => a.ownId === id);
-    if (!existing || existing.name === trimmed) return false;
-    existing.name = trimmed;
-    save(accounts);
-    return true;
+    // The common case, a daemon re-reading a name it already has, takes no lock and writes nothing.
+    const unchanged = (accounts) => {
+        const existing = accounts.find((a) => a.ownId === id);
+        return !existing || existing.name === trimmed;
+    };
+    try {
+        if (unchanged(load())) return false;
+        return mutate(
+            (accounts) => {
+                if (unchanged(accounts)) return { changed: false, value: false };
+                accounts.find((a) => a.ownId === id).name = trimmed;
+                return { changed: true, value: true };
+            },
+            // Daemons call this from event handlers: a busy registry costs a missed cosmetic refresh,
+            // not seconds of a blocked event loop.
+            { timeoutMs: 3000 },
+        );
+    } catch (e) {
+        // A cached display name is not worth a daemon: say so and carry on.
+        console.error(`[accounts] could not update the cached name of ${id}: ${e.message}`);
+        return false;
+    }
 }
 
 /** Get account by ownId. */

package/src/core/credentials.js

@@ -10,10 +10,11 @@
  * All credential files use 0600 permissions (owner read/write only).
  */
 
-import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { readFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
 import { homedir } from "os";
 import { parseEnv } from "node:util";
+import { writeFileAtomic } from "../utils/atomic-file.js";
 
 const defaultConfigDir = join(homedir(), ".zalo-agent-cli");
 
@@ -176,8 +177,9 @@ function credPath(ownId) {
 export function saveCredentials(ownId, creds) {
     ensureDirs();
     const target = credPath(ownId);
-    writeFileSync(target, JSON.stringify(creds, null, 2), "utf-8");
-    chmodSync(target, 0o600);
+    // Atomic and created at 0600: a login is never left half written, and the file is never readable
+    // by others, even for the moment between a write and a chmod.
+    writeFileAtomic(target, JSON.stringify(creds, null, 2));
     return target;
 }
 

package/src/core/daemon-channel.js

@@ -80,6 +80,7 @@ import http from "node:http";
 import fs from "node:fs";
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
+import { createLogSink, createRotatingFile, resolveLogSettings } from "./log-sink.js";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { maskSecretArgs } from "../utils/secrets.js";
 
@@ -296,6 +297,8 @@ function readJsonBody(req, reply) {
  *   long-poll callback invoked by `POST /wait` (`zalo-agent mcp wait`).
  * @param {(params: object) => Promise<object>} [args.onMarkRead] -
  *   read-cursor callback invoked by `POST /mark-read` (`zalo-agent mcp mark-read`).
+ * @param {() => object} [args.onStatus] - health snapshot returned by `POST /status`
+ *   (`listen --status`, `mcp start --status`; see ./daemon-health.js).
  * @returns {Promise<{port: number, stop: () => void}>}
  */
 export function startDaemonChannel({
@@ -307,6 +310,7 @@ export function startDaemonChannel({
     onStop = null,
     onWait = null,
     onMarkRead = null,
+    onStatus = null,
 }) {
     const token = randomBytes(24).toString("hex");
 
@@ -457,6 +461,17 @@ export function startDaemonChannel({
         }
     };
 
+    /** The daemon's health snapshot (`listen --status`, `mcp start --status`). */
+    const serveStatus = (body, reply) => {
+        if (!tokenMatches(body.token, token)) return reply(403, { error: "bad token" });
+        if (typeof onStatus !== "function") return reply(503, { error: "this daemon does not report health" });
+        try {
+            reply(200, { ok: true, health: onStatus() });
+        } catch (e) {
+            reply(200, { ok: false, error: e?.message || String(e) });
+        }
+    };
+
     const server = http.createServer(async (req, res) => {
         const reply = (code, body) => {
             res.writeHead(code, { "content-type": "application/json" });
@@ -470,6 +485,7 @@ export function startDaemonChannel({
             req.url !== "/stop" &&
             req.url !== "/wait" &&
             req.url !== "/mark-read" &&
+            req.url !== "/status" &&
             !stage
         ) {
             return reply(404, { error: "not found" });
@@ -480,6 +496,7 @@ export function startDaemonChannel({
         if (req.url === "/stop") return serveStop(body, reply);
         if (req.url === "/wait") return serveWait(body, res, reply);
         if (req.url === "/mark-read") return serveMarkRead(body, reply);
+        if (req.url === "/status") return serveStatus(body, reply);
         return stage ? serveStage(stage, body, res, reply) : serveAttachments(body, reply);
     });
 
@@ -841,7 +858,10 @@ export function stopViaDaemon(accountDir, { timeoutMs = 3000 } = {}) {
  * @returns {Promise<{ok: boolean, status?: "message"|"timeout"|number, message?: object|null, cursor?: number, error?: string}|null>}
  *   null when no daemon channel is published
  */
-export function waitViaDaemon(accountDir, { threadId = null, since = undefined, timeoutSec = 55, consumer } = {}) {
+export function waitViaDaemon(
+    accountDir,
+    { threadId = null, since = undefined, timeoutSec = 55, consumer, limit = 1, settleMs = 0 } = {},
+) {
     const chan = getDaemonChannel(accountDir);
     if (!chan) return Promise.resolve(null);
 
@@ -851,6 +871,8 @@ export function waitViaDaemon(accountDir, { threadId = null, since = undefined,
         ...(threadId ? { threadId: String(threadId) } : {}),
         ...(typeof since === "number" && Number.isFinite(since) ? { since } : {}),
         timeoutSec: clampedSec,
+        ...(limit > 1 ? { limit } : {}),
+        ...(settleMs > 0 ? { settleMs } : {}),
         ...(consumer ? { consumer: String(consumer) } : {}),
     });
 
@@ -881,6 +903,9 @@ export function waitViaDaemon(accountDir, { threadId = null, since = undefined,
                             ok: true,
                             status: body.status,
                             message: body.message ?? null,
+                            messages: Array.isArray(body.messages) ? body.messages : body.message ? [body.message] : [],
+                            count: body.count ?? (body.message ? 1 : 0),
+                            hasMore: Boolean(body.hasMore),
                             cursor: body.cursor,
                         });
                     } else {
@@ -1065,33 +1090,82 @@ function quoteWinArg(arg) {
  */
 export function attachDaemonLogIfChild() {
     if (process.env.ZALO_DAEMON_CHILD !== "1" || !process.env.ZALO_DAEMON_LOG) return;
-    let logFd;
+    const logPath = process.env.ZALO_DAEMON_LOG;
+    // The account is the name of the directory the log lives in (<data dir>/<ownId>/daemon.log).
+    const ownId = path.basename(path.dirname(logPath));
+    const settings = resolveLogSettings({ env: process.env, ownId });
+
+    let file;
     try {
-        logFd = fs.openSync(process.env.ZALO_DAEMON_LOG, "a", 0o600);
+        file = createRotatingFile({ file: logPath, maxBytes: settings.maxBytes, keep: settings.keep });
+        file.write(""); // fail now, here, if the log cannot be opened
     } catch {
         return;
     }
-    const writeToLog = (chunk, encoding, cb) => {
-        try {
-            const buf = Buffer.isBuffer(chunk)
-                ? chunk
-                : Buffer.from(String(chunk), typeof encoding === "string" ? encoding : "utf8");
-            fs.writeSync(logFd, buf);
-        } catch {
-            /* ignore logging errors */
-        }
+    // Levels, timestamps (or JSON) and rotation in front of the file; see ./log-sink.js.
+    const sink = createLogSink({ write: file.write, level: settings.level, format: settings.format, accountId: ownId });
+    daemonSink = sink;
+    const done = (encoding, cb) => {
         if (typeof encoding === "function") encoding();
         else if (typeof cb === "function") cb();
         return true;
     };
-    process.stdout.write = writeToLog;
-    process.stderr.write = writeToLog;
+    process.stdout.write = (chunk, encoding, cb) => {
+        sink.write(chunk);
+        return done(encoding, cb);
+    };
+    process.stderr.write = (chunk, encoding, cb) => {
+        sink.write(chunk);
+        return done(encoding, cb);
+    };
+    for (const w of settings.warnings) sink.write(`[logging] ${w}\n`);
     process.on("uncaughtException", (err) => {
-        writeToLog(`${err?.stack || err}\n`);
+        sink.write(`${err?.stack || err}\n`);
+        sink.flush();
         process.exit(1);
     });
+    process.on("exit", () => sink.flush());
+}
+
+/** The daemon child's log sink, once attachDaemonLogIfChild has built it. */
+let daemonSink = null;
+
+/**
+ * Apply `--log-level` and the per-account settings once the account is known, and, for a run that is not a
+ * background daemon, filter stderr when a level or format was asked for.
+ *
+ * @param {object} args
+ * @param {string} args.ownId
+ * @param {string|null} [args.levelFlag] - Already validated
+ * @param {boolean} [args.filterStderr=true] - Filter stderr of a foreground run; false for the process that only launches a daemon
+ * @returns {{ level: string, format: string, warnings: string[] }}
+ */
+export function configureLogging({ ownId, levelFlag = null, filterStderr = true }) {
+    const settings = resolveLogSettings({ env: process.env, ownId, levelFlag });
+    if (daemonSink) {
+        daemonSink.setLevel(settings.level);
+        daemonSink.setFormat(settings.format);
+    } else if (filterStderr && settings.explicit && !foregroundFilter) {
+        // A foreground run writes to the terminal: filter stderr in place, keep stdout (the output) alone.
+        const original = process.stderr.write.bind(process.stderr);
+        foregroundFilter = createLogSink({
+            write: (text) => original(text),
+            level: settings.level,
+            format: settings.format,
+            accountId: ownId,
+        });
+        process.stderr.write = (chunk, encoding, cb) => {
+            foregroundFilter.write(chunk);
+            if (typeof encoding === "function") encoding();
+            else if (typeof cb === "function") cb();
+            return true;
+        };
+    }
+    return { level: settings.level, format: settings.format, warnings: settings.warnings };
 }
 
+let foregroundFilter = null;
+
 /**
  * On Windows, spawn via `Win32_Process.Create` (WMI) so the background daemon
  * is parented to `WmiPrvSE.exe` outside any terminal or agent Job Object
@@ -1104,7 +1178,7 @@ export function attachDaemonLogIfChild() {
  * @param {string} logPath
  * @returns {number|null}
  */
-function trySpawnWin32JobBreakaway(execPath, args, logPath) {
+function trySpawnWin32JobBreakaway(execPath, args, logPath, extraEnv = {}) {
     if (process.platform !== "win32") return null;
     try {
         const cmdLine = [quoteWinArg(execPath), ...args.map(quoteWinArg)].join(" ");
@@ -1123,6 +1197,7 @@ function trySpawnWin32JobBreakaway(execPath, args, logPath) {
             timeout: 8000,
             env: {
                 ...process.env,
+                ...extraEnv,
                 ZALO_DAEMON_CHILD: "1",
                 ZALO_DAEMON_LOG: logPath,
                 ZALO_DAEMON_CMD: cmdLine,
@@ -1147,6 +1222,7 @@ function trySpawnWin32JobBreakaway(execPath, args, logPath) {
  * @param {string} opts.accountDir
  * @param {string[]} [opts.args] - CLI arguments (defaults to `process.argv.slice(1)`)
  * @param {number} [opts.timeoutMs=15000] - how long to wait for the channel to come up
+ * @param {Record<string, string>} [opts.env] - extra environment for this daemon only (a fleet gives each account its own token)
  * @returns {Promise<{
  *   ok: boolean,
  *   alreadyRunning?: boolean,
@@ -1156,7 +1232,7 @@ function trySpawnWin32JobBreakaway(execPath, args, logPath) {
  *   error?: string,
  * }>}
  */
-export async function spawnDaemonProcess({ accountDir, args = process.argv.slice(1), timeoutMs = 15_000 }) {
+export async function spawnDaemonProcess({ accountDir, args = process.argv.slice(1), timeoutMs = 15_000, env = {} }) {
     const status = getDaemonStatus(accountDir);
     if (status.running) {
         return {
@@ -1183,7 +1259,7 @@ export async function spawnDaemonProcess({ accountDir, args = process.argv.slice
         /* ignore */
     }
 
-    let pid = trySpawnWin32JobBreakaway(process.execPath, filteredArgs, logPath);
+    let pid = trySpawnWin32JobBreakaway(process.execPath, filteredArgs, logPath, env);
     if (pid !== null) {
         try {
             fs.closeSync(logFd);
@@ -1195,7 +1271,7 @@ export async function spawnDaemonProcess({ accountDir, args = process.argv.slice
             detached: true,
             windowsHide: true,
             stdio: ["ignore", logFd, logFd],
-            env: { ...process.env, ZALO_DAEMON_CHILD: "1" },
+            env: { ...process.env, ...env, ZALO_DAEMON_CHILD: "1", ZALO_DAEMON_LOG: logPath },
         });
         try {
             fs.closeSync(logFd);
@@ -1242,3 +1318,53 @@ export async function spawnDaemonProcess({ accountDir, args = process.argv.slice
         error: "Timed out waiting for background daemon to finish starting.",
     };
 }
+
+/**
+ * Ask the running daemon for its health snapshot (`listen --status`, `mcp start --status`).
+ *
+ * @param {string} accountDir
+ * @returns {Promise<{ok: boolean, health?: object, error?: string}|null>} null when no daemon channel is published;
+ *   `ok: false` for a daemon too old to answer (it has the channel but not the route)
+ */
+export function statusViaDaemon(accountDir) {
+    const chan = getDaemonChannel(accountDir);
+    if (!chan) return Promise.resolve(null);
+    const payload = JSON.stringify({ token: chan.token });
+    return new Promise((resolve) => {
+        const r = http.request(
+            {
+                host: "127.0.0.1",
+                port: chan.port,
+                path: "/status",
+                method: "POST",
+                headers: { "content-type": "application/json", "content-length": Buffer.byteLength(payload) },
+                timeout: 5000,
+                agent: false,
+            },
+            (res) => {
+                let raw = "";
+                res.setEncoding("utf8");
+                res.on("data", (c) => (raw += c));
+                res.on("end", () => {
+                    let body = {};
+                    try {
+                        body = JSON.parse(raw);
+                    } catch {
+                        /* non-JSON response */
+                    }
+                    resolve(
+                        res.statusCode === 200 && body.ok
+                            ? { ok: true, health: body.health }
+                            : { ok: false, error: body.error || `HTTP ${res.statusCode}` },
+                    );
+                });
+            },
+        );
+        r.on("timeout", () => {
+            r.destroy();
+            resolve({ ok: false, error: "timeout waiting for the daemon" });
+        });
+        r.on("error", (e) => resolve({ ok: false, error: e?.message || String(e) }));
+        r.end(payload);
+    });
+}