ezpm2gui 1.0.0 → 1.1.0

package/dist/server/routes/clusterManagement.js

@@ -0,0 +1,152 @@
+"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 pm2_1 = __importDefault(require("pm2"));
+const router = (0, express_1.Router)();
+// Get cluster information for a specific process
+router.get('/:id', (req, res) => {
+    const { id } = req.params;
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        pm2_1.default.describe(id, (err, processDesc) => {
+            pm2_1.default.disconnect();
+            if (err || !processDesc || processDesc.length === 0) {
+                res.status(404).json({ error: 'Process not found' });
+                return;
+            }
+            const process = processDesc[0];
+            const clusterInfo = {
+                pm_id: process.pm_id,
+                name: process.name,
+                instances: process.pm2_env.instances,
+                exec_mode: process.pm2_env.exec_mode,
+                isCluster: process.pm2_env.exec_mode === 'cluster_mode'
+            };
+            res.json(clusterInfo);
+        });
+    });
+});
+// Scale process (change number of instances)
+router.post('/:id/scale', (req, res) => {
+    const { id } = req.params;
+    const { instances } = req.body;
+    if (!instances || isNaN(parseInt(instances))) {
+        res.status(400).json({ error: 'Valid number of instances is required' });
+        return;
+    }
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        // Using PM2 API to scale a process
+        // TypeScript doesn't recognize 'scale' method, so we're using it with a type assertion
+        pm2_1.default.scale(id, parseInt(instances), (err) => {
+            pm2_1.default.disconnect();
+            if (err) {
+                console.error(err);
+                res.status(500).json({ error: 'Failed to scale process' });
+                return;
+            }
+            res.json({ success: true, message: `Process ${id} scaled to ${instances} instances` });
+        });
+    });
+});
+// Reload instances (zero-downtime reload)
+router.post('/:id/reload', (req, res) => {
+    const { id } = req.params;
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        pm2_1.default.reload(id, (err) => {
+            pm2_1.default.disconnect();
+            if (err) {
+                console.error(err);
+                res.status(500).json({ error: 'Failed to reload process' });
+                return;
+            }
+            res.json({ success: true, message: `Process ${id} reloaded with zero-downtime` });
+        });
+    });
+});
+// Change execution mode between 'fork' and 'cluster'
+router.post('/:id/exec-mode', (req, res) => {
+    const { id } = req.params;
+    const { mode } = req.body;
+    if (!mode || (mode !== 'fork' && mode !== 'cluster')) {
+        res.status(400).json({ error: 'Valid execution mode (fork or cluster) is required' });
+        return;
+    }
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        // First get the current process information to preserve settings
+        pm2_1.default.describe(id, (err, processDesc) => {
+            if (err || !processDesc || processDesc.length === 0) {
+                pm2_1.default.disconnect();
+                res.status(404).json({ error: 'Process not found' });
+                return;
+            }
+            const process = processDesc[0];
+            const pm2Env = process.pm2_env;
+            // Update the execution mode
+            const updateOptions = {
+                script: pm2Env.pm_exec_path,
+                name: process.name,
+                instances: pm2Env.instances || 1,
+                exec_mode: mode === 'cluster' ? 'cluster_mode' : 'fork_mode',
+                // Preserve other settings
+                cwd: pm2Env.pm_cwd,
+                watch: pm2Env.watch || false,
+                ignore_watch: pm2Env.ignore_watch || [],
+                env: pm2Env.env || {}
+            };
+            // Stop the existing process
+            pm2_1.default.stop(id, (stopErr) => {
+                if (stopErr) {
+                    pm2_1.default.disconnect();
+                    console.error(stopErr);
+                    res.status(500).json({ error: 'Failed to stop process for exec mode change' });
+                    return;
+                }
+                // Delete the existing process
+                pm2_1.default.del(id, (delErr) => {
+                    if (delErr) {
+                        pm2_1.default.disconnect();
+                        console.error(delErr);
+                        res.status(500).json({ error: 'Failed to delete process for exec mode change' });
+                        return;
+                    }
+                    // Start with new settings
+                    pm2_1.default.start(updateOptions, (startErr) => {
+                        pm2_1.default.disconnect();
+                        if (startErr) {
+                            console.error(startErr);
+                            res.status(500).json({ error: 'Failed to restart process with new exec mode' });
+                            return;
+                        }
+                        res.json({
+                            success: true,
+                            message: `Process ${process.name} execution mode changed to ${mode}`
+                        });
+                    });
+                });
+            });
+        });
+    });
+});
+exports.default = router;

