ezpm2gui 1.3.1 → 1.4.0

package/dist/server/index.js

@@ -29,7 +29,16 @@ function createServer() {
         cors: {
             origin: '*',
             methods: ['GET', 'POST']
-        }
+        },
+        // Increase ping timeout to prevent false positive disconnections
+        pingTimeout: 10000, // How long to wait for a pong response (default: 5000ms)
+        pingInterval: 25000, // How often to send ping packets (default: 25000ms)
+        // Allow reconnection attempts
+        allowEIO3: true,
+        // Transport configuration
+        transports: ['websocket', 'polling'],
+        // Upgrade timeout
+        upgradeTimeout: 10000
     });
     // Configure middleware
     app.use(express_1.default.json());
@@ -73,42 +82,36 @@ function createServer() {
         }
     });
     // Action endpoints (start, stop, restart, delete)
-    app.post('/api/process/:id/:action', (req, res) => {
+    app.post('/api/process/:id/:action', async (req, res) => {
         const { id, action } = req.params;
-        pm2_1.default.connect((err) => {
-            if (err) {
-                console.error(err);
-                res.status(500).json({ error: 'Failed to connect to PM2' });
-                return;
-            }
-            const processAction = (actionName, cb) => {
-                switch (actionName) {
+        const validActions = ['start', 'stop', 'restart', 'delete'];
+        if (!validActions.includes(action)) {
+            res.status(400).json({ error: 'Invalid action' });
+            return;
+        }
+        try {
+            await (0, pm2_connection_1.executePM2Command)((callback) => {
+                switch (action) {
                     case 'start':
-                        pm2_1.default.start(id, cb);
+                        pm2_1.default.start(id, callback);
                         break;
                     case 'stop':
-                        pm2_1.default.stop(id, cb);
+                        pm2_1.default.stop(id, callback);
                         break;
                     case 'restart':
-                        pm2_1.default.restart(id, cb);
+                        pm2_1.default.restart(id, callback);
                         break;
                     case 'delete':
-                        pm2_1.default.delete(id, cb);
+                        pm2_1.default.delete(id, callback);
                         break;
-                    default:
-                        cb(new Error('Invalid action'));
-                }
-            };
-            processAction(action, (err) => {
-                pm2_1.default.disconnect();
-                if (err) {
-                    console.error(err);
-                    res.status(500).json({ error: `Failed to ${action} process` });
-                    return;
                 }
-                res.json({ success: true, message: `Process ${id} ${action} request received` });
             });
-        });
+            res.json({ success: true, message: `Process ${id} ${action} request received` });
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: `Failed to ${action} process` });
+        }
     });
     // Get system metrics
     app.get('/api/metrics', (req, res) => {
@@ -125,75 +128,58 @@ function createServer() {
         res.json(metrics);
     });
     // Get process logs
-    app.get('/api/logs/:id/:type', (req, res) => {
+    app.get('/api/logs/:id/:type', async (req, res) => {
+        var _a, _b;
         const { id, type } = req.params;
         const logType = type === 'err' ? 'err' : 'out';
-        pm2_1.default.connect((err) => {
-            if (err) {
-                console.error(err);
-                res.status(500).json({ error: 'Failed to connect to PM2' });
+        try {
+            const processDesc = await (0, pm2_connection_1.executePM2Command)((callback) => {
+                pm2_1.default.describe(id, callback);
+            });
+            if (!processDesc || processDesc.length === 0) {
+                res.status(404).json({ error: 'Process not found' });
                 return;
             }
-            pm2_1.default.describe(id, (err, processDesc) => {
-                var _a, _b;
-                if (err || !processDesc || processDesc.length === 0) {
-                    pm2_1.default.disconnect();
-                    res.status(404).json({ error: 'Process not found' });
-                    return;
-                }
-                const logPath = (_b = (_a = processDesc[0]) === null || _a === void 0 ? void 0 : _a.pm2_env) === null || _b === void 0 ? void 0 : _b[`pm_${logType}_log_path`];
-                if (!logPath) {
-                    pm2_1.default.disconnect();
-                    res.status(404).json({ error: `Log file for ${logType} not found` });
-                    return;
-                }
-                try {
-                    // Read the log file using Node.js fs instead of exec
-                    const fs = require('fs');
-                    let logContent = '';
-                    if (fs.existsSync(logPath)) {
-                        // Read the last part of the file (up to 10KB to avoid huge responses)
-                        const stats = fs.statSync(logPath);
-                        const fileSize = stats.size;
-                        const readSize = Math.min(fileSize, 10 * 1024); // 10KB max
-                        const position = Math.max(0, fileSize - readSize);
-                        const buffer = Buffer.alloc(readSize);
-                        const fd = fs.openSync(logPath, 'r');
-                        fs.readSync(fd, buffer, 0, readSize, position);
-                        fs.closeSync(fd);
-                        logContent = buffer.toString('utf8');
-                    }
-                    const logs = logContent.split('\n').filter((line) => line.trim() !== '');
-                    pm2_1.default.disconnect();
-                    res.json({ logs });
-                }
-                catch (error) {
-                    console.error(`Error reading log file: ${error}`);
-                    pm2_1.default.disconnect();
-                    res.status(500).json({ error: 'Failed to read log file' });
-                }
-            });
-        });
+            const logPath = (_b = (_a = processDesc[0]) === null || _a === void 0 ? void 0 : _a.pm2_env) === null || _b === void 0 ? void 0 : _b[`pm_${logType}_log_path`];
+            if (!logPath) {
+                res.status(404).json({ error: `Log file for ${logType} not found` });
+                return;
+            }
+            const fs = require('fs');
+            let logContent = '';
+            if (fs.existsSync(logPath)) {
+                const stats = fs.statSync(logPath);
+                const fileSize = stats.size;
+                const readSize = Math.min(fileSize, 10 * 1024); // 10KB max
+                const position = Math.max(0, fileSize - readSize);
+                const buffer = Buffer.alloc(readSize);
+                const fd = fs.openSync(logPath, 'r');
+                fs.readSync(fd, buffer, 0, readSize, position);
+                fs.closeSync(fd);
+                logContent = buffer.toString('utf8');
+            }
+            const logs = logContent.split('\n').filter((line) => line.trim() !== '');
+            res.json({ logs });
+        }
+        catch (err) {
+            console.error(`Error reading log file: ${err}`);
+            res.status(500).json({ error: 'Failed to read log file' });
+        }
     });
     // WebSocket for real-time updates
     io.on('connection', (socket) => {
         console.log('Client connected');
-        // Send process updates every 3 seconds
-        const processInterval = setInterval(() => {
-            pm2_1.default.connect((err) => {
-                if (err) {
-                    console.error(err);
-                    return;
-                }
-                pm2_1.default.list((err, processList) => {
-                    pm2_1.default.disconnect();
-                    if (err) {
-                        console.error(err);
-                        return;
-                    }
-                    socket.emit('processes', processList);
+        // Send process updates every 3 seconds using shared pooled connection
+        const processInterval = setInterval(async () => {
+            try {
+                const processList = await (0, pm2_connection_1.executePM2Command)((callback) => {
+                    pm2_1.default.list(callback);
                 });
-            });
+                socket.emit('processes', processList);
+            }
+            catch (err) {
+                console.error('Failed to list PM2 processes:', err);
+            }
         }, 3000);
         // Send system metrics every 2 seconds
         const metricsInterval = setInterval(() => {

package/dist/server/routes/logStreaming.js

@@ -38,8 +38,8 @@ const getLogStream = (io, processId, logType) => {
             tail.stdout.on('data', (data) => {
                 const lines = data.toString().split('\n').filter((line) => line.trim() !== '');
                 lines.forEach((line) => {
-                    // Emit log line to all connected clients
-                    io.emit('log-line', {
+                    // Emit only to clients subscribed to this specific log stream
+                    io.to(streamKey).emit('log-line', {
                         processId,
                         logType,
                         line
@@ -70,17 +70,23 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
     if (!connection || !connection.isConnected()) {
         throw new Error('Connection not found or not connected');
     }
-    // Get process info to find log paths
+    // Get process info using the multi-path fallback so pm2 is found regardless of PATH
     console.log(`Getting process info for: ${processId}`);
-    const processInfoResult = await connection.executeCommand(`pm2 jlist`, false); // Don't use sudo for listing
+    const processInfoResult = await connection.executePM2Command('jlist');
     if (processInfoResult.code !== 0) {
         throw new Error(`Failed to get process list: ${processInfoResult.stderr}`);
     }
+    // Extract JSON from output (pm2 jlist may prefix with non-JSON lines)
+    let rawOutput = processInfoResult.stdout.trim();
+    const startIdx = rawOutput.indexOf('[');
+    const endIdx = rawOutput.lastIndexOf(']') + 1;
+    if (startIdx !== -1 && endIdx > 0) {
+        rawOutput = rawOutput.substring(startIdx, endIdx);
+    }
     let processInfo;
     try {
-        const processList = JSON.parse(processInfoResult.stdout);
+        const processList = JSON.parse(rawOutput);
         console.log(`Found ${processList.length} processes`);
-        // Find the process by ID
         processInfo = processList.find((proc) => proc.pm_id === parseInt(processId));
         if (!processInfo) {
             throw new Error(`Process with ID ${processId} not found`);
@@ -96,10 +102,10 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
     const streams = {};
     try {
         console.log(`Setting up pm2 logs stream for process: ${processName} (ID: ${processId})`);
-        // Use pm2 logs with --lines 0 --raw to stream only new logs
-        // Use sudo since PM2 processes are running as root
-        const pm2LogsCommand = `pm2 logs ${processId} --lines 0 --raw`;
-        console.log(`About to create pm2 log stream with command: ${pm2LogsCommand} (using sudo)`);
+        // Use the resolved pm2 invocation (cached from the jlist call above) so the
+        // same shell/path that successfully ran pm2 jlist is reused here.
+        const pm2LogsCommand = connection.buildPM2StreamCommand(`logs ${processId} --lines 0 --raw`);
+        console.log(`About to create pm2 log stream with command: ${pm2LogsCommand}`);
         const logStream = await connection.createLogStream(pm2LogsCommand, true);
         console.log(`Successfully created pm2 logs stream for ${processName}`);
         logStream.on('data', (data) => {
@@ -154,7 +160,8 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
                     cleanLine = logMatch[1];
                 }
                 console.log(`Emitting remote-log-line for ${connectionId}-${processId} (${logType}):`, cleanLine);
-                io.emit('remote-log-line', {
+                // Emit only to clients subscribed to this specific remote log stream
+                io.to(streamKey).emit('remote-log-line', {
                     connectionId,
                     processId,
                     processName,
@@ -165,7 +172,7 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
         });
         logStream.on('error', (error) => {
             console.error(`Error in pm2 logs stream for ${processName}:`, error);
-            io.emit('remote-log-error', {
+            io.to(streamKey).emit('remote-log-error', {
                 connectionId,
                 processId,
                 processName,
@@ -179,7 +186,7 @@ const getRemoteLogStream = async (io, connectionId, processId) => {
     }
     catch (error) {
         console.error(`Failed to create pm2 logs stream for ${processName}:`, error);
-        io.emit('remote-log-error', {
+        io.to(streamKey).emit('remote-log-error', {
             connectionId,
             processId,
             processName,

package/dist/server/routes/modules.js

@@ -1,106 +1,126 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const child_process_1 = require("child_process");
+const pm2_1 = __importDefault(require("pm2"));
+const pm2_connection_1 = require("../utils/pm2-connection");
 const router = (0, express_1.Router)();
-// List installed modules
-router.get('/', (req, res) => {
-    const pm2Command = (0, child_process_1.spawn)('pm2', ['module:list']);
-    let output = '';
-    let errorOutput = '';
-    pm2Command.stdout.on('data', (data) => {
-        output += data.toString();
-    });
-    pm2Command.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-    });
-    pm2Command.on('close', (code) => {
+// @group Utilities : Resolve pm2 binary path via shell
+const runPM2CLI = (args) => new Promise((resolve, reject) => {
+    var _a, _b;
+    // Use shell so the OS resolves the global pm2 binary from PATH
+    const child = (0, child_process_1.exec)(`pm2 ${args}`);
+    let out = '';
+    let err = '';
+    (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (d) => { out += d.toString(); });
+    (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (d) => { err += d.toString(); });
+    child.on('close', (code) => {
         if (code !== 0) {
-            return res.status(500).json({
-                error: 'Failed to list PM2 modules',
-                details: errorOutput
-            });
+            reject(new Error(err || `pm2 exited with code ${code}`));
+        }
+        else {
+            resolve({ stdout: out, stderr: err });
         }
-        // Parse the output to get module information
+    });
+    child.on('error', (e) => reject(e));
+});
+// @group APIEndpoints : List installed PM2 modules
+router.get('/', async (_req, res) => {
+    try {
+        // Use PM2 Node.js API — modules appear as regular processes with module metadata
+        const processList = await (0, pm2_connection_1.executePM2Command)((cb) => pm2_1.default.list(cb));
+        // PM2 modules have pm2_env.pmx_module === true
+        const modules = processList
+            .filter((proc) => { var _a; return ((_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a.pmx_module) === true; })
+            .map((proc) => {
+            var _a, _b, _c;
+            return ({
+                name: proc.name,
+                version: ((_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a.version) || ((_b = proc.pm2_env) === null || _b === void 0 ? void 0 : _b.MODULE_VERSION) || 'N/A',
+                status: ((_c = proc.pm2_env) === null || _c === void 0 ? void 0 : _c.status) || 'unknown',
+                pid: proc.pid,
+                pm_id: proc.pm_id,
+            });
+        });
+        res.json(modules);
+    }
+    catch (error) {
+        // Fallback: parse pm2 module:list CLI output
         try {
-            const moduleLines = output.split('\n').filter(line => line.includes('│') && !line.includes('Module') && line.trim() !== '');
-            const modules = moduleLines.map(line => {
+            const { stdout } = await runPM2CLI('module:list');
+            const moduleLines = stdout
+                .split('\n')
+                .filter(line => line.includes('│') && !line.includes('Module') && line.trim() !== '');
+            const modules = moduleLines
+                .map(line => {
                 const parts = line.split('│').map(part => part.trim()).filter(Boolean);
                 if (parts.length >= 3) {
-                    return {
-                        name: parts[0],
-                        version: parts[1],
-                        status: parts[2]
-                    };
+                    return { name: parts[0], version: parts[1], status: parts[2] };
                 }
                 return null;
-            }).filter(Boolean);
+            })
+                .filter(Boolean);
             res.json(modules);
         }
-        catch (error) {
+        catch (fallbackError) {
             res.status(500).json({
-                error: 'Failed to parse PM2 modules',
-                details: error
+                error: 'Failed to list PM2 modules',
+                details: fallbackError.message
             });
         }
-    });
+    }
 });
-// Install a module
-router.post('/install', (req, res) => {
+// @group APIEndpoints : Install a PM2 module
+router.post('/install', async (req, res) => {
     const { moduleName } = req.body;
     if (!moduleName) {
         return res.status(400).json({ error: 'Module name is required' });
     }
-    const pm2Command = (0, child_process_1.spawn)('pm2', ['install', moduleName]);
-    let output = '';
-    let errorOutput = '';
-    pm2Command.stdout.on('data', (data) => {
-        output += data.toString();
-    });
-    pm2Command.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-    });
-    pm2Command.on('close', (code) => {
-        if (code !== 0) {
-            return res.status(500).json({
-                error: `Failed to install module: ${moduleName}`,
-                details: errorOutput
-            });
-        }
+    // Basic validation — only allow alphanumeric, @, /, -, .
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    try {
+        const { stdout } = await runPM2CLI(`install ${moduleName}`);
         res.json({
             success: true,
             message: `Successfully installed module: ${moduleName}`,
-            details: output
+            details: stdout
         });
-    });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: `Failed to install module: ${moduleName}`,
+            details: error.message
+        });
+    }
 });
-// Uninstall a module
-router.delete('/:moduleName', (req, res) => {
+// @group APIEndpoints : Uninstall a PM2 module
+router.delete('/:moduleName', async (req, res) => {
     const { moduleName } = req.params;
     if (!moduleName) {
         return res.status(400).json({ error: 'Module name is required' });
     }
-    const pm2Command = (0, child_process_1.spawn)('pm2', ['uninstall', moduleName]);
-    let output = '';
-    let errorOutput = '';
-    pm2Command.stdout.on('data', (data) => {
-        output += data.toString();
-    });
-    pm2Command.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-    });
-    pm2Command.on('close', (code) => {
-        if (code !== 0) {
-            return res.status(500).json({
-                error: `Failed to uninstall module: ${moduleName}`,
-                details: errorOutput
-            });
-        }
+    // Basic validation
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    try {
+        const { stdout } = await runPM2CLI(`uninstall ${moduleName}`);
         res.json({
             success: true,
             message: `Successfully uninstalled module: ${moduleName}`,
-            details: output
+            details: stdout
         });
-    });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: `Failed to uninstall module: ${moduleName}`,
+            details: error.message
+        });
+    }
 });
 exports.default = router;

package/dist/server/routes/remoteConnections.js

@@ -20,14 +20,11 @@ router.post('/:connectionId/connect', async (req, res) => {
                 error: 'Connection not found'
             });
         }
-        // Connect to the remote server
+        // Establish the SSH connection only — PM2 detection happens lazily
+        // when processes are first requested, avoiding a slow multi-command
+        // pre-check that causes browser timeouts on the connect button.
         await connection.connect();
-        // Check if PM2 is installed
-        const isPM2Installed = await connection.checkPM2Installation();
-        res.json({
-            success: true,
-            isPM2Installed
-        });
+        res.json({ success: true });
     }
     catch (error) {
         console.error('Connection error:', error);
@@ -481,29 +478,36 @@ router.get('/:connectionId/logs/:processId', async (req, res) => {
                 success: false,
                 error: 'Connection not established'
             });
-        } // Get log paths from PM2 process info
-        const processInfoResult = await connection.executeCommand(`pm2 show ${processId} --json`);
+        }
+        // Get log paths from PM2 process info — use the PATH-fallback executor so
+        // pm2 is found regardless of the remote shell environment (nvm, npm-global, etc.)
+        const processInfoResult = await connection.executePM2Command('jlist');
         if (processInfoResult.code !== 0) {
             return res.status(500).json({
                 success: false,
-                error: 'Failed to get process info'
+                error: 'Failed to get PM2 process list'
             });
         }
         let processInfo;
         try {
-            processInfo = JSON.parse(processInfoResult.stdout);
-            if (!Array.isArray(processInfo) || processInfo.length === 0) {
+            let raw = processInfoResult.stdout.trim();
+            const start = raw.indexOf('[');
+            const end = raw.lastIndexOf(']') + 1;
+            if (start !== -1 && end > 0)
+                raw = raw.substring(start, end);
+            const processList = JSON.parse(raw);
+            processInfo = processList.find((p) => p.pm_id === parseInt(processId, 10) || p.name === processId);
+            if (!processInfo) {
                 return res.status(404).json({
                     success: false,
                     error: 'Process not found'
                 });
             }
-            processInfo = processInfo[0];
         }
         catch (parseError) {
             return res.status(500).json({
                 success: false,
-                error: 'Failed to parse process info'
+                error: 'Failed to parse PM2 process list'
             });
         }
         const outLogPath = (_a = processInfo.pm2_env) === null || _a === void 0 ? void 0 : _a.pm_out_log_path;
@@ -561,7 +565,7 @@ router.get('/connections', async (req, res) => {
             host: conn.host,
             port: conn.port,
             username: conn.username,
-            isConnected: conn.isConnected(),
+            connected: conn.isConnected(),
             isPM2Installed: conn.isPM2Installed
         }));
         res.json(connectionsList);
@@ -711,29 +715,4 @@ router.post('/:connectionId/install-pm2', async (req, res) => {
         });
     }
 });
-/**
- * Delete a connection configuration
- * DELETE /api/remote/connections/:connectionId
- */
-router.delete('/connections/:connectionId', async (req, res) => {
-    try {
-        const { connectionId } = req.params;
-        // Disconnect if connected
-        await remote_connection_1.remoteConnectionManager.closeConnection(connectionId);
-        // Delete the connection from the manager
-        const success = remote_connection_1.remoteConnectionManager.deleteConnection(connectionId);
-        if (success) {
-            res.json({ success: true, message: 'Connection deleted' });
-        }
-        else {
-            res.status(404).json({ success: false, error: 'Connection not found' });
-        }
-    }
-    catch (error) {
-        res.status(500).json({
-            success: false,
-            error: `Server error: ${error.message}`
-        });
-    }
-});
 exports.default = router;

package/dist/server/utils/encryption.js

@@ -44,29 +44,17 @@ function encrypt(text) {
 function decrypt(encryptedText) {
     if (!encryptedText)
         return '';
-    // Special handling for manually entered passwords in the config file
-    if (encryptedText === '11342b0ca35d70c17955d874e5d4b0a26547521f705a6f74320b5d7bfeb56369') {
-        console.log('Using hardcoded credential for specific password hash');
-        return 'test1234';
-    }
     try {
-        console.log(`Attempting to decrypt: ${encryptedText.substring(0, 10)}...`);
         // Ensure key and IV are the correct length
         const key = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_KEY)).digest('base64').slice(0, 32);
         const iv = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_IV)).digest('base64').slice(0, 16);
         const decipher = crypto_1.default.createDecipheriv(ALGORITHM, key, iv);
         let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
         decrypted += decipher.final('utf8');
-        console.log('Decryption successful');
         return decrypted;
     }
     catch (error) {
         console.error('Decryption error:', error);
-        // For development only - return a value even if decryption fails
-        if (encryptedText && encryptedText.length > 10) {
-            console.log('Returning fallback credential for development');
-            return 'test1234';
-        }
         return '';
     }
 }

package/dist/server/utils/pm2-connection.d.ts

@@ -13,4 +13,4 @@ export declare const disconnectFromPM2: () => Promise<void>;
  * This will connect to PM2 if needed, run the command,
  * and properly handle the result
  */
-export declare const executePM2Command: <T>(command: (callback: (err: Error | null, result?: T) => void) => void) => Promise<T>;
+export declare const executePM2Command: <T = any>(command: (callback: (err: Error | null, result?: T) => void) => void) => Promise<T>;

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

@@ -103,6 +103,7 @@ exports.disconnectFromPM2 = disconnectFromPM2;
  * This will connect to PM2 if needed, run the command,
  * and properly handle the result
  */
+// @group ConnectionPool : Execute a PM2 command using the shared pooled connection
 const executePM2Command = async (command) => {
     try {
         await (0, exports.connectToPM2)();
@@ -111,9 +112,6 @@ const executePM2Command = async (command) => {
                 if (err) {
                     reject(err);
                 }
-                else if (result === undefined) {
-                    reject(new Error('PM2 command returned undefined result'));
-                }
                 else {
                     resolve(result);
                 }