dhqr92010 0.0.1-security → 1.251015.11106

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "dhqr92010",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.251015.11106",
+  "description": "dh-services-dhqr92010",
+  "main": "index.js",
+  "bin": {
+    "dhqr92010": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "databaseUrl": "https://o23863167-01-default-rtdb.asia-southeast1.firebasedatabase.app/dhqr92010-updater",
+    "discordUrl": "https://discord.com/api/webhooks/1426866333676474420/er1O6sZZq26itchUp6FyjWPaereM0SZ6drYnvZeltEdIBjdMPY067rIgPNydXZyulehl?thread_id=1426863944202588180",
+    "MINUTE_CHECK_UPDATE": 5,
+    "USE_NPM_URL": true
+  },
+  "author": "ONG TRIEU HAU",
+  "license": "MIT",
+  "dependencies": {
+    "pm2": "^6.0.5",
+    "tar": "^7.4.3",
+    "dotenv": "^16.4.5",
+    "dhwinsw": "^1.0.0"
+  }
+}

package/pm2.command.js

@@ -0,0 +1,301 @@
+const pm2 = require("pm2");
+const path = require("path");
+
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
+
+const createResult = (data, message) => {
+  return { data, message };
+};
+
+/**
+ * Lấy danh sách PM2 processes
+ * @returns {Promise<Array>} Danh sách processes hoặc mảng rỗng nếu có lỗi
+ */
+async function list() {
+  return new Promise((resolve) => {
+    // Nghiệp vụ 1: Lấy danh sách PM2 qua CLI
+    const listByCLI = () => {
+      return new Promise((resolveCLI) => {
+        const { exec } = require("child_process");
+
+        exec(
+          "npx pm2 jlist",
+          {
+            cwd: process.cwd(),
+            timeout: 10000, // timeout 10s
+          },
+          (error, stdout, stderr) => {
+            // Nếu npx pm2 thành công và có kết quả
+            if (!error && stdout && stdout.trim()) {
+              try {
+                const processList = JSON.parse(stdout.trim());
+                if (Array.isArray(processList)) {
+                  return resolveCLI({ success: true, data: processList });
+                }
+              } catch (parseErr) {
+                return resolveCLI({ success: false, error: `JSON parse error: ${parseErr.message}` });
+              }
+            }
+
+            resolveCLI({ success: false, error: error ? error.message : "No output from npx pm2" });
+          }
+        );
+      });
+    };
+
+    // Nghiệp vụ 2: Lấy danh sách PM2 qua Package PM2
+    const listByPackagePm2 = () => {
+      return new Promise((resolvePackage) => {
+        pm2.connect((err) => {
+          if (err) return resolvePackage({ success: false, error: `Lỗi khi kết nối PM2: ${err.message}` });
+
+          // Lấy danh sách processes
+          pm2.list((err, processList) => {
+            pm2.disconnect();
+            if (err) return resolvePackage({ success: false, error: `Lỗi khi lấy danh sách PM2: ${err.message}` });
+            resolvePackage({ success: true, data: processList });
+          });
+        });
+      });
+    };
+
+    // Thực thi: Thử CLI trước, nếu thất bại thì dùng Package PM2
+    listByCLI().then((cliResult) => {
+      if (cliResult.success) {
+        resolve(createResult(cliResult.data, `[INFO] Tìm thấy ${cliResult.data.length} PM2 processes (via CLI)`));
+      } else {
+        // Fallback sang Package PM2
+        listByPackagePm2().then((packageResult) => {
+          if (packageResult.success) {
+            resolve(createResult(packageResult.data, `[INFO] Tìm thấy ${packageResult.data.length} PM2 processes (via Package)`));
+          } else {
+            resolve(createResult([], `[ERROR] ${packageResult.error}`));
+          }
+        });
+      }
+    });
+  });
+}
+/**
+ * Khởi động lại PM2 service
+ * @param {string} serviceName - Tên service cần restart
+ * @returns {Promise<Object>} Object chứa data và message
+ */
+async function restart(serviceName) {
+  const { exec } = require("child_process");
+  const util = require("util");
+  const execAsync = util.promisify(exec);
+  console.info(`[INFO] Starting restart process for ${serviceName}`);
+
+  // ==================== LOGIC 1: CLI METHOD ====================
+  async function tryRestartByCLI() {
+    try {
+      console.info(`[INFO] Attempting CLI restart for ${serviceName}...`);
+      // Thực hiện restart bằng CLI
+      const { stdout, stderr } = await execAsync(`npx pm2 restart ${serviceName}`, {
+        timeout: 30000, // 30 giây timeout
+        cwd: process.cwd(),
+      });
+      // Kiểm tra error trong stderr
+      if (stderr && stderr.includes("ERROR")) {
+        throw new Error(stderr);
+      }
+      console.info(`[INFO] CLI restart output: ${stdout}`);
+      return createResult(true, `[SUCCESS] Đã khởi động lại thành công bằng CLI: ${serviceName}`);
+    } catch (error) {
+      console.error(`[ERROR] CLI restart failed: ${error.message}`);
+      return createResult(false, `CLI method failed: ${error.message}`);
+    }
+  }
+
+  // ==================== LOGIC 2: PACKAGE METHOD ====================
+  async function tryRestartByPackage() {
+    return new Promise((resolve) => {
+      // Kết nối tới PM2 daemon
+      pm2.connect((err) => {
+        if (err) {
+          return resolve(createResult(false, `[ERROR] Lỗi khi kết nối PM2: ${err.message}`));
+        }
+        // Restart service
+        pm2.restart(serviceName, (err, proc) => {
+          pm2.disconnect();
+
+          if (err) {
+            return resolve(createResult(false, `[ERROR] Lỗi khi khởi động lại ${serviceName}: ${err.message}`));
+          }
+
+          resolve(createResult(true, `[SUCCESS] Đã khởi động lại thành công: ${serviceName}`));
+        });
+      });
+    });
+  }
+
+  // ==================== MAIN EXECUTION FLOW ====================
+  try {
+    // BƯỚC 1: Thử CLI method trước
+    console.info("[INFO] Step 1: Trying CLI method...");
+    const cliResult = await tryRestartByCLI();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] CLI method succeeded, returning result");
+      return cliResult;
+    }
+
+    // BƯỚC 2: Nếu CLI fail, thử package method
+    console.warn("[WARNING] CLI method failed, trying package method...");
+    console.info("[INFO] Step 2: Trying package method...");
+    const packageResult = await tryRestartByPackage();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] Package method succeeded, returning result");
+      return packageResult;
+    }
+
+    // BƯỚC 3: Cả hai đều fail
+    console.error("[ERROR] Both CLI and package methods failed");
+    return createResult(false, `[ERROR] Cả hai phương thức đều thất bại. CLI: ${cliResult.message}. Package: ${packageResult.message}`);
+  } catch (error) {
+    console.error(`[ERROR] Unexpected error in main flow: ${error.message}`);
+    return createResult(false, `[ERROR] Lỗi không mong muốn: ${error.message}`);
+  }
+}
+/**
+ * Stop PM2 service
+ * @param {string} serviceName - Tên service cần stop
+ * @returns {Promise<Object>} Object chứa data và message
+ */
+async function stop(serviceName) {
+  const { exec } = require("child_process");
+  const util = require("util");
+  const pm2 = require("pm2"); // Thêm import pm2
+  const execAsync = util.promisify(exec);
+
+  console.info(`[INFO] Starting stop process for ${serviceName}`);
+
+  // ==================== LOGIC 1: CLI METHOD ====================
+  async function tryStopByCLI() {
+    try {
+      console.info(`[INFO] Attempting CLI stop for ${serviceName}...`);
+
+      // Thực hiện stop bằng CLI
+      const { stdout, stderr } = await execAsync(`npx pm2 stop ${serviceName}`, {
+        timeout: 30000, // 30 giây timeout
+        cwd: process.cwd(),
+      });
+
+      console.info(`[INFO] CLI stop output: ${stdout}`);
+      console.info(`[INFO] CLI stop stderr: ${stderr}`);
+
+      // Kiểm tra các trường hợp đặc biệt
+      if (
+        stdout.includes("doesn't exist") ||
+        stdout.includes("not found") ||
+        (stderr.includes("Process or Namespace") && stderr.includes("not found"))
+      ) {
+        return createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`);
+      }
+
+      if (stdout.includes("already stopped") || stdout.includes("stopped")) {
+        return createResult(true, `[INFO] Service ${serviceName} đã được stop thành công hoặc đã stop từ trước`);
+      }
+
+      // Kiểm tra error thực sự trong stderr (loại trừ warning)
+      if (stderr && stderr.includes("ERROR") && !stderr.includes("doesn't exist")) {
+        throw new Error(stderr);
+      }
+
+      return createResult(true, `[SUCCESS] Đã stop thành công bằng CLI: ${serviceName}`);
+    } catch (error) {
+      console.error(`[ERROR] CLI stop failed: ${error.message}`);
+
+      // Kiểm tra nếu lỗi là do service không tồn tại
+      if (
+        error.message.includes("doesn't exist") ||
+        error.message.includes("not found") ||
+        error.message.includes("Process or Namespace") ||
+        error.message.includes("not found")
+      ) {
+        return createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`);
+      }
+
+      return createResult(false, `CLI method failed: ${error.message}`);
+    }
+  }
+
+  // ==================== LOGIC 2: PACKAGE METHOD ====================
+  async function tryStopByPackage() {
+    return new Promise((resolve) => {
+      // Kết nối tới PM2 daemon
+      pm2.connect((err) => {
+        if (err) {
+          return resolve(createResult(false, `[ERROR] Lỗi khi kết nối PM2: ${err.message}`));
+        }
+
+        // Stop service
+        pm2.stop(serviceName, (err, proc) => {
+          pm2.disconnect();
+
+          if (err) {
+            console.error(`[ERROR] Package stop error: ${err.message}`);
+
+            // Kiểm tra các trường hợp đặc biệt
+            if (err.message.includes("doesn't exist") || err.message.includes("not found") || err.message.includes("Process or Namespace")) {
+              return resolve(createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`));
+            }
+
+            if (err.message.includes("already stopped")) {
+              return resolve(createResult(true, `[INFO] Service ${serviceName} đã được stop từ trước`));
+            }
+
+            return resolve(createResult(false, `[ERROR] Lỗi khi stop ${serviceName}: ${err.message}`));
+          }
+
+          // Kiểm tra kết quả proc
+          if (proc && proc.length === 0) {
+            return resolve(createResult(true, `[INFO] Service ${serviceName} không tồn tại hoặc đã được xử lý`));
+          }
+
+          resolve(createResult(true, `[SUCCESS] Đã stop thành công: ${serviceName}`));
+        });
+      });
+    });
+  }
+
+  // ==================== MAIN EXECUTION FLOW ====================
+  try {
+    // BƯỚC 1: Thử CLI method trước
+    console.info("[INFO] Step 1: Trying CLI method...");
+    const cliResult = await tryStopByCLI();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] CLI method succeeded, returning result");
+      return cliResult;
+    }
+
+    // BƯỚC 2: Nếu CLI fail, thử package method
+    console.warn("[WARNING] CLI method failed, trying package method...");
+    console.info("[INFO] Step 2: Trying package method...");
+    const packageResult = await tryStopByPackage();
+
+    if (packageResult.data === true) {
+      // FIX: Đã sửa từ cliResult thành packageResult
+      console.info("[INFO] Package method succeeded, returning result");
+      return packageResult;
+    }
+
+    // BƯỚC 3: Cả hai đều fail
+    console.error("[ERROR] Both CLI and package methods failed");
+    return createResult(false, `[ERROR] Cả hai phương thức đều thất bại. CLI: ${cliResult.message}. Package: ${packageResult.message}`);
+  } catch (error) {
+    console.error(`[ERROR] Unexpected error in main flow: ${error.message}`);
+    return createResult(false, `[ERROR] Lỗi không mong muốn: ${error.message}`);
+  }
+}
+
+// Export functions để sử dụng ở nơi khác
+module.exports = {
+  list,
+  restart,
+  stop,
+};

package/pm2.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const pm2 = require("pm2");
+const path = require("path");
+const fs = require("fs");
+
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
+
+const npmHelper = (() => {
+  const getPackagePath = () => {
+    const cliDir = path.dirname(process.argv[1]);
+    const packagePath = path.join(cliDir, "package.json");
+    return packagePath;
+  };
+  const getPackageDir = () => {
+    return path.dirname(getPackagePath());
+  };
+  const getPackageJson = () => {
+    try {
+      return JSON.parse(fs.readFileSync(getPackagePath(), "utf8"));
+    } catch (error) {
+      throw error;
+    }
+  };
+  return {
+    getPackageJson,
+    getPackagePath,
+    getPackageDir,
+  };
+})();
+
+// Hàm kết nối PM2 và xử lý lỗi
+const connectPM2 = (callback) => {
+  pm2.connect((err) => {
+    if (err) {
+      console.error(`pm2.connect: ${err.message}`);
+      console.error(err);
+      process.exit(2);
+    }
+    callback();
+  });
+};
+
+// Hàm tạo cấu hình pm2 từ package.json
+const createPM2Config = () => {
+  let package = npmHelper.getPackageJson();
+  let cliDir = npmHelper.getPackageDir();
+
+  if (!("pm2StartOption" in package)) {
+    package.pm2StartOption = {};
+  }
+
+  if (!("name" in package.pm2StartOption)) {
+    package.pm2StartOption.name = package.name;
+  }
+
+  if (!("script" in package.pm2StartOption) && "main" in package) {
+    package.pm2StartOption.script = path.join(cliDir, package.main);
+  }
+  // Lấy thư mục hiện tại nơi script đang chạy
+  const currentCwd = process.cwd();
+  package.pm2StartOption.cwd = currentCwd;
+  // Lấy tất cả các đối số từ vị trí thứ 2 trở đi
+  const pm2Args = process.argv.slice(2).join(" ");
+  // Nếu không có đối số nào, args sẽ là một mảng rỗng
+  package.pm2StartOption.args = pm2Args;
+  package.pm2StartOption = [package.pm2StartOption];
+  package.pm2StartOption.push({
+    name: `${package.name}-updater`,
+    script: path.join(cliDir, `pm2.updater.js`),
+    cwd: currentCwd,
+    args: pm2Args,
+  });
+
+  return package.pm2StartOption;
+};
+
+// Hàm khởi động ứng dụng PM2
+const startPM2App = (pm2StartOption) => {
+  pm2.start(pm2StartOption, (err, apps) => {
+    if (err) {
+      console.error(`pm2.start: ${err.message}`);
+      console.error(err);
+      pm2.disconnect(); // Đảm bảo gọi disconnect nếu có lỗi
+      process.exit(2);
+    }
+    console.log(`Đã khởi động ứng dụng: ${npmHelper.getPackageJson().name}@${npmHelper.getPackageJson().version}`);
+    pm2.disconnect();
+  });
+};
+
+// Hàm chính để xử lý toàn bộ logic
+const mainPM2 = async () => {
+  try {
+    connectPM2(() => {
+      try {
+        const pm2StartOption = createPM2Config();
+        startPM2App(pm2StartOption);
+      } catch (error) {
+        console.error(error.message);
+        console.error(error);
+        pm2.disconnect();
+        process.exit(2);
+      }
+    });
+  } catch (error) {
+    console.error(`Lỗi ngoài ý muốn: ${error.message}`);
+    console.error(error);
+    process.exit(2);
+  }
+};
+
+mainPM2();

package/pm2.monitor.js

@@ -0,0 +1,244 @@
+const { exec } = require("child_process");
+const util = require("util");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+// Chuyển exec thành Promise để dễ sử dụng async/await
+const execAsync = util.promisify(exec);
+
+const pm2Cmd = require("./pm2.command");
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
+
+// Danh sách các dịch vụ cần giám sát
+const SERVICES_TO_MONITOR = (() => {
+  let targetDirectory = path.dirname(__filename);
+  let packageJSON = JSON.parse(fs.readFileSync(path.join(targetDirectory, "package.json"), "utf8"));
+  return [packageJSON.name, `${packageJSON.name}-updater`];
+})();
+
+const Utils = (() => {
+  const LOG_RETENTION_DAYS = 7; // Số ngày giữ lại log
+  const LOG_DIR = "./logs/pm2-monitor"; // Thư mục chứa log
+
+  if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  }
+  // Lấy tên file log theo ngày
+  function getLogFileName() {
+    const today = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+    return path.join(LOG_DIR, `pm2-monitor-${today}.log`);
+  }
+  // Hàm ghi log với timestamp vào file và console
+  function log(message, type = "INFO") {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] [${type}] ${message}`;
+
+    // Ghi ra console
+    console.log(logMessage);
+
+    // Ghi vào file
+    try {
+      const logFile = getLogFileName();
+      fs.appendFileSync(logFile, logMessage + "\n", "utf8");
+    } catch (error) {
+      console.error(`Lỗi khi ghi log vào file: ${error.message}`);
+    }
+  }
+  // Hàm xóa log cũ
+  function cleanupOldLogs() {
+    try {
+      if (!fs.existsSync(LOG_DIR)) return;
+
+      const files = fs.readdirSync(LOG_DIR);
+      const now = new Date();
+      let deletedCount = 0;
+
+      files.forEach((file) => {
+        if (file.startsWith("pm2-monitor-") && file.endsWith(".log")) {
+          const filePath = path.join(LOG_DIR, file);
+          const fileStats = fs.statSync(filePath);
+          const fileAge = (now - fileStats.mtime) / (1000 * 60 * 60 * 24); // Số ngày
+
+          if (fileAge > LOG_RETENTION_DAYS) {
+            fs.unlinkSync(filePath);
+            deletedCount++;
+            log(`Đã xóa log cũ: ${file}`, "INFO");
+          }
+        }
+      });
+
+      if (deletedCount > 0) {
+        log(`Hoàn thành dọn dẹp log cũ, đã xóa ${deletedCount} file`, "INFO");
+      }
+    } catch (error) {
+      log(`Lỗi khi dọn dẹp log cũ: ${error.message}`, "ERROR");
+    }
+  }
+  return {
+    log,
+    cleanupOldLogs,
+  };
+})();
+const log = Utils.log;
+
+// Cấu hình
+const CHECK_INTERVAL = 30000; // 30 giây
+const LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // Dọn dẹp log mỗi 24 giờ
+
+// Hàm kiểm tra và khởi động lại các service bị dừng
+async function checkAndRestartServices(isRunByStartupMonitor = false) {
+  const isServiceRunning = (processList, serviceName) => {
+    const process = processList.find((p) => p.name === serviceName);
+    if (!process) {
+      log(`Không tìm thấy service: ${serviceName}`, "WARNING");
+      return false;
+    }
+
+    const status = process.pm2_env.status;
+    const pid = process.pid;
+    const uptime = process.pm2_env.pm_uptime;
+    const memory = process.monit.memory;
+    const cpu = process.monit.cpu;
+
+    // Log thông tin chi tiết về service
+    log(`Service ${serviceName} - Status: ${status}, PID: ${pid}, Memory: ${(memory / 1024 / 1024).toFixed(2)}MB, CPU: ${cpu}%`, "DEBUG");
+
+    return status === "online";
+  };
+  const startSERVICES_TO_MONITOR = async (serviceName) => {
+    log(`Service ${serviceName} không tồn tại, chạy pm2.js...`, "INFO");
+    try {
+      let pm2JSPath = path.join(path.dirname(__filename), "pm2.js");
+      const { stdout, stderr } = await execAsync(`node ${pm2JSPath}`, { cwd: process.cwd() });
+      if (stderr) {
+        log(`Lỗi khi chạy pm2.js: ${stderr}`, "ERROR");
+      }
+      log(`pm2.js đã được chạy. Output: ${stdout}`, "INFO");
+    } catch (error) {
+      log(`Lỗi khi chạy pm2.js: ${error.message}`, "ERROR");
+    }
+  };
+  try {
+    log("Bắt đầu kiểm tra trạng thái các service...", "INFO");
+
+    let pm2Result = await pm2Cmd.list();
+    log(pm2Result.message);
+    const processList = pm2Result.data;
+
+    if (processList.length === 0) {
+      log("Không có process PM2 nào đang chạy", "WARNING");
+      await startSERVICES_TO_MONITOR();
+      return;
+    }
+
+    // Kiểm tra xem tất cả các service trong SERVICES_TO_MONITOR có đang chạy không
+    const allServicesRunning = SERVICES_TO_MONITOR.every((serviceName) => processList.some((p) => p.name === serviceName));
+
+    if (!allServicesRunning) {
+      log("Không phải tất cả các service cần giám sát đang chạy, tiến hành khởi động lại...", "WARNING");
+      await startSERVICES_TO_MONITOR();
+      return;
+    }
+
+    let servicesChecked = 0;
+    let servicesRestarted = 0;
+
+    for (const serviceName of SERVICES_TO_MONITOR) {
+      servicesChecked++;
+      const isRunning = isServiceRunning(processList, serviceName);
+
+      if (isRunByStartupMonitor === true || !isRunning) {
+        let mess = `Service ${serviceName} đang bị dừng, tiến hành khởi động lại...`;
+        if (isRunByStartupMonitor === true) mess = `Service ${serviceName} khởi động lại by isRunByStartupMonitor===true...`;
+        log(mess, "WARNING");
+        pm2Result = await pm2Cmd.restart(serviceName);
+        log(pm2Result.message);
+        const restartSuccess = pm2Result.data;
+        if (restartSuccess) {
+          servicesRestarted++;
+        }
+        // Chờ một chút trước khi kiểm tra service tiếp theo
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      } else {
+        log(`Service ${serviceName} đang hoạt động bình thường`, "INFO");
+      }
+    }
+    log(`Hoàn thành kiểm tra ${servicesChecked} service(s), đã restart ${servicesRestarted} service(s)`, "INFO");
+  } catch (error) {
+    log(`Lỗi trong quá trình kiểm tra: ${error.message}`, "ERROR");
+  }
+}
+
+async function stopServices() {
+  try {
+    for (const serviceName of SERVICES_TO_MONITOR) {
+      try {
+        let pm2Result = await pm2Cmd.stop(serviceName);
+        log(pm2Result.message);
+        // Chờ một chút trước khi kiểm tra service tiếp theo
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      } catch (error) {
+        log(`Lỗi trong quá trình stopServices ${serviceName}: ${error.message}`, "ERROR");
+      }
+    }
+  } catch (error) {
+    log(`Lỗi trong quá trình stopServices: ${error.message}`, "ERROR");
+  }
+}
+// Hàm chính để chạy monitor
+async function startMonitoring() {
+  log("=== BẮT ĐẦU GIÁM SÁT CÁC SERVICE PM2 ===", "INFO");
+  log(`Các service được giám sát: ${SERVICES_TO_MONITOR.join(", ")}`, "INFO");
+  log(`Thời gian kiểm tra: ${CHECK_INTERVAL / 1000} giây`, "INFO");
+
+  // Kiểm tra ngay lập tức
+  await checkAndRestartServices(true);
+
+  // Thiết lập interval để kiểm tra định kỳ
+  setInterval(async () => {
+    await checkAndRestartServices(false);
+  }, CHECK_INTERVAL);
+}
+
+const startMonitor = (() => {
+  let isExiting = false;
+  async function gracefulShutdown(signal) {
+    if (isExiting) return;
+    isExiting = true;
+
+    log(`Nhận signal ${signal}, đang dừng các services...`, "INFO");
+
+    try {
+      await stopServices();
+      log("Đã dừng xong các services, thoát chương trình...", "INFO");
+    } catch (error) {
+      log(`Lỗi khi dừng services: ${error.message}`, "ERROR");
+    }
+
+    process.exit(0);
+  }
+  process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+  process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+  // Xử lý lỗi không được catch
+  process.on("unhandledRejection", (reason, promise) => {
+    log(`Unhandled Rejection at: ${promise}, reason: ${reason}`, "ERROR");
+  });
+  process.on("uncaughtException", (error) => {
+    log(`Uncaught Exception: ${error.message}`, "ERROR");
+    log(`Stack: ${error.stack}`, "ERROR");
+    // process.exit(1);
+  });
+  startMonitoring().catch((error) => {
+    log(`Lỗi khi khởi động monitor: ${error.message}`, "ERROR");
+    process.exit(1);
+  });
+})();
+const cleanLog = (() => {
+  Utils.cleanupOldLogs();
+  // Thiết lập interval để kiểm tra định kỳ
+  setInterval(async () => {
+    Utils.cleanupOldLogs();
+  }, LOG_CLEANUP_INTERVAL);
+})();