package/dist/server/routes/deployApplication.d.ts

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

package/dist/server/routes/deployApplication.js

@@ -0,0 +1,163 @@
+"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 pm2_1 = __importDefault(require("pm2"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const router = (0, express_1.Router)();
+// Deploy a new application
+router.post('/', (req, res) => {
+    const { name, script, cwd, instances, exec_mode, autorestart, watch, max_memory_restart, env } = req.body;
+    // Validate required fields
+    if (!name || !script) {
+        return res.status(400).json({ error: 'Name and script path are required' });
+    }
+    // Validate script path exists
+    if (!fs_1.default.existsSync(script)) {
+        return res.status(400).json({ error: `Script file not found: ${script}` });
+    }
+    // Create deployment configuration
+    const appConfig = {
+        name,
+        script,
+        cwd: cwd || path_1.default.dirname(script),
+        instances: parseInt(instances) || 1,
+        exec_mode: exec_mode || 'fork',
+        autorestart: autorestart !== undefined ? autorestart : true,
+        watch: watch || false,
+        max_memory_restart: max_memory_restart || '150M',
+        env: env || {}
+    };
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            return res.status(500).json({ error: 'Failed to connect to PM2' });
+        }
+        pm2_1.default.start(appConfig, (err) => {
+            pm2_1.default.disconnect();
+            if (err) {
+                console.error('PM2 start error:', err);
+                return res.status(500).json({
+                    error: `Failed to deploy application: ${err.message || 'Unknown error'}`
+                });
+            }
+            res.json({
+                success: true,
+                message: `Application ${name} deployed successfully`
+            });
+        });
+    });
+});
+// Generate ecosystem.config.js file
+router.post('/generate-ecosystem', (req, res) => {
+    pm2_1.default.connect(async (err) => {
+        if (err) {
+            console.error(err);
+            return res.status(500).json({ error: 'Failed to connect to PM2' });
+        }
+        try {
+            // Get all processes
+            const listPromise = new Promise((resolve, reject) => {
+                pm2_1.default.list((err, processList) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(processList);
+                });
+            });
+            const processList = await listPromise;
+            // Filter processes if needed
+            let filteredProcesses = processList;
+            if (req.body.includeAllProcesses === false) {
+                filteredProcesses = processList.filter(proc => proc.pm2_env.status === 'online');
+            }
+            // Create ecosystem config
+            const apps = filteredProcesses.map(proc => {
+                const pm2Env = proc.pm2_env;
+                return {
+                    name: proc.name,
+                    script: pm2Env.pm_exec_path,
+                    cwd: pm2Env.pm_cwd,
+                    instances: pm2Env.instances || 1,
+                    exec_mode: pm2Env.exec_mode === 'cluster_mode' ? 'cluster' : 'fork',
+                    autorestart: pm2Env.autorestart,
+                    watch: pm2Env.watch,
+                    ignore_watch: pm2Env.ignore_watch || [],
+                    max_memory_restart: pm2Env.max_memory_restart || '150M',
+                    env: pm2Env.env || {}
+                };
+            });
+            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');
+            fs_1.default.writeFileSync(filePath, ecosystemConfig);
+            pm2_1.default.disconnect();
+            res.json({
+                success: true,
+                message: 'Ecosystem file generated successfully',
+                path: filePath
+            });
+        }
+        catch (error) {
+            pm2_1.default.disconnect();
+            res.status(500).json({ error: error.message || 'Failed to generate ecosystem file' });
+        }
+    });
+});
+// Preview ecosystem.config.js content
+router.get('/generate-ecosystem-preview', (req, res) => {
+    pm2_1.default.connect(async (err) => {
+        if (err) {
+            console.error(err);
+            return res.status(500).json({ error: 'Failed to connect to PM2' });
+        }
+        try {
+            // Get all processes
+            const listPromise = new Promise((resolve, reject) => {
+                pm2_1.default.list((err, processList) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(processList);
+                });
+            });
+            const processList = await listPromise;
+            // Create ecosystem config
+            const apps = processList.map(proc => {
+                const pm2Env = proc.pm2_env;
+                return {
+                    name: proc.name,
+                    script: pm2Env.pm_exec_path,
+                    cwd: pm2Env.pm_cwd,
+                    instances: pm2Env.instances || 1,
+                    exec_mode: pm2Env.exec_mode === 'cluster_mode' ? 'cluster' : 'fork',
+                    autorestart: pm2Env.autorestart,
+                    watch: pm2Env.watch,
+                    ignore_watch: pm2Env.ignore_watch || [],
+                    max_memory_restart: pm2Env.max_memory_restart || '150M',
+                    env: pm2Env.env || {}
+                };
+            });
+            const ecosystemConfig = `module.exports = {
+  apps: ${JSON.stringify(apps, null, 2)}
+};`;
+            pm2_1.default.disconnect();
+            res.json({
+                success: true,
+                content: ecosystemConfig
+            });
+        }
+        catch (error) {
+            pm2_1.default.disconnect();
+            res.status(500).json({ error: error.message || 'Failed to generate ecosystem preview' });
+        }
+    });
+});
+exports.default = router;

