ezpm2gui 1.3.2 → 1.5.0

package/dist/server/index.js

@@ -4,10 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = createServer;
+const path_1 = __importDefault(require("path"));
+// @group Configuration : Load .env.local first (local overrides), then .env (defaults)
+// Must happen before any code reads process.env
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const dotenv = require('dotenv');
+dotenv.config({ path: path_1.default.resolve(process.cwd(), '.env.local') });
+dotenv.config({ path: path_1.default.resolve(process.cwd(), '.env') });
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
 const socket_io_1 = require("socket.io");
-const path_1 = __importDefault(require("path"));
 const pm2_1 = __importDefault(require("pm2"));
 const os_1 = __importDefault(require("os"));
 const processConfig_1 = __importDefault(require("./routes/processConfig"));
@@ -15,6 +21,7 @@ const deployApplication_1 = __importDefault(require("./routes/deployApplication"
 const modules_1 = __importDefault(require("./routes/modules"));
 const remoteConnections_1 = __importDefault(require("./routes/remoteConnections"));
 const cronJobs_1 = __importDefault(require("./routes/cronJobs"));
+const updates_1 = __importDefault(require("./routes/updates"));
 const logStreaming_1 = require("./routes/logStreaming");
 const pm2_connection_1 = require("./utils/pm2-connection");
 const remote_connection_1 = require("./utils/remote-connection");
@@ -29,7 +36,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());
@@ -49,6 +65,7 @@ function createServer() {
     app.use('/api/modules', modules_1.default);
     app.use('/api/remote', remoteConnections_1.default);
     app.use('/api/cron-jobs', cronJobs_1.default);
+    app.use('/api/update', updates_1.default);
     // Setup log streaming with Socket.IO
     (0, logStreaming_1.setupLogStreaming)(io); // PM2 API endpoints
     app.get('/api/processes', async (req, res) => {
@@ -73,42 +90,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) => {
@@ -124,76 +135,238 @@ function createServer() {
         };
         res.json(metrics);
     });
-    // Get process logs
-    app.get('/api/logs/:id/:type', (req, res) => {
+    // @group LogHistory : Resolve log path from PM2 process descriptor
+    const resolveLocalLogPath = async (id, logType) => {
+        var _a, _b, _c;
+        const processDesc = await (0, pm2_connection_1.executePM2Command)((callback) => {
+            pm2_1.default.describe(id, callback);
+        });
+        if (!processDesc || processDesc.length === 0)
+            return null;
+        return (_c = (_b = (_a = processDesc[0]) === null || _a === void 0 ? void 0 : _a.pm2_env) === null || _b === void 0 ? void 0 : _b[`pm_${logType}_log_path`]) !== null && _c !== void 0 ? _c : null;
+    };
+    // @group LogHistory : Get log lines — ?lines=N (default 200, 0 = all)
+    app.get('/api/logs/:id/:type', async (req, res) => {
         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' });
+        const lines = parseInt(req.query.lines || '200', 10);
+        try {
+            const logPath = await resolveLocalLogPath(id, logType);
+            if (!logPath) {
+                res.status(404).json({ error: 'Process not found or log path unavailable' });
                 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 fs = require('fs');
+            if (!fs.existsSync(logPath)) {
+                res.json({ logs: [], logPath });
+                return;
+            }
+            const { lines: result, total } = await streamTailLines(fs.createReadStream(logPath), lines);
+            res.json({ logs: result, logPath, totalLines: total });
+        }
+        catch (err) {
+            console.error(`Error reading log file: ${err}`);
+            res.status(500).json({ error: 'Failed to read log file' });
+        }
+    });
+    // @group LogHistory : Download full log file
+    app.get('/api/logs/:id/:type/download', async (req, res) => {
+        const { id, type } = req.params;
+        const logType = type === 'err' ? 'err' : 'out';
+        try {
+            const logPath = await resolveLocalLogPath(id, logType);
+            if (!logPath) {
+                res.status(404).json({ error: 'Process not found or log path unavailable' });
+                return;
+            }
+            const fs = require('fs');
+            if (!fs.existsSync(logPath)) {
+                res.status(404).json({ error: 'Log file does not exist yet' });
+                return;
+            }
+            const fileName = `${id}-${logType}.log`;
+            res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+            res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            fs.createReadStream(logPath).pipe(res);
+        }
+        catch (err) {
+            console.error(`Error downloading log file: ${err}`);
+            res.status(500).json({ error: 'Failed to download log file' });
+        }
+    });
+    // @group LogHistory : List all log files (current + rotated) for a process
+    // Uses /api/log-files/:id to avoid Express matching /:id/:type with type='files'
+    app.get('/api/log-files/:id', async (req, res) => {
+        const { id } = req.params;
+        try {
+            const fs = require('fs');
+            const nodePath = require('path');
+            const [outPath, errPath] = await Promise.all([
+                resolveLocalLogPath(id, 'out'),
+                resolveLocalLogPath(id, 'err'),
+            ]);
+            if (!outPath && !errPath) {
+                res.status(404).json({ error: 'Process not found or no log paths available' });
+                return;
+            }
+            // Derive the process base name from the log path (strip -out.log suffix)
+            const baseName = outPath
+                ? nodePath.basename(outPath).replace(/-out\.log.*$/, '')
+                : nodePath.basename(errPath).replace(/-(error|err)\.log.*$/, '');
+            const logDirs = new Set();
+            if (outPath)
+                logDirs.add(nodePath.dirname(outPath));
+            if (errPath)
+                logDirs.add(nodePath.dirname(errPath));
+            const files = [];
+            for (const dir of logDirs) {
+                if (!fs.existsSync(dir))
+                    continue;
+                for (const fileName of fs.readdirSync(dir)) {
+                    if (!fileName.startsWith(baseName))
+                        continue;
+                    const filePath = nodePath.join(dir, fileName);
+                    const stat = fs.statSync(filePath);
+                    if (!stat.isFile())
+                        continue;
+                    let type = 'unknown';
+                    if (fileName.includes('-out'))
+                        type = 'out';
+                    else if (fileName.includes('-error') || fileName.includes('-err'))
+                        type = 'err';
+                    files.push({
+                        name: fileName,
+                        path: filePath,
+                        size: stat.size,
+                        modified: stat.mtime.toISOString(),
+                        type,
+                        compressed: fileName.endsWith('.gz'),
+                    });
                 }
-                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` });
+            }
+            files.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+            res.json({ files });
+        }
+        catch (err) {
+            console.error('Error listing log files:', err);
+            res.status(500).json({ error: 'Failed to list log files' });
+        }
+    });
+    // @group LogHistory : Security helper — block path traversal; allow any absolute log file path
+    const isAllowedLogPath = (filePath) => {
+        const nodePath = require('path');
+        const norm = nodePath.normalize(filePath);
+        // Require absolute path; reject shell-dangerous characters; require log extension
+        const SHELL_UNSAFE = /['"`;$|&<>(){}\\\n\r\0]/;
+        return (nodePath.isAbsolute(norm) &&
+            !norm.includes('..') &&
+            !SHELL_UNSAFE.test(norm) &&
+            /\.(log|gz)$/i.test(norm));
+    };
+    // @group LogHistory : Stream last N lines from a readable stream (ring buffer, no full-file load)
+    const streamTailLines = (inputStream, maxLines) => {
+        return new Promise((resolve, reject) => {
+            const rl = require('readline').createInterface({ input: inputStream, crlfDelay: Infinity });
+            const buffer = [];
+            let total = 0;
+            rl.on('line', (line) => {
+                if (line.trim() === '')
                     return;
+                total++;
+                if (maxLines > 0) {
+                    buffer.push(line);
+                    if (buffer.length > maxLines)
+                        buffer.shift();
                 }
-                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' });
+                else {
+                    buffer.push(line);
                 }
             });
+            rl.on('close', () => resolve({ lines: buffer, total }));
+            rl.on('error', reject);
+            inputStream.on('error', reject);
         });
+    };
+    // @group LogHistory : Read a specific log file by path — ?lines=N, supports .gz
+    // Uses /api/log-file (singular, top-level) to avoid clashing with /api/logs/:id/:type
+    app.get('/api/log-file', async (req, res) => {
+        const filePath = req.query.path;
+        const lines = parseInt(req.query.lines || '200', 10);
+        if (!filePath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        if (!isAllowedLogPath(filePath)) {
+            res.status(403).json({ error: 'Access denied: path is outside PM2 log directories' });
+            return;
+        }
+        try {
+            const fs = require('fs');
+            const zlib = require('zlib');
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+            const inputStream = filePath.endsWith('.gz')
+                ? fs.createReadStream(filePath).pipe(zlib.createGunzip())
+                : fs.createReadStream(filePath);
+            const { lines: result, total } = await streamTailLines(inputStream, lines);
+            res.json({ logs: result, totalLines: total });
+        }
+        catch (err) {
+            console.error('Error reading log file:', err);
+            res.status(500).json({ error: 'Failed to read log file' });
+        }
+    });
+    // @group LogHistory : Download a specific log file by path (streams .gz as-is)
+    app.get('/api/log-file/download', async (req, res) => {
+        const filePath = req.query.path;
+        if (!filePath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        if (!isAllowedLogPath(filePath)) {
+            res.status(403).json({ error: 'Access denied' });
+            return;
+        }
+        try {
+            const fs = require('fs');
+            const zlib = require('zlib');
+            const nodePath = require('path');
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+            // Decompress .gz server-side so the download is always plain text
+            const baseName = nodePath.basename(filePath).replace(/\.gz$/i, '');
+            res.setHeader('Content-Disposition', `attachment; filename="${baseName}"`);
+            res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+            if (filePath.endsWith('.gz')) {
+                fs.createReadStream(filePath).pipe(zlib.createGunzip()).pipe(res);
+            }
+            else {
+                fs.createReadStream(filePath).pipe(res);
+            }
+        }
+        catch (err) {
+            console.error('Error downloading log file:', err);
+            res.status(500).json({ error: 'Failed to download 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(() => {
@@ -233,7 +406,7 @@ function createServer() {
 }
 // Only start the server if this file is run directly
 if (require.main === module) {
-    const PORT = process.env.PORT || 3001;
+    const PORT = process.env.PORT || 3101;
     const HOST = process.env.HOST || 'localhost';
     const server = createServer();
     server.listen(PORT, () => {

package/dist/server/routes/deployApplication.js

@@ -11,7 +11,7 @@ const ProjectSetupService_1 = require("../services/ProjectSetupService");
 const router = (0, express_1.Router)();
 // Deploy a new application
 router.post('/', async (req, res) => {
-    const { name, script, cwd, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
+    const { name, script, cwd, namespace, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
     // Validate required fields
     if (!name || !script) {
         return res.status(400).json({ error: 'Name and script path are required' });
@@ -67,6 +67,7 @@ router.post('/', async (req, res) => {
             name,
             script,
             cwd: projectPath,
+            namespace: namespace || 'default',
             instances: parseInt(instances) || 1,
             exec_mode: exec_mode || 'fork',
             autorestart: autorestart !== undefined ? autorestart : true,
@@ -158,8 +159,8 @@ router.post('/generate-ecosystem', (req, res) => {
                     env: pm2Env.env || {}
                 };
             });
-            const ecosystemConfig = `module.exports = {
-  apps: ${JSON.stringify(apps, null, 2)}
+            const ecosystemConfig = `module.exports = {
+  apps: ${JSON.stringify(apps, null, 2)}
 };`;
             // Create the file (either at specified path or default location)
             const filePath = req.body.path || path_1.default.join(process.cwd(), 'ecosystem.config.js');
@@ -212,8 +213,8 @@ router.get('/generate-ecosystem-preview', (req, res) => {
                     env: pm2Env.env || {}
                 };
             });
-            const ecosystemConfig = `module.exports = {
-  apps: ${JSON.stringify(apps, null, 2)}
+            const ecosystemConfig = `module.exports = {
+  apps: ${JSON.stringify(apps, null, 2)}
 };`;
             pm2_1.default.disconnect();
             res.json({

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,