ezpm2gui 1.3.2 → 1.5.0

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

@@ -6,6 +6,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
 const remote_connection_1 = require("../utils/remote-connection");
 const router = express_1.default.Router();
+// @group Security : Validate remote log file paths before shell interpolation
+const SHELL_UNSAFE_CHARS = /['"`;$|&<>(){}\\\n\r\0]/;
+const MAX_LOG_LINES = 10000;
+const validateRemotePath = (filePath) => {
+    if (!filePath)
+        return false;
+    if (filePath.includes('..'))
+        return false;
+    if (SHELL_UNSAFE_CHARS.test(filePath))
+        return false;
+    if (!/\.(log|gz)$/i.test(filePath))
+        return false;
+    return true;
+};
+const safeLogLines = (raw) => {
+    const n = parseInt(raw || '200', 10);
+    if (!Number.isFinite(n) || n < 0)
+        return 200;
+    return Math.min(n, MAX_LOG_LINES);
+};
 /**
  * Connect to an existing remote server
  * POST /api/remote/:connectionId/connect
@@ -20,14 +40,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 +498,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;
@@ -548,6 +572,246 @@ router.get('/:connectionId/logs/:processId', async (req, res) => {
         });
     }
 });
+// @group LogHistory : Helper — resolve log path for a given process on a remote connection
+const resolveRemoteLogPath = async (connection, processId, logType) => {
+    var _a, _b;
+    const processInfoResult = await connection.executePM2Command('jlist');
+    if (processInfoResult.code !== 0)
+        return { logPath: null, error: 'Failed to get PM2 process list' };
+    try {
+        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);
+        const proc = processList.find((p) => p.pm_id === parseInt(processId, 10) || p.name === processId);
+        if (!proc)
+            return { logPath: null, error: 'Process not found' };
+        const key = logType === 'out' ? 'pm_out_log_path' : 'pm_err_log_path';
+        return { logPath: (_b = (_a = proc.pm2_env) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : null };
+    }
+    catch {
+        return { logPath: null, error: 'Failed to parse PM2 process list' };
+    }
+};
+/**
+ * Get log lines from a specific log type on a remote process — ?lines=N (default 200, 0 = all)
+ * GET /api/remote/:connectionId/logs/:processId/:type
+ */
+router.get('/:connectionId/logs/:processId/:type', async (req, res) => {
+    var _a;
+    try {
+        const { connectionId, processId, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        const lines = safeLogLines(req.query.lines);
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const { logPath, error } = await resolveRemoteLogPath(connection, processId, logType);
+        if (!logPath)
+            return res.status(404).json({ success: false, error: error || 'Log path not found' });
+        // tail -n 0 = all lines; use wc -l to get total count alongside
+        const lineArg = lines === 0 ? '+1' : `-${lines}`;
+        const cmd = `{ wc -l < "${logPath}" 2>/dev/null || echo 0; } && tail -n ${lineArg} "${logPath}" 2>/dev/null`;
+        let result = await connection.executeCommand(cmd);
+        // Fallback to sudo if the file is unreadable (root-owned logs)
+        if (result.code !== 0 || !result.stdout.trim()) {
+            result = await connection.executeCommand(`{ sudo wc -l < "${logPath}" 2>/dev/null || echo 0; } && sudo tail -n ${lineArg} "${logPath}" 2>/dev/null`);
+        }
+        const outputLines = result.stdout.split('\n');
+        const totalLines = parseInt(((_a = outputLines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || '0', 10);
+        const logLines = outputLines.slice(1).filter((l) => l.trim() !== '');
+        res.json({ logs: logLines, logPath, totalLines });
+    }
+    catch (error) {
+        console.error('Error fetching remote log history:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Download full log file from a remote process via SSH
+ * GET /api/remote/:connectionId/logs/:processId/:type/download
+ */
+router.get('/:connectionId/logs/:processId/:type/download', async (req, res) => {
+    try {
+        const { connectionId, processId, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const { logPath, error } = await resolveRemoteLogPath(connection, processId, logType);
+        if (!logPath)
+            return res.status(404).json({ success: false, error: error || 'Log path not found' });
+        const fileName = `${processId}-${logType}.log`;
+        await connection.streamFileToResponse(logPath, res, fileName);
+    }
+    catch (error) {
+        console.error('Error downloading remote log:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+        }
+    }
+});
+/**
+ * List all log files (current + rotated) for a remote process
+ * GET /api/remote/:connectionId/log-files/:processId
+ * Uses /log-files/ prefix to avoid Express matching /:processId/:type with type='files'
+ */
+router.get('/:connectionId/log-files/:processId', async (req, res) => {
+    try {
+        const { connectionId, processId } = req.params;
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        // Resolve both log paths so we know the directory and base name
+        const { logPath: outPath } = await resolveRemoteLogPath(connection, processId, 'out');
+        const { logPath: errPath } = await resolveRemoteLogPath(connection, processId, 'err');
+        if (!outPath && !errPath) {
+            return res.status(404).json({ success: false, error: 'No log paths found for this process' });
+        }
+        // Derive log directory + base name from the out log path (or err if out missing)
+        const refPath = outPath || errPath;
+        const logDir = refPath.substring(0, refPath.lastIndexOf('/'));
+        const baseName = refPath.split('/').pop().replace(/-out\.log.*$/, '').replace(/-(error|err)\.log.*$/, '');
+        // List matching files in the log directory
+        const lsCmd = `ls -la "${logDir}" 2>/dev/null`;
+        let lsResult = await connection.executeCommand(lsCmd);
+        if (lsResult.code !== 0)
+            lsResult = await connection.executeCommand(`sudo ${lsCmd}`);
+        const files = [];
+        if (lsResult.code === 0) {
+            for (const line of lsResult.stdout.split('\n')) {
+                // ls -la line: permissions links owner group size month day time name
+                const parts = line.trim().split(/\s+/);
+                if (parts.length < 9)
+                    continue;
+                const fileName = parts.slice(8).join(' ');
+                if (!fileName.startsWith(baseName))
+                    continue;
+                const size = parseInt(parts[4], 10) || 0;
+                const month = parts[5];
+                const day = parts[6];
+                const timeOrYr = parts[7];
+                const modified = `${month} ${day} ${timeOrYr}`;
+                let type = 'unknown';
+                if (fileName.includes('-out'))
+                    type = 'out';
+                else if (fileName.includes('-error') || fileName.includes('-err'))
+                    type = 'err';
+                files.push({
+                    name: fileName,
+                    path: `${logDir}/${fileName}`,
+                    size,
+                    modified,
+                    type,
+                    compressed: fileName.endsWith('.gz'),
+                });
+            }
+        }
+        // Sort: current files first (no date suffix), then rotated newest first
+        files.sort((a, b) => {
+            const aRot = a.name.includes('__') || /\d{4}-\d{2}/.test(a.name);
+            const bRot = b.name.includes('__') || /\d{4}-\d{2}/.test(b.name);
+            if (!aRot && bRot)
+                return -1;
+            if (aRot && !bRot)
+                return 1;
+            return b.name.localeCompare(a.name);
+        });
+        res.json({ files });
+    }
+    catch (error) {
+        console.error('Error listing remote log files:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Read a specific remote log file by path — ?lines=N, handles .gz via zcat
+ * GET /api/remote/:connectionId/log-file?path=...&lines=N
+ * Uses /log-file top-level to avoid clashing with /logs/:processId routes
+ */
+router.get('/:connectionId/log-file', async (req, res) => {
+    var _a;
+    try {
+        const { connectionId } = req.params;
+        const filePath = req.query.path;
+        const lines = safeLogLines(req.query.lines);
+        if (!filePath)
+            return res.status(400).json({ error: 'path query parameter required' });
+        // Strict path validation — blocks traversal, shell metacharacters, and non-log extensions
+        if (!validateRemotePath(filePath)) {
+            return res.status(403).json({ error: 'Access denied: invalid or unsafe log file path' });
+        }
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        const isGz = filePath.endsWith('.gz');
+        const catCmd = isGz ? `zcat "${filePath}" 2>/dev/null` : `cat "${filePath}" 2>/dev/null`;
+        const lineArg = lines === 0 ? '' : `| tail -n ${lines}`;
+        const countCmd = isGz
+            ? `zcat "${filePath}" 2>/dev/null | wc -l`
+            : `wc -l < "${filePath}" 2>/dev/null`;
+        const [contentResult, countResult] = await Promise.all([
+            connection.executeCommand(`${catCmd} ${lineArg}`).catch(() => ({ code: 1, stdout: '', stderr: '' })),
+            connection.executeCommand(countCmd).catch(() => ({ code: 1, stdout: '0', stderr: '' })),
+        ]);
+        // Fallback to sudo on permission error
+        const content = contentResult.code === 0 && contentResult.stdout.trim()
+            ? contentResult
+            : await connection.executeCommand(`sudo ${catCmd} ${lineArg}`);
+        const totalLines = parseInt(((_a = countResult.stdout) === null || _a === void 0 ? void 0 : _a.trim()) || '0', 10);
+        const logLines = (content.stdout || '').split('\n').filter((l) => l.trim() !== '');
+        res.json({ logs: logLines, totalLines });
+    }
+    catch (error) {
+        console.error('Error reading remote log file:', error);
+        res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+    }
+});
+/**
+ * Download a specific remote log file by path via SSH cat/zcat
+ * GET /api/remote/:connectionId/log-file/download?path=...
+ */
+router.get('/:connectionId/log-file/download', async (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const filePath = req.query.path;
+        if (!filePath)
+            return res.status(400).json({ error: 'path query parameter required' });
+        if (!validateRemotePath(filePath)) {
+            return res.status(403).json({ error: 'Access denied: invalid or unsafe log file path' });
+        }
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection)
+            return res.status(404).json({ success: false, error: 'Connection not found' });
+        if (!connection.isConnected())
+            return res.status(400).json({ success: false, error: 'Not connected' });
+        // .gz files: stream via SFTP + local gunzip (no server-side memory buffering)
+        if (filePath.endsWith('.gz')) {
+            const gzName = filePath.split('/').pop().replace(/\.gz$/, '');
+            await connection.streamGzFileToResponse(filePath, res, gzName);
+            return;
+        }
+        // Plain files: SFTP stream
+        const fileName = filePath.split('/').pop();
+        await connection.streamFileToResponse(filePath, res, fileName);
+    }
+    catch (error) {
+        console.error('Error downloading remote log file:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ success: false, error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}` });
+        }
+    }
+});
 /**
  * Get list of all remote connections with their status
  * GET /api/remote/connections
@@ -561,7 +825,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 +975,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/routes/updates.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+declare const router: Router;
+export default router;