@drocketxx/pm2me 1.1.12 → 1.1.13

package/apps/PM2Me-main/backend/routes/auth.js

@@ -1,44 +0,0 @@
-import express from 'express';
-import db from '../db/index.js';
-import bcrypt from 'bcrypt';
-import jwt from 'jsonwebtoken';
-
-const router = express.Router();
-const JWT_SECRET = process.env.JWT_SECRET || 'super-secret-pm2me-key-2026';
-
-router.post('/login', async (req, res) => {
-    const { password } = req.body;
-    const adminConfig = db.data.admin;
-
-    if (!adminConfig || !adminConfig.passwordHash) {
-        // If no password is set, the first login attempts sets it
-        const hash = await bcrypt.hash(password, 10);
-        db.data.admin.passwordHash = hash;
-        await db.write();
-        const token = jwt.sign({ role: 'admin' }, JWT_SECRET, { expiresIn: '1d' });
-        return res.json({ token, message: 'Admin password set successfully and logged in' });
-    }
-
-    const match = await bcrypt.compare(password, adminConfig.passwordHash);
-    if (!match) {
-        return res.status(401).json({ error: 'Invalid password' });
-    }
-
-    const token = jwt.sign({ role: 'admin' }, JWT_SECRET, { expiresIn: '1d' });
-    res.json({ token });
-});
-
-export const authenticateToken = (req, res, next) => {
-    const authHeader = req.headers['authorization'];
-    const token = authHeader && authHeader.split(' ')[1];
-
-    if (!token) return res.sendStatus(401);
-
-    jwt.verify(token, JWT_SECRET, (err, user) => {
-        if (err) return res.sendStatus(403);
-        req.user = user;
-        next();
-    });
-};
-
-export default router;

package/apps/PM2Me-main/backend/services/gitService.js

@@ -1,110 +0,0 @@
-import simpleGit from 'simple-git';
-import fs from 'fs';
-import path from 'path';
-
-const getFinalUrl = (repoUrl, token) => {
-    let finalUrl = repoUrl;
-    if (token) {
-        try {
-            const urlObj = new URL(repoUrl);
-            urlObj.password = token;
-            urlObj.username = 'oauth2';
-            finalUrl = urlObj.toString();
-        } catch (e) {
-            console.error('Invalid URL for cloning', e);
-        }
-    }
-    return finalUrl;
-};
-
-export const syncRepo = async (repoUrl, targetPath, branchName, token = null) => {
-    const finalUrl = getFinalUrl(repoUrl, token);
-    const envOptions = { ...process.env, GIT_TERMINAL_PROMPT: '0' }; // Prevent hanging on auth prompts or merge editors
-
-    const isGitRepo = fs.existsSync(path.join(targetPath, '.git'));
-
-    const freshClone = async () => {
-        if (fs.existsSync(targetPath)) {
-            fs.rmSync(targetPath, { recursive: true, force: true });
-        }
-        fs.mkdirSync(targetPath, { recursive: true });
-        const git = simpleGit().env(envOptions);
-        await git.clone(finalUrl, targetPath, ['--branch', branchName]);
-        const gitLocal = simpleGit(targetPath);
-        const log = await gitLocal.log(['-1']);
-        const commitHash = log.latest.hash;
-        const commitMessage = log.latest.message;
-        return { message: 'Cloned repository cleanly', commitHash: commitHash.trim(), commitMessage: commitMessage.trim() };
-    };
-
-    if (!isGitRepo) {
-        try {
-            return await freshClone();
-        } catch (err) {
-            throw new Error(`Git Clone Error: ${err.message}`);
-        }
-    } else {
-        try {
-            const git = simpleGit(targetPath).env(envOptions);
-            await git.remote(['set-url', 'origin', finalUrl]);
-            await git.fetch('origin', branchName);
-            await git.checkout(branchName);
-            await git.reset(['--hard', 'FETCH_HEAD']);
-            await git.clean('f', ['-d']);
-            const log = await git.log(['-1']);
-            const commitHash = log.latest.hash;
-            const commitMessage = log.latest.message;
-            return { message: 'Pulled latest changes cleanly', commitHash: commitHash.trim(), commitMessage: commitMessage.trim() };
-        } catch (err) {
-            console.warn(`Git Sync failed, attempting fresh clone. Reason: ${err.message}`);
-            try {
-                return await freshClone();
-            } catch (cloneErr) {
-                throw new Error(`Git Sync & Retreat Clone Error: ${cloneErr.message}`);
-            }
-        }
-    }
-};
-
-export const getBranches = async (repoUrl, token = null) => {
-    const finalUrl = getFinalUrl(repoUrl, token);
-    const git = simpleGit().env({ ...process.env, GIT_TERMINAL_PROMPT: '0' });
-    const branches = await git.listRemote(['--heads', finalUrl]);
-    // Parse branch output, simplistic split
-    return branches.split('\n').filter(Boolean).map(line => line.split('refs/heads/')[1]);
-};
-
-/**
- * Get the number of commits that the local branch is behind its remote origin counterpart.
- */
-export const getBehindCount = async (repoUrl, targetPath, branchName, token = null) => {
-    const isGitRepo = fs.existsSync(path.join(targetPath, '.git'));
-    if (!isGitRepo) return 0;
-
-    const finalUrl = getFinalUrl(repoUrl, token);
-    const git = simpleGit(targetPath).env({ ...process.env, GIT_TERMINAL_PROMPT: '0' });
-
-    try {
-        await git.remote(['set-url', 'origin', finalUrl]);
-        await git.fetch(['origin', branchName]);
-        const count = await git.raw(['rev-list', '--count', `HEAD..origin/${branchName}`]);
-        return parseInt(count.trim(), 10) || 0;
-    } catch (err) {
-        console.error(`Git behind count error for ${targetPath}:`, err.message);
-        return 0;
-    }
-};
-
-export const checkout = async (targetPath, ref) => {
-    const git = simpleGit(targetPath).env({ ...process.env, GIT_TERMINAL_PROMPT: '0' });
-    try {
-        await git.checkout(ref);
-        const log = await git.log(['-1']);
-        return {
-            hash: log.latest.hash.trim(),
-            message: log.latest.message.trim()
-        };
-    } catch (err) {
-        throw new Error(`Git Checkout Error: ${err.message}`);
-    }
-};

