ezpm2gui 1.2.2 → 1.3.0

package/README.md

@@ -2,30 +2,55 @@
 
 A modern web-based graphical user interface for the PM2 process manager, built with TypeScript and Material UI.
 
-![ezPM2GUI Dashboard](./screenshots/screenshot-1747156076728.png)
-
 ## Features
 
-- 🔍 **Real-time process monitoring** - Keep track of all your PM2 processes in real-time
-- 🎮 **Process management** - Start, stop, restart, and delete processes with one click
-- 📊 **System metrics dashboard** - Monitor CPU, memory usage, and uptime
-- 📝 **Enhanced log streaming** - View and filter logs from multiple processes simultaneously
-- 🔄 **WebSocket for live updates** - Get instant updates without refreshing
-- 📈 **Process CPU and memory charts** - Visualize performance metrics over time
-- 🔍 **Filter processes by status or name** - Quickly find the processes you need
-- 🌙 **Dark mode support** - Easy on the eyes for late-night monitoring
-- 🖥️ **Cluster management** - Easily scale your Node.js applications
-- 📦 **Application deployment** - Deploy new applications directly from the UI
-- ⚙️ **Ecosystem configuration** - Create and manage your PM2 ecosystem files
-- 🧩 **PM2 modules support** - Manage and configure PM2 modules
-- 🌐 **Modern UI with Material UI components** - Clean and intuitive interface
-- 🔒 **Fully typed with TypeScript** - Robust and maintainable codebase
+- **Real-time process monitoring** - Keep track of all your PM2 processes in real-time
+- **Process management** - Start, stop, restart, and delete processes with one click
+- **System metrics dashboard** - Monitor CPU, memory usage, and uptime
+- **Enhanced log streaming** - View and filter logs from multiple processes simultaneously
+- **WebSocket for live updates** - Get instant updates without refreshing
+- **Process CPU and memory charts** - Visualize performance metrics over time
+- **Filter processes by status or name** - Quickly find the processes you need
+- **Dark mode support** - Easy on the eyes for late-night monitoring
+- **Cluster management** - Easily scale your Node.js applications
+- **Application deployment** - Deploy new applications directly from the UI
+- **Ecosystem configuration** - Create and manage your PM2 ecosystem files
+- **PM2 modules support** - Manage and configure PM2 modules
+- **Cron Jobs** - Schedule and manage automated tasks with visual cron expression builder
+- **Remote Server Management** - Connect and manage PM2 on remote servers via SSH
+- **Advanced Monitoring Dashboard** - Real-time performance charts with health scoring
+- **Modern UI with Material UI components** - Clean and intuitive interface
+- **Fully typed with TypeScript** - Robust and maintainable codebase
 
 ## Detailed Features
 
 ### Process Monitoring
 Monitor all your PM2 processes in real-time with detailed information on CPU usage, memory consumption, uptime, and status. The intuitive interface makes it easy to identify issues at a glance.
 
+### Remote Server Management
+Connect to and manage PM2 processes on remote servers via secure SSH connections:
+- Add multiple remote server connections with SSH credentials
+- View and manage processes on remote servers
+- Stream logs from remote processes in real-time
+- Execute PM2 commands on remote machines
+- Encrypted credential storage for security
+
+### Cron Jobs
+Schedule and automate tasks using PM2's cron restart feature:
+- Visual cron expression builder with common presets
+- Support for Node.js, Python, Shell, and .NET scripts
+- Inline script editor or file-based execution
+- Enable/disable jobs without deleting them
+- View next execution times and job status
+
+### Advanced Monitoring Dashboard
+Get deeper insights into your system and process performance:
+- Real-time performance charts for CPU, memory, and load
+- System health score calculation
+- Historical metrics tracking
+- Process alerts for high resource usage
+- Per-process performance visualization
+
 ### Application Deployment
 Deploy new Node.js applications to PM2 directly from the UI. Configure all the necessary options including:
 - Application name and script path
@@ -41,10 +66,11 @@ Easily scale your Node.js applications with the cluster management interface. Ad
 
 ### Log Streaming
 View and filter logs from multiple processes simultaneously with the enhanced log streaming interface. Features include:
-- Real-time log updates
-- Filtering by log level or content
+- Real-time log updates via WebSocket
+- Filtering by process, log level, or content
 - Pausing and resuming log streams
-- Log retention configuration
+- Download logs for offline analysis
+- Floating log panel for remote process logs
 
 ### Ecosystem Configuration
 Generate and manage PM2 ecosystem configuration files directly from the UI. This makes it easy to set up complex application deployments and share configurations across your team.
