ezpm2gui 1.3.2 → 1.5.0

package/dist/server/utils/remote-connection.js

@@ -34,6 +34,8 @@ class RemoteConnection extends events_1.EventEmitter {
         super();
         this._isConnected = false;
         this.isPM2Installed = false;
+        /** Index into PM2_BUILDERS of the invocation that actually works on this host. -1 = not yet resolved. */
+        this.resolvedBuilderIndex = -1;
         this.client = new ssh2_1.Client();
         this.config = config;
         // Initialize public properties
@@ -127,11 +129,10 @@ class RemoteConnection extends events_1.EventEmitter {
         }
         // Apply sudo if configured or explicitly requested for this command
         const useElevatedPrivileges = forceSudo || this.config.useSudo;
-        let finalCommand = command;
-        // Only apply sudo if it's requested and we have a password
-        if (useElevatedPrivileges && this.config.password) {
-            finalCommand = `echo '${this.config.password}' | sudo -S ${command}`;
-        }
+        // Use sudo -S so sudo reads the password from stdin instead of piping it in the shell command
+        const finalCommand = (useElevatedPrivileges && this.config.password)
+            ? `sudo -S ${command}`
+            : command;
         console.log(`Executing command: ${useElevatedPrivileges ? '[sudo] ' : ''}${command}`);
         return new Promise((resolve, reject) => {
             this.client.exec(finalCommand, (err, channel) => {
@@ -139,6 +140,11 @@ class RemoteConnection extends events_1.EventEmitter {
                     console.error('Error executing command:', err);
                     return reject(err);
                 }
+                // Write password to sudo's stdin, then close stdin
+                if (useElevatedPrivileges && this.config.password) {
+                    channel.stdin.write(this.config.password + '\n');
+                    channel.stdin.end();
+                }
                 let stdout = '';
                 let stderr = '';
                 let exitCode = null;
@@ -152,11 +158,6 @@ class RemoteConnection extends events_1.EventEmitter {
                     exitCode = code;
                 });
                 channel.on('close', () => {
-                    // Remove sudo password from stdout/stderr if present
-                    if (useElevatedPrivileges && this.config.password) {
-                        stdout = stdout.replace(this.config.password, '[PASSWORD REDACTED]');
-                        stderr = stderr.replace(this.config.password, '[PASSWORD REDACTED]');
-                    }
                     resolve({
                         stdout,
                         stderr,
@@ -170,6 +171,170 @@ class RemoteConnection extends events_1.EventEmitter {
             });
         });
     }
+    static validateRemotePath(remotePath) {
+        if (!remotePath)
+            return false;
+        if (remotePath.includes('..'))
+            return false;
+        if (RemoteConnection.SHELL_UNSAFE.test(remotePath))
+            return false;
+        if (!/\.(log|gz)$/i.test(remotePath))
+            return false;
+        return true;
+    }
+    async streamFileToResponse(remotePath, res, fileName) {
+        // Validate path before any shell interpolation (fallback methods 2-4 use exec)
+        if (!RemoteConnection.validateRemotePath(remotePath)) {
+            if (!res.headersSent)
+                res.status(400).json({ success: false, error: 'Invalid log file path' });
+            return;
+        }
+        const setHeaders = () => {
+            if (!res.headersSent) {
+                res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            }
+        };
+        const escapeRemotePathForShell = (value) => {
+            if (/[\0\n\r]/.test(value)) {
+                throw new Error('Invalid remote path');
+            }
+            return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+        };
+        let escapedRemotePath;
+        try {
+            escapedRemotePath = escapeRemotePathForShell(remotePath);
+        }
+        catch {
+            if (!res.headersSent) {
+                res.status(400).json({ success: false, error: 'Invalid remote path' });
+            }
+            return;
+        }
+        // @group StreamFileToResponse : Helper — pipe an exec channel stdout to response
+        const pipeExec = (cmd, sudoPassword) => new Promise((resolve) => {
+            this.client.exec(cmd, (err, channel) => {
+                if (err) {
+                    resolve('error');
+                    return;
+                }
+                if (sudoPassword) {
+                    channel.stdin.write(sudoPassword + '\n');
+                }
+                channel.stdin.end();
+                let hasData = false;
+                channel.on('data', (chunk) => {
+                    if (!hasData) {
+                        setHeaders();
+                        hasData = true;
+                    }
+                    res.write(chunk);
+                });
+                channel.on('close', (code) => {
+                    if (hasData) {
+                        res.end();
+                        resolve('ok');
+                    }
+                    else
+                        resolve(code === 0 ? 'empty' : 'error');
+                });
+                channel.on('error', () => resolve('error'));
+                channel.stderr.resume(); // Discard stderr so it doesn't block the channel
+            });
+        });
+        // ── 1. SFTP (preferred — real streaming, no exec overhead) ──────────
+        const sftpOk = await new Promise((resolve) => {
+            this.client.sftp((err, sftp) => {
+                if (err) {
+                    resolve(false);
+                    return;
+                }
+                const stream = sftp.createReadStream(remotePath);
+                let hasData = false;
+                stream.on('data', (chunk) => {
+                    if (!hasData) {
+                        setHeaders();
+                        hasData = true;
+                    }
+                    res.write(chunk);
+                });
+                stream.on('end', () => { if (hasData) {
+                    res.end();
+                    resolve(true);
+                }
+                else
+                    resolve(false); });
+                stream.on('error', () => resolve(false));
+            });
+        });
+        if (sftpOk)
+            return;
+        // ── 2. Plain cat ─────────────────────────────────────────────────────
+        if (await pipeExec(`cat -- ${escapedRemotePath}`) === 'ok')
+            return;
+        // ── 3. sudo -S cat (password auth) ───────────────────────────────────
+        if (this.config.password) {
+            if (await pipeExec(`sudo -S cat -- ${escapedRemotePath}`, this.config.password) === 'ok')
+                return;
+        }
+        // ── 4. sudo cat without -S (NOPASSWD / key-based auth) ───────────────
+        if (await pipeExec(`sudo cat -- ${escapedRemotePath}`) === 'ok')
+            return;
+        // All attempts failed
+        if (!res.headersSent) {
+            res.status(403).json({ success: false, error: 'Cannot read log file — check file permissions or sudo configuration' });
+        }
+    }
+    /**
+     * Stream a remote .gz file to an HTTP response, decompressing it on the fly.
+     * Uses SFTP + local zlib.createGunzip() pipeline — no server-side buffering.
+     * Falls back to exec `zcat` if SFTP is unavailable.
+     */
+    async streamGzFileToResponse(remotePath, res, fileName) {
+        if (!RemoteConnection.validateRemotePath(remotePath)) {
+            if (!res.headersSent)
+                res.status(400).json({ success: false, error: 'Invalid log file path' });
+            return;
+        }
+        const zlib = require('zlib');
+        const setHeaders = () => {
+            if (!res.headersSent) {
+                res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            }
+        };
+        // ── SFTP + local gunzip (preferred — no exec, streaming, no buffering) ──
+        const sftpOk = await new Promise((resolve) => {
+            this.client.sftp((err, sftp) => {
+                if (err) {
+                    resolve(false);
+                    return;
+                }
+                const inputStream = sftp.createReadStream(remotePath);
+                const gunzip = zlib.createGunzip();
+                setHeaders();
+                inputStream.pipe(gunzip).pipe(res);
+                gunzip.on('finish', () => resolve(true));
+                gunzip.on('error', () => { inputStream.destroy(); resolve(false); });
+                inputStream.on('error', () => resolve(false));
+            });
+        });
+        if (sftpOk)
+            return;
+        // ── Fallback: exec zcat and buffer (path already validated) ──────────
+        if (!res.headersSent) {
+            const result = await this.executeCommand(`zcat -- "${remotePath}" 2>/dev/null`);
+            const decompressed = result.stdout ||
+                (await this.executeCommand(`sudo zcat -- "${remotePath}" 2>/dev/null`)).stdout;
+            if (decompressed) {
+                setHeaders();
+                res.send(decompressed);
+            }
+            else if (!res.headersSent) {
+                res.status(500).json({ success: false, error: 'Could not decompress file' });
+            }
+        }
+    }
     /**
      * Check if PM2 is installed on the remote server
      * Uses multiple detection methods for better reliability
@@ -246,91 +411,122 @@ class RemoteConnection extends events_1.EventEmitter {
         }
     }
     /**
-     * Execute a PM2 command with proper PATH handling
-     * Tries different methods to find and execute PM2
+     * Execute a PM2 command with proper PATH handling.
+     * The first successful invocation is cached so later calls (and streaming
+     * commands) reuse the same shell/binary path without re-probing.
      */
     async executePM2Command(pm2Args) {
-        const commands = [
-            `pm2 ${pm2Args}`, // Direct PM2 call
-            `bash -l -c "pm2 ${pm2Args}"`, // With login shell
-            `~/.npm-global/bin/pm2 ${pm2Args}`, // Common global npm path
-            `~/node_modules/.bin/pm2 ${pm2Args}`, // Local node_modules path
-            `/usr/local/bin/pm2 ${pm2Args}`, // System-wide installation
-            `npx pm2 ${pm2Args}` // Using npx as fallback
-        ];
+        // Fast path: reuse the builder we already know works on this host
+        if (this.resolvedBuilderIndex >= 0) {
+            return this.executeCommand(RemoteConnection.PM2_BUILDERS[this.resolvedBuilderIndex](pm2Args));
+        }
         let lastError = null;
-        for (const command of commands) {
+        for (let i = 0; i < RemoteConnection.PM2_BUILDERS.length; i++) {
+            const command = RemoteConnection.PM2_BUILDERS[i](pm2Args);
             try {
                 const result = await this.executeCommand(command);
                 if (result.code === 0) {
+                    this.resolvedBuilderIndex = i; // Cache for all future calls on this connection
+                    console.log(`[executePM2Command] Resolved pm2 via builder[${i}]: ${command.substring(0, 60)}`);
                     return result;
                 }
-                lastError = new Error(`Command failed with exit code ${result.code}: ${result.stderr}`);
+                lastError = new Error(`Command failed (code ${result.code}): ${result.stderr}`);
             }
             catch (error) {
                 lastError = error;
-                continue;
             }
         }
         throw lastError || new Error(`Failed to execute PM2 command: ${pm2Args}`);
     }
+    /**
+     * Build a pm2 command string using the already-resolved invocation pattern.
+     * Falls back to bash -li -c if the resolver has not yet run.
+     * Use this when you need the raw command string for a streaming shell exec.
+     */
+    buildPM2StreamCommand(pm2Args) {
+        if (this.resolvedBuilderIndex >= 0) {
+            return RemoteConnection.PM2_BUILDERS[this.resolvedBuilderIndex](pm2Args);
+        }
+        // Default: login+interactive shell covers .profile AND .bashrc (catches nvm)
+        return `bash -li -c "pm2 ${pm2Args}"`;
+    }
     /**
      * Get PM2 processes from the remote server
      */
     async getPM2Processes() {
+        if (!this._isConnected) {
+            await this.connect();
+        }
+        let result;
         try {
-            // Connect if not already connected
-            if (!this._isConnected) {
-                await this.connect();
-            }
-            // Check if PM2 is installed (force re-check if not cached)
-            const isPM2Installed = await this.checkPM2Installation();
-            if (!isPM2Installed) {
-                throw new Error('PM2 is not installed on the remote server. Please install PM2 globally using: npm install -g pm2');
-            }
-            // Update the cached status
+            // executePM2Command tries all known paths/shells before giving up
+            result = await this.executePM2Command('jlist');
             this.isPM2Installed = true;
-            const result = await this.executePM2Command('jlist');
-            // Clean the output to ensure it's valid JSON
-            // Sometimes pm2 jlist can include non-JSON data at the beginning or end
-            let cleanedOutput = result.stdout.trim();
-            // Find the beginning of the JSON array
-            const startIndex = cleanedOutput.indexOf('[');
-            // Find the end of the JSON array
-            const endIndex = cleanedOutput.lastIndexOf(']') + 1;
-            if (startIndex === -1 || endIndex === 0) {
-                console.log('Invalid PM2 output format, trying alternative approach');
-                // Try using pm2 list --format=json instead
-                const listResult = await this.executeCommand('pm2 list --format=json');
-                cleanedOutput = listResult.stdout.trim();
-            }
-            else if (startIndex > 0 || endIndex < cleanedOutput.length) {
-                // Extract just the JSON array part
-                cleanedOutput = cleanedOutput.substring(startIndex, endIndex);
-            }
-            try {
-                const processList = JSON.parse(cleanedOutput);
-                // Format process data similar to local PM2 format
-                return processList.map((proc) => ({
-                    name: proc.name,
-                    pm_id: proc.pm_id,
-                    status: proc.pm2_env ? proc.pm2_env.status : 'unknown',
-                    cpu: proc.monit ? (proc.monit.cpu || 0).toFixed(1) : '0.0',
-                    memory: proc.monit ? this.formatMemory(proc.monit.memory) : '0 B',
-                    uptime: proc.pm2_env ? this.formatUptime(proc.pm2_env.pm_uptime) : 'N/A',
-                    restarts: proc.pm2_env ? (proc.pm2_env.restart_time || 0) : 0
-                }));
-            }
-            catch (error) {
-                console.error('Error parsing PM2 process list:', error);
-                console.log('Raw output:', result.stdout);
-                // Return an empty array instead of throwing
-                return [];
-            }
+        }
+        catch (err) {
+            // All path attempts failed — PM2 is genuinely not found
+            console.error('Error getting PM2 processes:', err);
+            throw new Error('PM2 is not installed or not accessible on the remote server. Please install PM2 globally using: npm install -g pm2');
+        }
+        // Extract the JSON array from the output (pm2 jlist may include extra lines)
+        let cleanedOutput = result.stdout.trim();
+        const startIndex = cleanedOutput.indexOf('[');
+        const endIndex = cleanedOutput.lastIndexOf(']') + 1;
+        if (startIndex !== -1 && endIndex > 0) {
+            cleanedOutput = cleanedOutput.substring(startIndex, endIndex);
+        }
+        else {
+            console.log('Invalid PM2 jlist output, returning empty list. Raw:', result.stdout);
+            return [];
+        }
+        try {
+            const processList = JSON.parse(cleanedOutput);
+            // Return the full PM2 process shape (pm2_env + monit) so all frontend
+            // components work without modification when viewing a remote server.
+            return processList.map((proc) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+                return ({
+                    pid: proc.pid || 0,
+                    pm_id: proc.pm_id || 0,
+                    name: proc.name || '',
+                    monit: {
+                        cpu: proc.monit ? (proc.monit.cpu || 0) : 0,
+                        memory: proc.monit ? (proc.monit.memory || 0) : 0,
+                    },
+                    pm2_env: {
+                        // identity
+                        pm_id: proc.pm_id || 0,
+                        name: proc.name || '',
+                        namespace: ((_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a.namespace) || 'default',
+                        version: ((_b = proc.pm2_env) === null || _b === void 0 ? void 0 : _b.version) || '',
+                        versioning: ((_c = proc.pm2_env) === null || _c === void 0 ? void 0 : _c.versioning) || null,
+                        // timing
+                        pm_uptime: ((_d = proc.pm2_env) === null || _d === void 0 ? void 0 : _d.pm_uptime) || 0,
+                        created_at: ((_e = proc.pm2_env) === null || _e === void 0 ? void 0 : _e.created_at) || 0,
+                        // paths
+                        pm_cwd: ((_f = proc.pm2_env) === null || _f === void 0 ? void 0 : _f.pm_cwd) || '',
+                        pm_exec_path: ((_g = proc.pm2_env) === null || _g === void 0 ? void 0 : _g.pm_exec_path) || '',
+                        pm_out_log_path: ((_h = proc.pm2_env) === null || _h === void 0 ? void 0 : _h.pm_out_log_path) || '',
+                        pm_err_log_path: ((_j = proc.pm2_env) === null || _j === void 0 ? void 0 : _j.pm_err_log_path) || '',
+                        // runtime
+                        exec_interpreter: ((_k = proc.pm2_env) === null || _k === void 0 ? void 0 : _k.exec_interpreter) || 'node',
+                        exec_mode: ((_l = proc.pm2_env) === null || _l === void 0 ? void 0 : _l.exec_mode) || 'fork',
+                        instances: ((_m = proc.pm2_env) === null || _m === void 0 ? void 0 : _m.instances) || 1,
+                        node_args: ((_o = proc.pm2_env) === null || _o === void 0 ? void 0 : _o.node_args) || [],
+                        status: ((_p = proc.pm2_env) === null || _p === void 0 ? void 0 : _p.status) || 'unknown',
+                        restart_time: ((_q = proc.pm2_env) === null || _q === void 0 ? void 0 : _q.restart_time) || 0,
+                        unstable_restarts: ((_r = proc.pm2_env) === null || _r === void 0 ? void 0 : _r.unstable_restarts) || 0,
+                        autorestart: (_t = (_s = proc.pm2_env) === null || _s === void 0 ? void 0 : _s.autorestart) !== null && _t !== void 0 ? _t : true,
+                        watch: ((_u = proc.pm2_env) === null || _u === void 0 ? void 0 : _u.watch) || false,
+                        env: ((_v = proc.pm2_env) === null || _v === void 0 ? void 0 : _v.env) || {},
+                    },
+                });
+            });
         }
         catch (error) {
-            console.error('Error getting PM2 processes:', error);
-            throw error;
+            console.error('Error parsing PM2 process list:', error);
+            console.log('Raw output:', result.stdout);
+            return [];
         }
     }
     /**
@@ -506,14 +702,11 @@ class RemoteConnection extends events_1.EventEmitter {
         if (!this._isConnected) {
             throw new Error('Connection not established');
         }
-        let finalCommand = command;
+        // Use sudo -S so sudo reads the password from stdin rather than the shell command line
+        const useSudoAuth = useSudo && this.config.useSudo && !!this.config.password;
+        const finalCommand = useSudoAuth ? `sudo -S ${command}` : command;
         let isInitialized = false;
-        // Apply sudo if requested and we have a password
-        if (useSudo && this.config.useSudo && this.config.password) {
-            // Use echo to pipe the password to sudo for streaming commands
-            finalCommand = `echo '${this.config.password}' | sudo -S ${command}`;
-        }
-        console.log(`[createLogStream] Executing command: ${finalCommand.replace(this.config.password || '', '[PASSWORD]')}`);
+        console.log(`[createLogStream] Executing command: ${useSudoAuth ? '[sudo] ' : ''}${command}`);
         return new Promise((resolve, reject) => {
             this.client.exec(finalCommand, (err, stream) => {
                 var _a;
@@ -522,6 +715,10 @@ class RemoteConnection extends events_1.EventEmitter {
                     reject(err);
                     return;
                 }
+                // Write password to sudo's stdin (do not close stdin — stream must stay open)
+                if (useSudoAuth && this.config.password) {
+                    stream.stdin.write(this.config.password + '\n');
+                }
                 const logEmitter = new events_1.EventEmitter();
                 stream.on('data', (data) => {
                     const dataStr = data.toString();
@@ -566,6 +763,37 @@ class RemoteConnection extends events_1.EventEmitter {
     }
 }
 exports.RemoteConnection = RemoteConnection;
+/**
+ * Stream a remote file directly into an HTTP response without buffering.
+ *
+ * Strategy (tried in order):
+ *   1. SFTP createReadStream  — best; handles large files, uses file-transfer protocol
+ *   2. exec `cat <file>`      — current SSH user, direct pipe to response
+ *   3. exec `sudo -S cat`     — password-based sudo (when password auth is configured)
+ *   4. exec `sudo cat`        — NOPASSWD sudo (key-based auth where sudo needs no password)
+ */
+// @group Security : Shell metacharacter allowlist for remote file paths
+RemoteConnection.SHELL_UNSAFE = /['"`$|&;<>(){}\\\n\r\0]/;
+/**
+ * Ordered list of command builders tried when resolving the pm2 binary.
+ * The index of the first successful builder is cached so that subsequent
+ * calls (including streaming commands) reuse the same invocation.
+ */
+RemoteConnection.PM2_BUILDERS = [
+    args => `pm2 ${args}`,
+    args => `bash -l -c "pm2 ${args}"`,
+    args => `bash -i -c "pm2 ${args}"`,
+    args => `bash -li -c "pm2 ${args}"`,
+    args => `/usr/local/bin/pm2 ${args}`,
+    args => `/usr/bin/pm2 ${args}`,
+    args => `~/.npm-global/bin/pm2 ${args}`,
+    args => `~/.npm/bin/pm2 ${args}`,
+    args => `~/node_modules/.bin/pm2 ${args}`,
+    args => `. ~/.nvm/nvm.sh && pm2 ${args}`,
+    args => `. ~/.nvm/nvm.sh && nvm use --lts && pm2 ${args}`,
+    args => `. /usr/share/nvm/init-nvm.sh && pm2 ${args}`,
+    args => `npx pm2 ${args}`,
+];
 /**
  * Connection manager to handle multiple remote connections
  */

package/package.json

@@ -1,69 +1,73 @@
-{
-  "name": "ezpm2gui",
-  "version": "1.3.2",
-  "main": "dist/server/index.js",
-  "bin": {
-    "ezpm2gui": "bin/ezpm2gui.js",
-    "ezpm2gui-generate-ecosystem": "bin/generate-ecosystem.js"
-  },
-  "scripts": {
-    "start": "node dist/server/index.js",
-    "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\"",
-    "dev:server": "nodemon --exec ts-node src/server/index.ts",
-    "dev:client": "cd src/client && npm start",
-    "build": "node scripts/build.js",
-    "build:server": "tsc",
-    "build:client": "cd src/client && npm run build",
-    "build:bin": "tsc --project tsconfig.bin.json",
-    "prepare": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "postinstall": "node scripts/postinstall.js"
-  },
-  "keywords": [
-    "pm2",
-    "gui",
-    "monitor",
-    "process-manager",
-    "dashboard"
-  ],
-  "author": "Chandan Bhagat",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/thechandanbhagat/ezpm2gui.git"
-  },
-  "description": "A modern web-based GUI for PM2 process manager",
-  "files": [
-    "dist/",
-    "bin/",
-    "src/client/build/",
-    "scripts/postinstall.js"
-  ],
-  "dependencies": {
-    "@tailwindcss/postcss": "^4.1.14",
-    "@types/node-cron": "^3.0.11",
-    "axios": "^1.9.0",
-    "chart.js": "^4.4.9",
-    "cron-parser": "^5.4.0",
-    "express": "^4.18.3",
-    "node-cron": "^4.2.1",
-    "pm2": "^6.0.5",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "react-scripts": "^5.0.1",
-    "socket.io": "^4.8.1",
-    "ssh2": "^1.16.0"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/node": "^22.15.17",
-    "@types/react": "^19.1.4",
-    "@types/react-dom": "^19.1.5",
-    "@types/socket.io": "^3.0.2",
-    "@types/ssh2": "^1.15.5",
-    "concurrently": "^9.1.2",
-    "nodemon": "^3.1.10",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
-  }
-}
+{
+  "name": "ezpm2gui",
+  "version": "1.5.0",
+  "main": "dist/server/index.js",
+  "bin": {
+    "ezpm2gui": "bin/ezpm2gui.js",
+    "ezpm2gui-generate-ecosystem": "bin/generate-ecosystem.js"
+  },
+  "scripts": {
+    "start": "node dist/server/index.js",
+    "dev": "concurrently --kill-others-on-fail --names \"server,client\" --prefix-colors \"cyan,green\" \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:server": "nodemon --exec ts-node src/server/index.ts",
+    "dev:client": "cd src/client && npm run dev",
+    "build": "node scripts/build.js",
+    "build:server": "tsc",
+    "build:client": "cd src/client && npm run build",
+    "build:bin": "tsc --project tsconfig.bin.json",
+    "prepare": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "pm2",
+    "gui",
+    "monitor",
+    "process-manager",
+    "dashboard"
+  ],
+  "author": "Chandan Bhagat",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thechandanbhagat/ezpm2gui.git"
+  },
+  "description": "A modern web-based GUI for PM2 process manager",
+  "files": [
+    "dist/",
+    "bin/",
+    "src/client/build/",
+    "scripts/postinstall.js"
+  ],
+  "dependencies": {
+    "@tailwindcss/postcss": "^4.1.14",
+    "@types/node-cron": "^3.0.11",
+    "axios": "^1.9.0",
+    "dotenv": "^16.5.0",
+    "chart.js": "^4.4.9",
+    "cron-parser": "^5.4.0",
+    "express": "^4.18.3",
+    "node-cron": "^4.2.1",
+    "pm2": "^6.0.5",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-scripts": "^5.0.1",
+    "socket.io": "^4.8.1",
+    "ssh2": "^1.16.0",
+    "uuid": "^11.0.5"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.15.17",
+    "@types/react": "^19.1.4",
+    "@types/react-dom": "^19.1.5",
+    "@types/socket.io": "^3.0.2",
+    "@types/ssh2": "^1.15.5",
+    "@types/uuid": "^10.0.0",
+    "concurrently": "^9.1.2",
+    "cross-env": "^10.1.0",
+    "nodemon": "^3.1.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}