package/apps/PM2Me-main/backend/services/notificationService.js

@@ -1,48 +0,0 @@
-import db from '../db/index.js';
-
-export const sendDiscordNotification = async (message) => {
-    const { discordWebhook } = db.data.settings;
-    if (!discordWebhook) return;
-
-    try {
-        await fetch(discordWebhook, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ content: message })
-        });
-    } catch (err) {
-        console.error('Discord notification failed:', err);
-    }
-};
-
-export const sendTelegramNotification = async (message) => {
-    const { telegramBotToken, telegramChatId } = db.data.settings;
-    if (!telegramBotToken || !telegramChatId) return;
-
-    try {
-        const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
-        await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ chat_id: telegramChatId, text: message })
-        });
-    } catch (err) {
-        console.error('Telegram notification failed:', err);
-    }
-};
-
-export const notifyAll = async (appName, status, error = null) => {
-    let message = '';
-    if (status === 'success') {
-        message = `✅ **Deployment Success**\nApp \`${appName}\` has been successfully deployed and is now running.`;
-    } else if (status === 'failed') {
-        message = `❌ **Deployment Failed**\nApp \`${appName}\` failed to deploy.\nError: ${error}`;
-    } else {
-        message = `ℹ️ **App Status Update**\nApp \`${appName}\` is now ${status}.`;
-    }
-
-    await Promise.all([
-        sendDiscordNotification(message),
-        sendTelegramNotification(message)
-    ]);
-};

package/apps/PM2Me-main/backend/services/pm2Service.js

@@ -1,84 +0,0 @@
-import pm2 from 'pm2';
-
-export const connectPM2 = () => {
-    return new Promise((resolve, reject) => {
-        pm2.connect((err) => {
-            if (err) return reject(err);
-            resolve(true);
-        });
-    });
-};
-
-export const listApps = () => {
-    return new Promise((resolve, reject) => {
-        pm2.list((err, list) => {
-            if (err) return reject(err);
-            resolve(list);
-        });
-    });
-};
-
-export const startApp = (options) => {
-    return new Promise((resolve, reject) => {
-        pm2.start(options, (err, apps) => {
-            if (err) return reject(err);
-            resolve(apps);
-        });
-    });
-};
-
-export const stopApp = (nameOrId) => {
-    return new Promise((resolve, reject) => {
-        pm2.stop(nameOrId, (err, proc) => {
-            if (err) return reject(err);
-            resolve(proc);
-        });
-    });
-};
-
-export const restartApp = (nameOrId, options = {}) => {
-    return new Promise((resolve, reject) => {
-        if (options && options.updateEnv) {
-            // To update env, restart should be called via start with appropriate options
-            pm2.start({ ...options, name: nameOrId, updateEnv: true }, (err, proc) => {
-                if (err) return reject(err);
-                resolve(proc);
-            });
-        } else {
-            pm2.restart(nameOrId, (err, proc) => {
-                if (err) return reject(err);
-                resolve(proc);
-            });
-        }
-    });
-};
-
-export const reloadApp = (nameOrId, options = {}) => {
-    return new Promise((resolve, reject) => {
-        if (options && options.updateEnv) {
-            // pm2.reload doesn't accept options directly in all versions, start with updateEnv enforces a reload/restart
-            pm2.start({ ...options, name: nameOrId, updateEnv: true }, (err, proc) => {
-                if (err) return reject(err);
-                resolve(proc);
-            });
-        } else {
-            pm2.reload(nameOrId, (err, proc) => {
-                if (err) return reject(err);
-                resolve(proc);
-            });
-        }
-    });
-};
-
-export const deleteApp = (nameOrId) => {
-    return new Promise((resolve, reject) => {
-        pm2.delete(nameOrId, (err, proc) => {
-            if (err) return reject(err);
-            resolve(proc);
-        });
-    });
-};
-
-export const disconnectPM2 = () => {
-    pm2.disconnect();
-};