package/dist/server/routes/logStreaming.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+declare const router: Router;
+declare const setupLogStreaming: (io: any) => void;
+export { setupLogStreaming };
+export default router;

package/dist/server/routes/logStreaming.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLogStreaming = void 0;
+const express_1 = require("express");
+const pm2_1 = __importDefault(require("pm2"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const router = (0, express_1.Router)();
+// This variable will hold references to active log streams
+const activeStreams = {};
+// Get active stream (or create a new one)
+const getLogStream = (io, processId, logType) => {
+    const streamKey = `${processId}-${logType}`;
+    // If stream already exists, return it
+    if (activeStreams[streamKey]) {
+        return activeStreams[streamKey];
+    }
+    return new Promise((resolve, reject) => {
+        pm2_1.default.describe(processId, (err, processDesc) => {
+            var _a, _b;
+            if (err || !processDesc || processDesc.length === 0) {
+                reject(new 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 || !fs_1.default.existsSync(logPath)) {
+                reject(new Error(`Log file not found: ${logPath}`));
+                return;
+            }
+            // Create a tail process to stream the log file
+            const tail = (0, child_process_1.spawn)('tail', ['-f', logPath]);
+            // Setup event handlers
+            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', {
+                        processId,
+                        logType,
+                        line
+                    });
+                });
+            });
+            tail.stderr.on('data', (data) => {
+                console.error(`Tail error: ${data}`);
+            });
+            tail.on('close', (code) => {
+                console.log(`Tail process exited with code ${code}`);
+                delete activeStreams[streamKey];
+            });
+            // Store the tail process
+            activeStreams[streamKey] = tail;
+            resolve(tail);
+        });
+    });
+};
+// Setup socket.io handlers for log streaming
+const setupLogStreaming = (io) => {
+    io.on('connection', (socket) => {
+        console.log('Client connected for log streaming');
+        // Subscribe to log stream
+        socket.on('subscribe-logs', async ({ processId, logType }) => {
+            try {
+                const streamKey = `${processId}-${logType}`;
+                // Add socket to a room for this specific log stream
+                socket.join(streamKey);
+                console.log(`Client subscribed to logs: ${streamKey}`);
+                // Get or create the log stream
+                await getLogStream(io, processId, logType);
+            }
+            catch (error) {
+                console.error('Error subscribing to logs:', error);
+            }
+        });
+        // Unsubscribe from log stream
+        socket.on('unsubscribe-logs', ({ processId, logType }) => {
+            const streamKey = `${processId}-${logType}`;
+            // Remove socket from the room
+            socket.leave(streamKey);
+            console.log(`Client unsubscribed from logs: ${streamKey}`);
+            // If no more clients in this room, stop the stream
+            const room = io.sockets.adapter.rooms.get(streamKey);
+            if (!room || room.size === 0) {
+                const stream = activeStreams[streamKey];
+                if (stream) {
+                    console.log(`Stopping log stream: ${streamKey}`);
+                    stream.kill();
+                    delete activeStreams[streamKey];
+                }
+            }
+        });
+        // Cleanup on disconnect
+        socket.on('disconnect', () => {
+            console.log('Client disconnected from log streaming');
+        });
+    });
+};
+exports.setupLogStreaming = setupLogStreaming;
+exports.default = router;

package/dist/server/routes/modules.d.ts

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

package/dist/server/routes/modules.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const child_process_1 = require("child_process");
+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) => {
+        if (code !== 0) {
+            return res.status(500).json({
+                error: 'Failed to list PM2 modules',
+                details: errorOutput
+            });
+        }
+        // Parse the output to get module information
+        try {
+            const moduleLines = output.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 null;
+            }).filter(Boolean);
+            res.json(modules);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: 'Failed to parse PM2 modules',
+                details: error
+            });
+        }
+    });
+});
+// Install a module
+router.post('/install', (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
+            });
+        }
+        res.json({
+            success: true,
+            message: `Successfully installed module: ${moduleName}`,
+            details: output
+        });
+    });
+});
+// Uninstall a module
+router.delete('/:moduleName', (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
+            });
+        }
+        res.json({
+            success: true,
+            message: `Successfully uninstalled module: ${moduleName}`,
+            details: output
+        });
+    });
+});
+exports.default = router;

