ezpm2gui 1.0.0 → 1.2.0

package/dist/server/routes/deployApplication.js

@@ -0,0 +1,310 @@
+"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 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;
+    // 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}` });
+    }
+    try {
+        const projectPath = cwd || path_1.default.dirname(script);
+        let setupResult = null;
+        let finalEnv = env || {};
+        let interpreterPath = '';
+        // Auto-detect project type if not provided
+        let detectedType = appType;
+        if (!detectedType) {
+            detectedType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
+            if (detectedType) {
+                console.log(`Auto-detected project type: ${detectedType}`);
+            }
+        }
+        // Run project setup if auto-setup is enabled and project type is detected
+        if (autoSetup && detectedType && ['node', 'python', 'dotnet'].includes(detectedType)) {
+            console.log(`Running setup for ${detectedType} project...`);
+            try {
+                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType);
+                if (!setupResult.success) {
+                    return res.status(500).json({
+                        error: 'Project setup failed',
+                        details: setupResult.errors,
+                        warnings: setupResult.warnings,
+                        steps: setupResult.steps
+                    });
+                }
+                // Merge environment variables from setup
+                finalEnv = { ...setupResult.environment, ...finalEnv };
+                // Set interpreter path for Python projects
+                if (setupResult.interpreterPath) {
+                    interpreterPath = setupResult.interpreterPath;
+                }
+                console.log('Project setup completed successfully');
+            }
+            catch (setupError) {
+                console.error('Setup error:', setupError);
+                return res.status(500).json({
+                    error: 'Project setup failed',
+                    details: setupError instanceof Error ? setupError.message : 'Unknown setup error'
+                });
+            }
+        }
+        // Create deployment configuration
+        const appConfig = {
+            name,
+            script,
+            cwd: projectPath,
+            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: finalEnv
+        };
+        // Set interpreter for Python projects
+        if (detectedType === 'python' && interpreterPath) {
+            appConfig.interpreter = interpreterPath;
+        }
+        else if (detectedType === 'dotnet') {
+            appConfig.interpreter = 'dotnet';
+            // For .NET projects, update script to point to the published DLL if available
+            const publishedDll = path_1.default.join(projectPath, 'publish', `${path_1.default.basename(projectPath)}.dll`);
+            if (fs_1.default.existsSync(publishedDll)) {
+                appConfig.script = publishedDll;
+            }
+        }
+        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`,
+                    setupResult: setupResult ? {
+                        steps: setupResult.steps,
+                        warnings: setupResult.warnings
+                    } : null
+                });
+            });
+        });
+    }
+    catch (error) {
+        console.error('Deployment error:', error);
+        return res.status(500).json({
+            error: 'Deployment failed',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// 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' });
+        }
+    });
+});
+// Detect project type
+router.post('/detect-project', (req, res) => {
+    const { projectPath } = req.body;
+    if (!projectPath) {
+        return res.status(400).json({ error: 'Project path is required' });
+    }
+    if (!fs_1.default.existsSync(projectPath)) {
+        return res.status(400).json({ error: 'Project path does not exist' });
+    }
+    try {
+        const projectType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
+        const config = projectType ? ProjectSetupService_1.projectSetupService.getProjectConfig(projectType) : null;
+        res.json({
+            success: true,
+            projectType,
+            config: config ? {
+                name: config.name,
+                defaultConfig: config.defaultConfig,
+                setupSteps: config.setup.steps.length
+            } : null
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Failed to detect project type',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// Setup project (without deployment)
+router.post('/setup-project', async (req, res) => {
+    const { projectPath, projectType } = req.body;
+    if (!projectPath || !projectType) {
+        return res.status(400).json({ error: 'Project path and type are required' });
+    }
+    if (!fs_1.default.existsSync(projectPath)) {
+        return res.status(400).json({ error: 'Project path does not exist' });
+    }
+    try {
+        const setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, projectType);
+        res.json({
+            success: setupResult.success,
+            steps: setupResult.steps,
+            errors: setupResult.errors,
+            warnings: setupResult.warnings,
+            environment: setupResult.environment,
+            interpreterPath: setupResult.interpreterPath
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Project setup failed',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// Get supported project types
+router.get('/project-types', (req, res) => {
+    try {
+        const types = ProjectSetupService_1.projectSetupService.getSupportedProjectTypes();
+        const typeConfigs = types.map(type => {
+            const config = ProjectSetupService_1.projectSetupService.getProjectConfig(type);
+            return {
+                type,
+                name: config === null || config === void 0 ? void 0 : config.name,
+                defaultConfig: config === null || config === void 0 ? void 0 : config.defaultConfig
+            };
+        });
+        res.json({
+            success: true,
+            types: typeConfigs
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Failed to get project types',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+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,276 @@
+"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 remote_connection_1 = require("../utils/remote-connection");
+const router = (0, express_1.Router)();
+// This variable will hold references to active log streams
+const activeStreams = {};
+const activeRemoteStreams = {};
+// 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);
+        });
+    });
+};
+// Get remote log stream (or create a new one)
+const getRemoteLogStream = async (io, connectionId, processId) => {
+    const streamKey = `${connectionId}-${processId}`;
+    // If stream already exists, return it
+    if (activeRemoteStreams[streamKey]) {
+        return activeRemoteStreams[streamKey];
+    }
+    const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+    if (!connection || !connection.isConnected()) {
+        throw new Error('Connection not found or not connected');
+    }
+    // Get process info to find log paths
+    console.log(`Getting process info for: ${processId}`);
+    const processInfoResult = await connection.executeCommand(`pm2 jlist`, false); // Don't use sudo for listing
+    if (processInfoResult.code !== 0) {
+        throw new Error(`Failed to get process list: ${processInfoResult.stderr}`);
+    }
+    let processInfo;
+    try {
+        const processList = JSON.parse(processInfoResult.stdout);
+        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`);
+        }
+        console.log(`Found process: ${processInfo.name} (ID: ${processInfo.pm_id})`);
+    }
+    catch (parseError) {
+        console.error('Parse error:', parseError);
+        throw new Error(`Failed to parse process list: ${parseError}`);
+    }
+    const processName = processInfo.name;
+    // Create streams using pm2 logs instead of tail for better permission handling
+    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)`);
+        const logStream = await connection.createLogStream(pm2LogsCommand, true);
+        console.log(`Successfully created pm2 logs stream for ${processName}`);
+        logStream.on('data', (data) => {
+            console.log(`Raw pm2 logs data received for ${processName}:`, data);
+            const lines = data.toString().split('\n').filter((line) => line.trim() !== '');
+            lines.forEach((line) => {
+                // Skip PM2 startup messages, system messages, and errors
+                if (line.trim() === '' ||
+                    line.includes('PM2') ||
+                    line.includes('---') ||
+                    line.includes('watching') ||
+                    line.includes('change detected') ||
+                    line.includes('Runtime Edition') ||
+                    line.includes('Production Process Manager') ||
+                    line.includes('built-in Load Balancer') ||
+                    line.includes('$ pm2') ||
+                    line.includes('http://pm2.io') ||
+                    line.includes('Start and Daemonize') ||
+                    line.includes('Load Balance') ||
+                    line.includes('Monitor in production') ||
+                    line.includes('Make pm2 auto-boot') ||
+                    line.includes('To go further') ||
+                    line.includes('ENOENT') ||
+                    line.includes('module_conf.json') ||
+                    line.includes('pm2.log') ||
+                    line.includes('node:fs:') ||
+                    line.includes('at Object.') ||
+                    line.includes('at Client.') ||
+                    line.includes('at processTicksAndRejections') ||
+                    line.includes('errno:') ||
+                    line.includes('syscall:') ||
+                    line.includes('Node.js v') ||
+                    line.startsWith('    at ') ||
+                    line.match(/^\s*\^?\s*$/) ||
+                    line.match(/^[\s_\/\\|]+$/)) {
+                    console.log(`Skipping PM2 system/error line: "${line}"`);
+                    return;
+                }
+                // Parse PM2 log format: timestamp | app-name | message
+                // PM2 logs typically come in format like: "2023-01-01T12:00:00: PM2 log: [TAILING]"
+                // or just the raw log content depending on version
+                let logType = 'stdout'; // Default to stdout
+                let cleanLine = line;
+                // Try to detect if this is stderr (PM2 usually prefixes with different indicators)
+                if (line.includes('ERROR') || line.includes('error') || line.includes('stderr')) {
+                    logType = 'stderr';
+                }
+                // Clean up the line by removing PM2 prefixes if present
+                // PM2 log format can vary, but often includes timestamps and app names
+                const logMatch = line.match(/^.*?\|\s*(.+)$/);
+                if (logMatch) {
+                    cleanLine = logMatch[1];
+                }
+                console.log(`Emitting remote-log-line for ${connectionId}-${processId} (${logType}):`, cleanLine);
+                io.emit('remote-log-line', {
+                    connectionId,
+                    processId,
+                    processName,
+                    logType,
+                    line: cleanLine
+                });
+            });
+        });
+        logStream.on('error', (error) => {
+            console.error(`Error in pm2 logs stream for ${processName}:`, error);
+            io.emit('remote-log-error', {
+                connectionId,
+                processId,
+                processName,
+                error: error.message
+            });
+        });
+        logStream.on('close', (code) => {
+            console.log(`PM2 logs stream closed for ${processName} with code:`, code);
+        });
+        streams.combined = logStream;
+    }
+    catch (error) {
+        console.error(`Failed to create pm2 logs stream for ${processName}:`, error);
+        io.emit('remote-log-error', {
+            connectionId,
+            processId,
+            processName,
+            error: `Failed to start log streaming: ${error}`
+        });
+    }
+    // Store the streams
+    activeRemoteStreams[streamKey] = streams;
+    return streams;
+};
+// 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');
+        }); // Subscribe to remote log stream
+        socket.on('subscribe-remote-logs', async ({ connectionId, processId }) => {
+            try {
+                console.log(`Subscribing to remote logs - Connection: ${connectionId}, Process: ${processId}`);
+                const streamKey = `${connectionId}-${processId}`;
+                // Add socket to a room for this specific log stream
+                socket.join(streamKey);
+                console.log(`Client subscribed to remote logs: ${streamKey}`);
+                // Get or create the remote log stream
+                await getRemoteLogStream(io, connectionId, processId);
+            }
+            catch (error) {
+                console.error('Error subscribing to remote logs:', error);
+                socket.emit('remote-log-error', {
+                    connectionId,
+                    processId,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        });
+        // Unsubscribe from remote log stream
+        socket.on('unsubscribe-remote-logs', ({ connectionId, processId }) => {
+            const streamKey = `${connectionId}-${processId}`;
+            // Remove socket from the room
+            socket.leave(streamKey);
+            console.log(`Client unsubscribed from remote logs: ${streamKey}`);
+            // If no more clients in this room, stop the streams
+            const room = io.sockets.adapter.rooms.get(streamKey);
+            if (!room || room.size === 0) {
+                const streams = activeRemoteStreams[streamKey];
+                if (streams) {
+                    console.log(`Stopping remote log streams: ${streamKey}`);
+                    if (streams.stdout && streams.stdout.kill) {
+                        streams.stdout.kill();
+                    }
+                    if (streams.stderr && streams.stderr.kill) {
+                        streams.stderr.kill();
+                    }
+                    delete activeRemoteStreams[streamKey];
+                }
+            }
+        });
+    });
+};
+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;