@@ -66,28 +92,6 @@ Customize the ezPM2GUI interface to suit your preferences:
 - Configure dashboard refresh intervals
 - Adjust log display settings
 
-## Screenshots
-
-### Process Monitor
-The main dashboard provides a comprehensive view of all your PM2 processes, showing CPU usage, memory consumption, uptime, and status at a glance.
-
-![Process Monitor](./screenshots/screenshot-1747156076728.png)
-
-### System Metrics & Process Management
-Monitor your system resources and manage PM2 processes with intuitive controls for start, stop, restart, and delete operations.
-
-![System Metrics](./screenshots/screenshot-1747156118224.png)
-
-### Deploy New Application
-Easily deploy new Node.js applications to PM2 with a user-friendly form interface. Configure all PM2 options including instances, execution mode, working directory, and environment variables.
-
-![Deploy Application](./screenshots/screenshot-1747156060890.png)
-
-### Application Settings
-Customize the ezPM2GUI interface and configure your PM2 connection settings to match your environment.
-
-![Application Settings](./screenshots/screenshot-1747156042956.png)
-
 ## Installation
 
 ### Global Installation

package/dist/server/config/cron-jobs.json

@@ -0,0 +1,18 @@
+[
+  {
+    "name": "cv-forge",
+    "description": "",
+    "scriptType": "shell",
+    "scriptMode": "inline",
+    "scriptPath": "",
+    "inlineScript": "echo \"Installing CV Forge\"\nnpm install -g cv-forge",
+    "cronExpression": "* * * * *",
+    "args": [],
+    "env": {},
+    "cwd": "",
+    "enabled": true,
+    "id": "6d8d5e1d-2bc8-463f-82a6-6c294f2b9dbe",
+    "createdAt": "2025-11-03T15:46:21.776Z",
+    "updatedAt": "2025-11-03T15:50:34.133Z"
+  }
+]

package/dist/server/config/cron-scripts/6d8d5e1d-2bc8-463f-82a6-6c294f2b9dbe.sh

@@ -0,0 +1,2 @@
+echo "Installing CV Forge"
+npm install -g cv-forge

package/dist/server/config/remote-connections.json

@@ -0,0 +1,22 @@
+{
+  "connections": [
+    {
+      "id": "192.168.50.100-22-oll-dev",
+      "name": "ascend",
+      "host": "192.168.50.100",
+      "port": 22,
+      "username": "oll-dev",
+      "password": "42eb428a6d0ca614741be36634da53791a5273626acd5d59502780066ce6005e",
+      "useSudo": true
+    },
+    {
+      "id": "172.26.252.123-22-chandan",
+      "name": "wsl",
+      "host": "172.26.252.123",
+      "port": 22,
+      "username": "chandan",
+      "password": "65350d6eb4851ac4386b23b596ea08ed",
+      "useSudo": true
+    }
+  ]
+}

package/dist/server/index.js

@@ -14,6 +14,7 @@ const processConfig_1 = __importDefault(require("./routes/processConfig"));
 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 logStreaming_1 = require("./routes/logStreaming");
 const pm2_connection_1 = require("./utils/pm2-connection");
 const remote_connection_1 = require("./utils/remote-connection");