package/dist/server/routes/processConfig.d.ts

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

package/dist/server/routes/processConfig.js

@@ -0,0 +1,118 @@
+"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 pm2_1 = __importDefault(require("pm2"));
+const router = (0, express_1.Router)();
+// Get current configuration for a process
+router.get('/:id', (req, res) => {
+    const { id } = req.params;
+    pm2_1.default.connect((err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        pm2_1.default.describe(id, (err, processDesc) => {
+            pm2_1.default.disconnect();
+            if (err || !processDesc || processDesc.length === 0) {
+                res.status(404).json({ error: 'Process not found' });
+                return;
+            }
+            const process = processDesc[0];
+            const pm2Env = process.pm2_env;
+            // Extract configuration from PM2 environment
+            const config = {
+                name: process.name,
+                script: pm2Env.pm_exec_path,
+                cwd: pm2Env.pm_cwd,
+                interpreter: pm2Env.exec_interpreter,
+                instances: pm2Env.instances || 1,
+                exec_mode: pm2Env.exec_mode === 'cluster_mode' ? 'cluster' : 'fork',
+                autorestart: pm2Env.autorestart,
+                watch: pm2Env.watch,
+                ignore_watch: pm2Env.ignore_watch || [],
+                env: pm2Env.env || {},
+                max_memory_restart: pm2Env.max_memory_restart || '150M'
+            };
+            res.json(config);
+        });
+    });
+});
+// Update configuration for a process
+router.post('/:id', (req, res) => {
+    const { id } = req.params;
+    const config = req.body;
+    if (!config) {
+        res.status(400).json({ error: 'Configuration data is required' });
+        return;
+    }
+    pm2_1.default.connect(async (err) => {
+        if (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed to connect to PM2' });
+            return;
+        }
+        try {
+            // First get the current process to find its ecosystem file if any
+            const describePromise = new Promise((resolve, reject) => {
+                pm2_1.default.describe(id, (err, processDesc) => {
+                    if (err || !processDesc || processDesc.length === 0) {
+                        reject(new Error('Process not found'));
+                        return;
+                    }
+                    resolve(processDesc[0]);
+                });
+            });
+            const process = await describePromise;
+            // Update process via PM2 API
+            const updatePromise = new Promise((resolve, reject) => {
+                // Stop the process first
+                pm2_1.default.stop(id, (err) => {
+                    if (err) {
+                        reject(new Error(`Failed to stop process: ${err.message}`));
+                        return;
+                    }
+                    // Delete the process
+                    // TypeScript doesn't recognize 'del' method, so we're using it with a type assertion
+                    pm2_1.default.del(id, (err) => {
+                        if (err) {
+                            reject(new Error(`Failed to delete process: ${err.message}`));
+                            return;
+                        }
+                        // Start with new configuration
+                        pm2_1.default.start({
+                            name: config.name,
+                            script: config.script,
+                            cwd: config.cwd,
+                            interpreter: config.interpreter,
+                            instances: config.instances,
+                            exec_mode: config.exec_mode,
+                            autorestart: config.autorestart,
+                            watch: config.watch,
+                            ignore_watch: config.ignore_watch,
+                            env: config.env,
+                            max_memory_restart: config.max_memory_restart
+                        }, (err) => {
+                            if (err) {
+                                reject(new Error(`Failed to start process with new config: ${err.message}`));
+                                return;
+                            }
+                            resolve(true);
+                        });
+                    });
+                });
+            });
+            await updatePromise;
+            pm2_1.default.disconnect();
+            res.json({ success: true, message: 'Configuration updated successfully' });
+        }
+        catch (error) {
+            pm2_1.default.disconnect();
+            res.status(500).json({ error: error.message || 'Failed to update configuration' });
+        }
+    });
+});
+exports.default = router;

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

@@ -0,0 +1,16 @@
+/**
+ * Connect to PM2 if not already connected
+ * Returns a promise that resolves when the connection is established
+ */
+export declare const connectToPM2: () => Promise<void>;
+/**
+ * Safely disconnect from PM2
+ * Use this when shutting down the server
+ */
+export declare const disconnectFromPM2: () => Promise<void>;
+/**
+ * Execute a PM2 command with automatic connection handling
+ * 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>;