package/apps/PM2Me-main/backend/services/systemService.js

@@ -1,113 +0,0 @@
-import os from 'os';
-import { exec } from 'child_process';
-import util from 'util';
-
-const execPromise = util.promisify(exec);
-let lastNetworkStats = { rx: 0, tx: 0, time: Date.now() };
-
-// Cache for slow stats
-let cachedDiskStats = { total: 0, free: 0, used: 0, percentage: 0, lastFetch: 0 };
-const DISK_CACHE_TTL = 60000; // 60 seconds
-
-export const getSystemStats = async () => {
-    const uptime = os.uptime();
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const usedMem = totalMem - freeMem;
-    const memUsage = (usedMem / totalMem) * 100;
-
-    // CPU Usage (Load average or heuristic)
-    const cpus = os.cpus();
-    const cpuModel = cpus[0].model;
-    const loadAvg = os.loadavg();
-    let cpuUsage = os.platform() === 'win32' ? 0 : (loadAvg[0] / cpus.length) * 100;
-    let diskUsage = { total: 0, free: 0, used: 0, percentage: 0 };
-
-    // Network Usage
-    let networkUsage = { down: 0, up: 0 };
-
-    if (os.platform() === 'win32') {
-        try {
-            const now = Date.now();
-            const promises = [];
-
-            // 1. CPU Usage (Every time)
-            const cpuPromise = execPromise('powershell -Command "(Get-Counter \'\\Processor(_Total)\\% Processor Time\' -ErrorAction SilentlyContinue).CounterSamples.CookedValue"')
-                .then(({ stdout }) => {
-                    const realCpu = parseFloat(stdout.trim());
-                    if (!isNaN(realCpu)) cpuUsage = realCpu;
-                })
-                .catch(e => console.error('CPU fetch failed:', e));
-            promises.push(cpuPromise);
-
-            // 2. Network Stats (Every time)
-            const netPromise = execPromise('powershell -Command "Get-NetAdapterStatistics | Select-Object ReceivedBytes, SentBytes | ConvertTo-Json"')
-                .then(({ stdout }) => {
-                    const netData = JSON.parse(stdout);
-                    let totalRx = 0;
-                    let totalTx = 0;
-                    if (Array.isArray(netData)) {
-                        netData.forEach(adapter => {
-                            totalRx += adapter.ReceivedBytes || 0;
-                            totalTx += adapter.SentBytes || 0;
-                        });
-                    } else if (netData) {
-                        totalRx = netData.ReceivedBytes || 0;
-                        totalTx = netData.SentBytes || 0;
-                    }
-                    const timeDiff = (now - lastNetworkStats.time) / 1000;
-                    if (timeDiff > 0 && lastNetworkStats.rx > 0) {
-                        networkUsage.down = Math.max(0, (totalRx - lastNetworkStats.rx) / timeDiff);
-                        networkUsage.up = Math.max(0, (totalTx - lastNetworkStats.tx) / timeDiff);
-                    }
-                    lastNetworkStats = { rx: totalRx, tx: totalTx, time: now };
-                })
-                .catch(e => console.error('Network fetch failed:', e));
-            promises.push(netPromise);
-
-            // 3. Disk Stats (Cached)
-            if (now - cachedDiskStats.lastFetch > DISK_CACHE_TTL) {
-                const diskPromise = execPromise('powershell -Command "Get-Volume -DriveLetter C | Select-Object Size, SizeRemaining | ConvertTo-Json"')
-                    .then(({ stdout }) => {
-                        const data = JSON.parse(stdout);
-                        if (data.Size > 0) {
-                            cachedDiskStats = {
-                                total: data.Size,
-                                free: data.SizeRemaining,
-                                used: data.Size - data.SizeRemaining,
-                                percentage: ((data.Size - data.SizeRemaining) / data.Size) * 100,
-                                lastFetch: now
-                            };
-                        }
-                    })
-                    .catch(e => console.error('Disk fetch failed:', e));
-                promises.push(diskPromise);
-            }
-
-            // Run all in parallel
-            await Promise.all(promises);
-            diskUsage = cachedDiskStats; // Use either fresh or current cache
-        } catch (e) {
-            console.error('Failed to get system stats via PowerShell:', e);
-        }
-    }
-
-    return {
-        platform: os.platform(),
-        hostname: os.hostname(),
-        uptime,
-        cpu: {
-            model: cpuModel,
-            usage: cpuUsage,
-            cores: cpus.length
-        },
-        memory: {
-            total: totalMem,
-            free: freeMem,
-            used: usedMem,
-            percentage: memUsage
-        },
-        disk: diskUsage,
-        network: networkUsage
-    };
-};