@@ -47,6 +48,7 @@ function createServer() {
     app.use('/api/deploy', deployApplication_1.default);
     app.use('/api/modules', modules_1.default);
     app.use('/api/remote', remoteConnections_1.default);
+    app.use('/api/cron-jobs', cronJobs_1.default);
     // Setup log streaming with Socket.IO
     (0, logStreaming_1.setupLogStreaming)(io); // PM2 API endpoints
     app.get('/api/processes', async (req, res) => {

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

@@ -0,0 +1,7 @@
+/**
+ * Cron Jobs API Routes
+ * Manages scheduled tasks using PM2's cron_restart feature
+ */
+import { Router } from 'express';
+declare const router: Router;
+export default router;

package/dist/server/routes/cronJobs.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Cron Jobs API Routes
+ * Manages scheduled tasks using PM2's cron_restart feature
+ */
+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 CronJobService_1 = __importDefault(require("../services/CronJobService"));
+const router = (0, express_1.Router)();
+/**
+ * GET /api/cron-jobs
+ * Get all cron jobs
+ */
+router.get('/', async (req, res) => {
+    try {
+        const jobs = CronJobService_1.default.getCronJobs();
+        res.json({ success: true, data: jobs });
+    }
+    catch (error) {
+        console.error('Error getting cron jobs:', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * GET /api/cron-jobs/status
+ * Get status of all cron jobs including PM2 process info
+ */
+router.get('/status', async (req, res) => {
+    try {
+        const statuses = await CronJobService_1.default.getCronJobsStatus();
+        res.json({ success: true, data: statuses });
+    }
+    catch (error) {
+        console.error('Error getting cron job statuses:', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * GET /api/cron-jobs/:id
+ * Get a specific cron job by ID
+ */
+router.get('/:id', (req, res) => {
+    try {
+        const job = CronJobService_1.default.getCronJob(req.params.id);
+        if (!job) {
+            return res.status(404).json({ success: false, error: 'Cron job not found' });
+        }
+        res.json({ success: true, data: job });
+    }
+    catch (error) {
+        console.error('Error getting cron job:', error);
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/cron-jobs
+ * Create a new cron job
+ */
+router.post('/', async (req, res) => {
+    try {
+        const config = req.body;
+        // Validate required fields
+        if (!config.name || !config.scriptType || !config.cronExpression) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required fields: name, scriptType, cronExpression'
+            });
+        }
+        // Validate script mode specific requirements
+        if (config.scriptMode === 'file' && !config.scriptPath) {
+            return res.status(400).json({
+                success: false,
+                error: 'Script path is required when using file mode'
+            });
+        }
+        if (config.scriptMode === 'inline' && !config.inlineScript) {
+            return res.status(400).json({
+                success: false,
+                error: 'Inline script content is required when using inline mode'
+            });
+        }
+        const job = await CronJobService_1.default.createCronJob(config);
+        res.json({ success: true, data: job });
+    }
+    catch (error) {
+        console.error('Error creating cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * PUT /api/cron-jobs/:id
+ * Update a cron job
+ */
+router.put('/:id', async (req, res) => {
+    try {
+        const updates = req.body;
+        const job = await CronJobService_1.default.updateCronJob(req.params.id, updates);
+        res.json({ success: true, data: job });
+    }
+    catch (error) {
+        console.error('Error updating cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * DELETE /api/cron-jobs/:id
+ * Delete a cron job
+ */
+router.delete('/:id', async (req, res) => {
+    try {
+        await CronJobService_1.default.deleteCronJob(req.params.id);
+        res.json({ success: true, message: 'Cron job deleted successfully' });
+    }
+    catch (error) {
+        console.error('Error deleting cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/cron-jobs/:id/toggle
+ * Toggle cron job enabled state
+ */
+router.post('/:id/toggle', async (req, res) => {
+    try {
+        const job = await CronJobService_1.default.toggleCronJob(req.params.id);
+        res.json({ success: true, data: job });
+    }
+    catch (error) {
+        console.error('Error toggling cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/cron-jobs/:id/start
+ * Manually start a cron job
+ */
+router.post('/:id/start', async (req, res) => {
+    try {
+        await CronJobService_1.default.startCronJob(req.params.id);
+        res.json({ success: true, message: 'Cron job started successfully' });
+    }
+    catch (error) {
+        console.error('Error starting cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/cron-jobs/:id/stop
+ * Manually stop a cron job
+ */
+router.post('/:id/stop', async (req, res) => {
+    try {
+        await CronJobService_1.default.stopCronJob(req.params.id);
+        res.json({ success: true, message: 'Cron job stopped successfully' });
+    }
+    catch (error) {
+        console.error('Error stopping cron job:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+/**
+ * POST /api/cron-jobs/validate
+ * Validate a cron expression
+ */
+router.post('/validate', (req, res) => {
+    try {
+        const { expression } = req.body;
+        if (!expression) {
+            return res.status(400).json({ success: false, error: 'Expression is required' });
+        }
+        const validation = CronJobService_1.default.validateCronExpression(expression);
+        const description = CronJobService_1.default.getCronDescription(expression);
+        res.json({
+            success: true,
+            data: {
+                ...validation,
+                description
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error validating cron expression:', error);
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+exports.default = router;

package/dist/server/routes/remoteConnections.js

@@ -606,6 +606,111 @@ router.post('/connections', (req, res) => {
         });
     }
 });
+/**
+ * Update an existing remote connection configuration
+ * PUT /api/remote/connections/:connectionId
+ */
+router.put('/connections/:connectionId', async (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const connectionConfig = req.body;
+        if (!connectionConfig.name || !connectionConfig.host || !connectionConfig.username) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required connection parameters: name, host, or username'
+            });
+        }
+        // Ensure port is set
+        if (!connectionConfig.port) {
+            connectionConfig.port = 22;
+        }
+        // Update the connection
+        const success = await remote_connection_1.remoteConnectionManager.updateConnection(connectionId, connectionConfig);
+        if (!success) {
+            return res.status(404).json({
+                success: false,
+                error: 'Connection not found'
+            });
+        }
+        res.json({
+            success: true,
+            message: 'Connection updated successfully'
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}`
+        });
+    }
+});
+/**
+ * Delete a remote connection configuration
+ * DELETE /api/remote/connections/:connectionId
+ */
+router.delete('/connections/:connectionId', async (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        // Close the connection if it's open
+        await remote_connection_1.remoteConnectionManager.closeConnection(connectionId);
+        // Delete the connection configuration
+        const success = remote_connection_1.remoteConnectionManager.deleteConnection(connectionId);
+        if (!success) {
+            return res.status(404).json({
+                success: false,
+                error: 'Connection not found'
+            });
+        }
+        res.json({
+            success: true,
+            message: 'Connection deleted successfully'
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: `Server error: ${error instanceof Error ? error.message : 'Unknown error'}`
+        });
+    }
+});
+/**
+ * Install PM2 on a remote server
+ * POST /api/remote/:connectionId/install-pm2
+ */
+router.post('/:connectionId/install-pm2', async (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const connection = remote_connection_1.remoteConnectionManager.getConnection(connectionId);
+        if (!connection) {
+            return res.status(404).json({
+                success: false,
+                error: 'Connection not found'
+            });
+        }
+        // Install PM2
+        const result = await connection.installPM2();
+        if (result.code === 0) {
+            res.json({
+                success: true,
+                message: 'PM2 installed successfully',
+                output: result.stdout
+            });
+        }
+        else {
+            res.status(400).json({
+                success: false,
+                error: 'Failed to install PM2',
+                output: result.stderr || result.stdout
+            });
+        }
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: `Failed to install PM2: ${error.message}`
+        });
+    }
+});
 /**
  * Delete a connection configuration
  * DELETE /api/remote/connections/:connectionId

package/dist/server/services/CronJobService.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Cron Job Service - Manages PM2 processes with cron_restart
+ */
+import { CronJobConfig, CronJobStatus } from '../../types/cron';
+export declare class CronJobService {
+    private static instance;
+    private constructor();
+    static getInstance(): CronJobService;
+    private ensureConfigFile;
+    private readConfig;
+    private writeConfig;
+    /**
+     * Validate cron expression
+     */
+    validateCronExpression(expression: string): {
+        valid: boolean;
+        error?: string;
+        nextRun?: Date;
+    };
+    /**
+     * Get human-readable description of cron expression
+     */
+    getCronDescription(expression: string): string;
+    /**
+     * Get script path for inline scripts (creates temp file)
+     */
+    private getScriptPath;
+    /**
+     * Get file extension for script type
+     */
+    private getScriptExtension;
+    /**
+     * Convert CronJobConfig to PM2 start options
+     */
+    private toPM2Options;
+    /**
+     * Create a new cron job
+     */
+    createCronJob(config: Omit<CronJobConfig, 'id' | 'createdAt' | 'updatedAt'>): Promise<CronJobConfig>;
+    /**
+     * Get all cron jobs
+     */
+    getCronJobs(): CronJobConfig[];
+    /**
+     * Get a single cron job by ID
+     */
+    getCronJob(id: string): CronJobConfig | undefined;
+    /**
+     * Update a cron job
+     */
+    updateCronJob(id: string, updates: Partial<CronJobConfig>): Promise<CronJobConfig>;
+    /**
+     * Delete a cron job
+     */
+    deleteCronJob(id: string): Promise<void>;
+    /**
+     * Start a cron job (start PM2 process with cron_restart)
+     */
+    startCronJob(id: string): Promise<void>;
+    /**
+     * Stop a cron job (delete PM2 process)
+     */
+    stopCronJob(id: string): Promise<void>;
+    /**
+     * Get status of all cron jobs (including PM2 process info)
+     */
+    getCronJobsStatus(): Promise<CronJobStatus[]>;
+    /**
+     * Toggle cron job enabled state
+     */
+    toggleCronJob(id: string): Promise<CronJobConfig>;
+}
+declare const _default: CronJobService;
+export default _default;