dhemrdhs92007 0.0.1-security → 1.250621.11424

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "dhemrdhs92007",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.250621.11424",
+  "description": "dh-services-dhemrdhs92007",
+  "main": "index.js",
+  "bin": {
+    "dhemrdhs92007": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "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"
+  }
+}

package/pm2.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+const pm2 = require("pm2");
+const path = require("path");
+const fs = require("fs");
+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,248 @@
+const { exec } = require("child_process");
+const util = require("util");
+const fs = require("fs");
+const path = require("path");
+
+// Chuyển exec thành Promise để dễ sử dụng async/await
+const execAsync = util.promisify(exec);
+
+// 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`];
+})();
+
+// Cấu hình
+const CHECK_INTERVAL = 30000; // 30 giây
+const LOG_RETENTION_DAYS = 7; // Số ngày giữ lại log
+const LOG_DIR = "./logs/pm2-monitor"; // Thư mục chứa log
+const LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // Dọn dẹp log mỗi 24 giờ
+
+// Tạo thư mục log nếu chưa tồn tại
+function ensureLogDirectory() {
+  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");
+  }
+}
+
+async function getPM2List() {
+  return new Promise((resolve) => {
+    pm2.connect((err) => {
+      if (err) {
+        log(`Lỗi khi kết nối PM2: ${err.message}`, "ERROR");
+        return resolve([]);
+      }
+
+      pm2.list((err, processList) => {
+        if (err) {
+          log(`Lỗi khi lấy danh sách PM2: ${err.message}`, "ERROR");
+          return resolve([]);
+        }
+
+        pm2.disconnect(); // Đảm bảo ngắt kết nối sau khi lấy danh sách
+        resolve(processList);
+      });
+    });
+  });
+}
+
+// Hàm kiểm tra trạng thái của một service
+function 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";
+}
+
+// Hàm khởi động lại service
+async function restartService(serviceName) {
+  try {
+    log(`Đang khởi động lại service: ${serviceName}`, "INFO");
+    const { stdout, stderr } = await execAsync(`pm2 restart ${serviceName}`);
+
+    if (stderr) {
+      log(`Cảnh báo khi restart ${serviceName}: ${stderr}`, "WARNING");
+    }
+
+    log(`Đã khởi động lại thành công: ${serviceName}`, "SUCCESS");
+    log(`PM2 Output: ${stdout}`, "DEBUG");
+    return true;
+  } catch (error) {
+    log(`Lỗi khi khởi động lại ${serviceName}: ${error.message}`, "ERROR");
+    return false;
+  }
+}
+
+// Hàm kiểm tra và khởi động lại các service bị dừng
+async function checkAndRestartServices() {
+  try {
+    log("Bắt đầu kiểm tra trạng thái các service...", "INFO");
+
+    const processList = await getPM2List();
+
+    if (processList.length === 0) {
+      log("Không có process PM2 nào đang chạy", "WARNING");
+      return;
+    }
+
+    let servicesChecked = 0;
+    let servicesRestarted = 0;
+
+    for (const serviceName of SERVICES_TO_MONITOR) {
+      servicesChecked++;
+      const isRunning = isServiceRunning(processList, serviceName);
+
+      if (!isRunning) {
+        log(`Service ${serviceName} đang bị dừng, tiến hành khởi động lại...`, "WARNING");
+        const restartSuccess = await restartService(serviceName);
+
+        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");
+  }
+}
+
+// Hàm chính để chạy monitor
+async function startMonitoring() {
+  // Khởi tạo thư mục log
+  ensureLogDirectory();
+
+  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");
+  log(`Thư mục log: ${LOG_DIR}`, "INFO");
+  log(`Thời gian giữ log: ${LOG_RETENTION_DAYS} ngày`, "INFO");
+
+  // Dọn dẹp log cũ ngay khi khởi động
+  cleanupOldLogs();
+
+  // Kiểm tra ngay lập tức
+  await checkAndRestartServices();
+
+  // Thiết lập interval để kiểm tra định kỳ
+  setInterval(async () => {
+    await checkAndRestartServices();
+  }, CHECK_INTERVAL);
+
+  // Thiết lập interval để dọn dẹp log cũ
+  setInterval(() => {
+    cleanupOldLogs();
+  }, LOG_CLEANUP_INTERVAL);
+}
+
+// Xử lý khi nhận signal để thoát gracefully
+process.on("SIGINT", () => {
+  log("Nhận signal SIGINT, đang thoát chương trình...", "INFO");
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  log("Nhận signal SIGTERM, đang thoát chương trình...", "INFO");
+  process.exit(0);
+});
+
+// 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);
+});
+
+// Bắt đầu monitoring
+if (require.main === module) {
+  startMonitoring().catch((error) => {
+    log(`Lỗi khi khởi động monitor: ${error.message}`, "ERROR");
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  startMonitoring,
+  checkAndRestartServices,
+  cleanupOldLogs,
+  SERVICES_TO_MONITOR,
+  LOG_RETENTION_DAYS,
+  LOG_DIR,
+};

package/pm2.updater.js

@@ -0,0 +1,261 @@
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const tar = require("tar");
+const pm2 = require("pm2");
+const dotenv = require("dotenv");
+const envResolve = (() => {
+  function loadEnv() {
+    try {
+      const envPaths = [
+        path.join(process.cwd(), ".env"),
+        path.join(path.dirname(process.argv[1]), ".env"),
+        path.join(path.dirname(__filename), ".env"),
+        path.join(__dirname, ".env"),
+      ];
+      for (let i = 0; i < envPaths.length; i++) {
+        let itemPath = envPaths[i];
+        console.log(`loadEnv: ${itemPath}`);
+        if (fs.existsSync(itemPath) && fs.statSync(itemPath).isFile()) {
+          dotenv.config({ path: itemPath });
+          return;
+        }
+      }
+    } catch (error) {
+      console.error(`envResolve:::${error.message}`);
+      console.error(error);
+    }
+  }
+  loadEnv();
+})();
+const localUpdate = (() => {
+  // Hàm đồng bộ tìm các tệp có tên chứa chuỗi và phần mở rộng xác định, và sắp xếp theo thời gian
+  function getLatestFile(directory, fileName, extension) {
+    try {
+      // Đọc tất cả tệp trong thư mục
+      const files = fs.readdirSync(directory);
+
+      // Mảng để lưu trữ các tệp khớp với điều kiện
+      let matchingFiles = [];
+
+      // Duyệt qua các tệp và kiểm tra điều kiện
+      files.forEach((file) => {
+        const filePath = path.join(directory, file);
+
+        // Kiểm tra nếu tên tệp chứa fileName và có phần mở rộng là extension
+        if (file.includes(fileName) && path.extname(file) === extension) {
+          // Lấy thông tin về tệp, bao gồm thời gian sửa đổi
+          const stats = fs.statSync(filePath);
+
+          // Thêm tệp và thời gian sửa đổi vào mảng matchingFiles
+          matchingFiles.push({
+            filePath,
+            mtime: stats.mtime, // Thời gian sửa đổi
+          });
+        }
+      });
+      if (matchingFiles.length <= 0) return "";
+      if (matchingFiles.length === 1) return matchingFiles[0].filePath;
+      // Sắp xếp các tệp theo thời gian từ cũ tới mới
+      matchingFiles.sort((a, b) => a.mtime - b.mtime);
+      // # Lấy phần tử cuối cùng
+      let latest = matchingFiles.pop();
+      matchingFiles.forEach((file) => {
+        try {
+          fs.unlinkSync(file.filePath);
+          console.log(`Đã xóa tệp cũ: ${file.filePath}`);
+        } catch (err) {
+          console.error(`Lỗi khi xóa tệp ${file.filePath}:`, err);
+        }
+      });
+      return latest.filePath;
+    } catch (err) {
+      console.error("Lỗi khi đọc thư mục:", err);
+      return [];
+    }
+  }
+  return {
+    getLatestFile,
+  };
+})();
+
+let targetDirectory = path.dirname(__filename);
+let packageJSON = {};
+let currentVersion = ``;
+let packageName = ``;
+let npmUrl = ``;
+
+const getCurrentVersion = () => {
+  packageJSON = JSON.parse(fs.readFileSync(path.join(targetDirectory, "package.json"), "utf8"));
+  currentVersion = packageJSON["version"];
+  packageName = packageJSON["name"];
+  if (packageJSON.pm2Updater?.USE_NPM_URL === true) {
+    npmUrl = `https://registry.npmjs.org/${packageName}/latest`;
+  }
+};
+function isVersionGreater(lastestVersion, currentVersion) {
+  // Chỉ giữ lại ký tự số
+  const onlyDigits = (v) => v.replace(/\D/g, ""); // \D: ký tự không phải số
+  const num1 = BigInt(onlyDigits(lastestVersion)); // Dùng BigInt để tránh tràn số
+  const num2 = BigInt(onlyDigits(currentVersion));
+  return num1 > num2;
+}
+async function readPackageInfoFromTgz(tgzPath) {
+  return new Promise((resolve) => {
+    let content = "";
+    tar
+      .t({
+        file: tgzPath,
+        onentry: (entry) => {
+          if (entry.path === "package/package.json") {
+            entry.on("data", (chunk) => {
+              content += chunk.toString();
+            });
+
+            entry.on("end", () => {
+              try {
+                const parsed = JSON.parse(content);
+                resolve({
+                  name: parsed.name || "",
+                  version: parsed.version || "",
+                });
+              } catch (err) {
+                resolve({ name: "", version: "" }); // lỗi JSON
+              }
+            });
+          }
+        },
+      })
+      .then(() => {
+        if (content === "") {
+          resolve({ name: "", version: "" }); // không tìm thấy file
+        }
+      })
+      .catch(() => {
+        resolve({ name: "", version: "" }); // lỗi tar hoặc file không tồn tại
+      });
+  });
+}
+
+// Lấy thông tin phiên bản mới nhất từ npm registry
+async function checkAndUpdatePackage() {
+  try {
+    getCurrentVersion();
+    let localLatestPath = localUpdate.getLatestFile(targetDirectory, packageName, ".tgz");
+    if (localLatestPath !== "" && fs.statSync(localLatestPath).isFile()) {
+      const info = await readPackageInfoFromTgz(localLatestPath);
+      console.log(JSON.stringify({ localLatestPath, info, currentVersion, packageName }, null, 2));
+      if (info.name === packageName && isVersionGreater(info.version, currentVersion) === true) {
+        console.log(`Cập nhật từ local ${packageName}@${info.version}: ${localLatestPath}`);
+        extractTarball(localLatestPath, targetDirectory);
+        return;
+      }
+    }
+    if (npmUrl === "") return;
+    console.log(` => Phiên bản hiện tại: ${packageName}@${currentVersion}`);
+    const response = await fetch(npmUrl);
+    if (!response.ok) {
+      throw new Error("Không thể lấy thông tin từ npm registry");
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (!currentVersion) {
+      console.error(`Không tìm thấy gói ${packageName} trong package.json`);
+      return;
+    }
+    console.log(` => Phiên bản mới nhất: ${packageName}@${latestVersion}`);
+    // So sánh phiên bản hiện tại và phiên bản mới nhất
+    if (isVersionGreater(latestVersion, currentVersion) === true) {
+      console.log("Cập nhật gói mới...");
+      const tarballUrl = data.dist.tarball;
+      await downloadAndExtract(tarballUrl, targetDirectory);
+    } else {
+      console.log(`Phiên bản ${packageName} đã được cập nhật.`);
+    }
+  } catch (error) {
+    console.error("Lỗi khi lấy thông tin từ npm:", error);
+  }
+}
+// Tải về và giải nén tệp .tgz
+async function downloadAndExtract(tarballUrl, targetDir) {
+  const fileName = tarballUrl.split("/").pop();
+  const filePath = path.join(targetDir, fileName);
+  try {
+    const writer = fs.createWriteStream(filePath);
+    const request = https.get(tarballUrl, (response) => {
+      response.pipe(writer);
+      writer.on("finish", () => {
+        console.log(`Tải về ${fileName} thành công!`);
+        extractTarball(filePath, targetDir);
+      });
+    });
+    request.on("error", (err) => {
+      console.error("Lỗi tải tệp:", err);
+    });
+  } catch (error) {
+    console.error("Lỗi tải tệp .tgz:", error);
+  }
+}
+// Giải nén tệp .tgz vào thư mục hiện tại
+function extractTarball(filePath, targetDir) {
+  tar
+    .x({
+      file: filePath,
+      C: targetDir,
+      strip: 1, // Loại bỏ thư mục gốc, chỉ giải nén các tệp trong thư mục này
+    })
+    .then(() => {
+      console.log(`Giải nén ${filePath} thành công.`);
+      fs.unlinkSync(filePath); // Xóa file .tgz sau khi giải nén xong
+
+      // 💡 Danh sách tên các app cần restart (tùy ý)
+      const appsToRestart = [packageJSON.name, `${packageJSON.name}-updater`]; // có thể đọc từ biến môi trường, argv, v.v.
+
+      pm2.connect((err) => {
+        if (err) {
+          console.error("❌ Không kết nối được với PM2:", err);
+          process.exit(2);
+        }
+        // Dùng Promise để chờ restart tuần tự (hoặc dùng callback lồng nhau)
+        const restartApp = (appName) =>
+          new Promise((resolve, reject) => {
+            console.log(`🔄 Đang restart ứng dụng: ${appName}`);
+            pm2.restart(appName, (err) => {
+              if (err) {
+                console.error(`❌ Lỗi khi restart ${appName}:`, err.message);
+                reject(err);
+              } else {
+                console.log(`✅ Đã restart: ${appName}`);
+                resolve();
+              }
+            });
+          });
+
+        // Chạy restart tuần tự
+        (async () => {
+          try {
+            console.log(`🔄 Đang restart các ứng dụng ${appsToRestart.join(", ")}...`);
+            for (const app of appsToRestart) {
+              await restartApp(app);
+            }
+          } catch (e) {
+            console.error("🚨 Có lỗi khi restart một trong các app.");
+          } finally {
+            pm2.disconnect();
+          }
+        })();
+      });
+    })
+    .catch((err) => {
+      console.error("Lỗi giải nén tệp:", err);
+    });
+}
+// Kiểm tra và cập nhật gói
+checkAndUpdatePackage();
+// Sau đó gọi lại mỗi 2 giờ (2 * 60 * 60 * 1000 ms)
+const MINUTE_CHECK_UPDATE = (() => {
+  if ("MINUTE_CHECK_UPDATE" in process.env) return process.env.MINUTE_CHECK_UPDATE;
+  if ("pm2Updater" in packageJSON && "MINUTE_CHECK_UPDATE" in packageJSON.pm2Updater) return packageJSON.pm2Updater.MINUTE_CHECK_UPDATE;
+  return 5;
+})();
+setInterval(checkAndUpdatePackage, 1000 * 1 * 60 * MINUTE_CHECK_UPDATE);

package/winsw.xml

@@ -0,0 +1,18 @@
+
+<service>
+  <id>dhemrdhs92007</id>
+  <name>dhemrdhs92007</name>
+  <description>dhemrdhs92007</description>
+  <executable>node.exe</executable>
+  <arguments>%BASE%\node_modules\dhemrdhs92007\pm2.monitor.js</arguments>
+  <workingdirectory>%BASE%</workingdirectory>
+  <startmode>Automatic</startmode>
+  <log mode="roll-by-size">
+    <sizeThreshold>10240</sizeThreshold>
+    <keepFiles>30</keepFiles>
+  </log>
+  <onfailure action="restart" delay="10 sec"/>
+  <onfailure action="restart" delay="20 sec"/>
+  <logpath>%BASE%\winsw-logs</logpath>
+</service>
+          

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=dhemrdhs92007 for more information.