ezpm2gui 1.6.0 → 1.8.0

package/dist/server/routes/deployApplication.js

@@ -9,60 +9,69 @@ 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
+// Deploy a new application (SSE streaming)
 router.post('/', async (req, res) => {
     const { name, script, cwd, namespace, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
-    // Validate required fields
+    // Validate required fields before starting SSE
     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}` });
     }
+    // Switch to SSE
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const send = (type, data) => {
+        if (!res.writableEnded) {
+            res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+        }
+    };
+    const log = (message) => send('log', { message });
+    const done = (success, extra = {}) => {
+        send('done', { success, ...extra });
+        res.end();
+    };
     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 setupResult = null;
+        // Auto-detect project type
         let detectedType = appType;
         if (!detectedType) {
             detectedType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
             if (detectedType) {
-                console.log(`Auto-detected project type: ${detectedType}`);
+                log(`Auto-detected project type: ${detectedType}`);
             }
         }
-        // Run project setup if auto-setup is enabled and project type is detected
+        // Run project setup
         if (autoSetup && detectedType && ['node', 'python', 'dotnet'].includes(detectedType)) {
-            console.log(`Running setup for ${detectedType} project...`);
+            log(`Running ${detectedType} project setup...`);
             try {
-                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType);
+                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType, log);
                 if (!setupResult.success) {
-                    return res.status(500).json({
+                    return done(false, {
                         error: 'Project setup failed',
                         details: setupResult.errors,
-                        warnings: setupResult.warnings,
-                        steps: setupResult.steps
+                        warnings: setupResult.warnings
                     });
                 }
-                // 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({
+                return done(false, {
                     error: 'Project setup failed',
                     details: setupError instanceof Error ? setupError.message : 'Unknown setup error'
                 });
             }
         }
-        // Create deployment configuration
+        // Build PM2 config
         const appConfig = {
             name,
             script,
@@ -75,45 +84,38 @@ router.post('/', async (req, res) => {
             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
+        log(`Starting PM2 process: ${name}`);
+        await new Promise((resolve, reject) => {
+            pm2_1.default.connect((err) => {
+                if (err)
+                    return reject(err);
+                pm2_1.default.start(appConfig, (startErr) => {
+                    pm2_1.default.disconnect();
+                    if (startErr)
+                        return reject(startErr);
+                    resolve();
                 });
             });
         });
+        log(`Process "${name}" started successfully.`);
+        done(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({
+        done(false, {
             error: 'Deployment failed',
             details: error instanceof Error ? error.message : 'Unknown error'
         });
@@ -159,8 +161,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');
@@ -213,8 +215,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

@@ -7,7 +7,6 @@ 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
@@ -18,7 +17,7 @@ const getLogStream = (io, processId, logType) => {
     const streamKey = `${processId}-${logType}`;
     // If stream already exists, return it
     if (activeStreams[streamKey]) {
-        return activeStreams[streamKey];
+        return Promise.resolve(activeStreams[streamKey]);
     }
     return new Promise((resolve, reject) => {
         pm2_1.default.describe(processId, (err, processDesc) => {
@@ -32,30 +31,38 @@ const getLogStream = (io, processId, logType) => {
                 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 only to clients subscribed to this specific log stream
-                    io.to(streamKey).emit('log-line', {
-                        processId,
-                        logType,
-                        line
+            // Cross-platform tail using fs.watch — no Unix `tail` binary needed
+            let position = fs_1.default.statSync(logPath).size; // start at EOF, don't replay history
+            const watcher = fs_1.default.watch(logPath, (eventType) => {
+                if (eventType !== 'change')
+                    return;
+                try {
+                    const stat = fs_1.default.statSync(logPath);
+                    // Handle log rotation / truncation
+                    if (stat.size < position)
+                        position = 0;
+                    if (stat.size === position)
+                        return;
+                    const length = stat.size - position;
+                    const buffer = Buffer.alloc(length);
+                    const fd = fs_1.default.openSync(logPath, 'r');
+                    fs_1.default.readSync(fd, buffer, 0, length, position);
+                    fs_1.default.closeSync(fd);
+                    position = stat.size;
+                    const lines = buffer.toString('utf8').split('\n').filter((l) => l.trim() !== '');
+                    lines.forEach((line) => {
+                        io.to(streamKey).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];
+                }
+                catch (e) {
+                    console.error('Error reading log file:', e);
+                }
             });
-            // Store the tail process
-            activeStreams[streamKey] = tail;
-            resolve(tail);
+            watcher.on('error', (e) => console.error(`Watcher error for ${streamKey}:`, e));
+            // Expose a kill() so existing cleanup code works unchanged
+            const streamObj = { kill: () => { watcher.close(); delete activeStreams[streamKey]; } };
+            activeStreams[streamKey] = streamObj;
+            resolve(streamObj);
         });
     });
 };

package/dist/server/routes/modules.js

@@ -5,6 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const pm2_1 = __importDefault(require("pm2"));
 const pm2_connection_1 = require("../utils/pm2-connection");
 const router = (0, express_1.Router)();
@@ -123,4 +126,56 @@ router.delete('/:moduleName', async (req, res) => {
         });
     }
 });
+// @group Utilities : Resolve ~/.pm2/module_conf.json path
+const moduleConfPath = () => path_1.default.join(os_1.default.homedir(), '.pm2', 'module_conf.json');
+// @group APIEndpoints : Get config for a specific installed module
+router.get('/:moduleName/config', (req, res) => {
+    var _a;
+    const { moduleName } = req.params;
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    const confFile = moduleConfPath();
+    if (!fs_1.default.existsSync(confFile)) {
+        return res.json({ config: {} });
+    }
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(confFile, 'utf8'));
+        // PM2 stores module config under the module name key
+        const config = (_a = raw[moduleName]) !== null && _a !== void 0 ? _a : {};
+        res.json({ config });
+    }
+    catch {
+        res.status(500).json({ error: 'Failed to read module configuration' });
+    }
+});
+// @group APIEndpoints : Set one or more config keys for an installed module
+router.put('/:moduleName/config', async (req, res) => {
+    const { moduleName } = req.params;
+    const { config } = req.body;
+    if (!/^[@a-zA-Z0-9/_\-.]+$/.test(moduleName)) {
+        return res.status(400).json({ error: 'Invalid module name' });
+    }
+    if (!config || typeof config !== 'object') {
+        return res.status(400).json({ error: 'config object is required' });
+    }
+    // Validate all keys — no shell metacharacters
+    for (const key of Object.keys(config)) {
+        if (!/^[a-zA-Z0-9_\-.]+$/.test(key)) {
+            return res.status(400).json({ error: `Invalid config key: ${key}` });
+        }
+    }
+    try {
+        // Run pm2 set for each key sequentially
+        for (const [key, value] of Object.entries(config)) {
+            // Wrap value in quotes to handle spaces; strip any embedded quotes first
+            const safeValue = String(value).replace(/"/g, '');
+            await runPM2CLI(`set ${moduleName}:${key} "${safeValue}"`);
+        }
+        res.json({ success: true, message: `Configuration updated for ${moduleName}` });
+    }
+    catch (error) {
+        res.status(500).json({ error: 'Failed to update configuration', details: error.message });
+    }
+});
 exports.default = router;

package/dist/server/routes/pageAuth.js

@@ -96,14 +96,14 @@ router.post('/verify', (req, res) => {
     const config = loadAuthConfig();
     if (!config) {
         // No password set — treat as unlocked
-        return res.json({ success: true });
+        return res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
     }
     const hash = hashPassword(password, config.salt);
     const match = crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(config.hash, 'hex'));
     if (!match) {
         return res.status(401).json({ success: false, error: 'Incorrect password' });
     }
-    res.json({ success: true });
+    res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
 });
 // @group Endpoints : DELETE /api/auth/remove — remove the password (requires current password)
 router.delete('/remove', (req, res) => {
@@ -153,7 +153,7 @@ router.post('/pin/verify', (req, res) => {
     if (!match) {
         return res.status(401).json({ success: false, error: 'Incorrect PIN' });
     }
-    res.json({ success: true });
+    res.json({ success: true, token: crypto_1.default.randomBytes(32).toString('hex') });
 });
 // @group Endpoints : DELETE /api/auth/pin/remove — remove PIN (requires current password)
 router.delete('/pin/remove', (req, res) => {

package/dist/server/routes/remoteConnections.js

@@ -819,15 +819,19 @@ router.get('/:connectionId/log-file/download', async (req, res) => {
 router.get('/connections', async (req, res) => {
     try {
         const connections = remote_connection_1.remoteConnectionManager.getAllConnections();
-        const connectionsList = Array.from(connections.entries()).map(([id, conn]) => ({
-            id,
-            name: conn.name || `${conn.username}@${conn.host}`,
-            host: conn.host,
-            port: conn.port,
-            username: conn.username,
-            connected: conn.isConnected(),
-            isPM2Installed: conn.isPM2Installed
-        }));
+        const connectionsList = Array.from(connections.entries()).map(([id, conn]) => {
+            const connected = conn.isConnected();
+            return {
+                id,
+                name: conn.name || `${conn.username}@${conn.host}`,
+                host: conn.host,
+                port: conn.port,
+                username: conn.username,
+                connected,
+                isPM2Installed: conn.isPM2Installed,
+                status: connected ? 'connected' : 'disconnected',
+            };
+        });
         res.json(connectionsList);
     }
     catch (error) {

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

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

package/dist/server/routes/remoteMetrics.js

@@ -0,0 +1,84 @@
+"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 = __importDefault(require("express"));
+const remote_metrics_db_1 = require("../utils/remote-metrics-db");
+const router = express_1.default.Router();
+// @group Constants : Default and maximum query bounds
+const DEFAULT_RANGE_MS = 3600000; // 1 hour
+const MAX_RANGE_MS = 7 * 24 * 3600000; // 7 days
+const MAX_POINTS = 500;
+// @group Utilities : Parse and clamp a query-string integer
+const parseIntParam = (raw, fallback, min, max) => {
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(min, Math.min(max, n));
+};
+/**
+ * List all remote connections that have recorded metrics
+ * GET /api/remote-metrics/connections
+ */
+router.get('/connections', (_req, res) => {
+    try {
+        const connections = remote_metrics_db_1.remoteMetricsDB.getConnectionsWithData();
+        res.json({ success: true, connections });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * List all process names recorded for a connection
+ * GET /api/remote-metrics/:connectionId/processes
+ */
+router.get('/:connectionId/processes', (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const names = remote_metrics_db_1.remoteMetricsDB.getProcessNames(connectionId);
+        res.json({ success: true, processes: names });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * Latest snapshot (most recent metric point per process) for a connection
+ * GET /api/remote-metrics/:connectionId/snapshot
+ */
+router.get('/:connectionId/snapshot', (req, res) => {
+    try {
+        const { connectionId } = req.params;
+        const snapshot = remote_metrics_db_1.remoteMetricsDB.getLatestSnapshot(connectionId);
+        res.json({ success: true, snapshot });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+/**
+ * Time-series metrics for one process on a connection
+ * GET /api/remote-metrics/:connectionId/:processName
+ *   ?from=<unix-ms>  (default: now - 1h)
+ *   ?to=<unix-ms>    (default: now)
+ *   ?maxPoints=<n>   (default: 500, max: 1000)
+ */
+router.get('/:connectionId/:processName', (req, res) => {
+    try {
+        const { connectionId, processName } = req.params;
+        const now = Date.now();
+        const to = parseIntParam(req.query.to, now, 0, now + 60000);
+        const from = parseIntParam(req.query.from, to - DEFAULT_RANGE_MS, 0, now);
+        // Clamp range to max window
+        const clampedFrom = Math.max(from, to - MAX_RANGE_MS);
+        const maxPoints = parseIntParam(req.query.maxPoints, MAX_POINTS, 50, 1000);
+        const metrics = remote_metrics_db_1.remoteMetricsDB.getMetrics(connectionId, processName, clampedFrom, to, maxPoints);
+        res.json({ success: true, metrics });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+exports.default = router;

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

@@ -62,7 +62,7 @@ export declare class ProjectSetupService {
     private ensureLogDirectory;
     private log;
     detectProjectType(projectPath: string): string | null;
-    setupProject(projectPath: string, projectType: string): Promise<SetupResult>;
+    setupProject(projectPath: string, projectType: string, onLog?: (msg: string) => void): Promise<SetupResult>;
     private shouldSkipStep;
     private executeStep;
     private validateSetup;

package/dist/server/services/ProjectSetupService.js

@@ -78,8 +78,9 @@ class ProjectSetupService {
         this.log('Could not detect project type');
         return null;
     }
-    async setupProject(projectPath, projectType) {
+    async setupProject(projectPath, projectType, onLog) {
         this.log(`Starting setup for ${projectType} project at: ${projectPath}`);
+        onLog === null || onLog === void 0 ? void 0 : onLog(`Starting ${projectType} project setup at: ${projectPath}`);
         const config = this.configs[projectType];
         if (!config) {
             throw new Error(`Unknown project type: ${projectType}`);
@@ -96,6 +97,7 @@ class ProjectSetupService {
             try {
                 // Check if step should be skipped
                 if (this.shouldSkipStep(step, projectPath)) {
+                    onLog === null || onLog === void 0 ? void 0 : onLog(`[SKIP] ${step.name}`);
                     result.steps.push({
                         name: step.name,
                         success: true,
@@ -106,24 +108,31 @@ class ProjectSetupService {
                     continue;
                 }
                 this.log(`Executing step: ${step.name}`);
-                const stepResult = await this.executeStep(step, projectPath, result.environment);
+                onLog === null || onLog === void 0 ? void 0 : onLog(`\n[STEP] ${step.name}`);
+                const stepResult = await this.executeStep(step, projectPath, result.environment, onLog);
                 const duration = Date.now() - stepStart;
                 result.steps.push({
                     ...stepResult,
                     duration
                 });
                 if (!stepResult.success && step.required) {
+                    onLog === null || onLog === void 0 ? void 0 : onLog(`[ERROR] Step failed: ${step.name}`);
                     result.success = false;
                     result.errors.push(`Required step failed: ${step.name} - ${stepResult.error}`);
                     break;
                 }
                 else if (!stepResult.success) {
+                    onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] Optional step failed: ${step.name}`);
                     result.warnings.push(`Optional step failed: ${step.name} - ${stepResult.error}`);
                 }
+                else {
+                    onLog === null || onLog === void 0 ? void 0 : onLog(`[OK] ${step.name} completed (${duration}ms)`);
+                }
             }
             catch (error) {
                 const duration = Date.now() - stepStart;
                 const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[ERROR] ${step.name}: ${errorMessage}`);
                 result.steps.push({
                     name: step.name,
                     success: false,
@@ -152,13 +161,13 @@ class ProjectSetupService {
                 result.environment.PYTHON_INTERPRETER = venvPath;
             }
         }
-        // Validate the setup
+        // Validate the setup (advisory only — step success/failure is the real gate)
         const validationResult = await this.validateSetup(projectPath, config);
         if (!validationResult.success) {
-            result.success = false;
-            result.errors.push(...validationResult.errors);
+            result.warnings.push(...validationResult.errors);
         }
         this.log(`Setup completed. Success: ${result.success}`);
+        onLog === null || onLog === void 0 ? void 0 : onLog(`\nSetup ${result.success ? 'completed successfully' : 'failed'}.`);
         return result;
     }
     shouldSkipStep(step, projectPath) {
@@ -216,7 +225,7 @@ class ProjectSetupService {
         }
         return false;
     }
-    async executeStep(step, projectPath, environment) {
+    async executeStep(step, projectPath, environment, onLog) {
         const workingDir = step.workingDirectory === 'project' ? projectPath : process.cwd();
         let command = step.command;
         // Handle virtual environment activation for Python
@@ -245,13 +254,20 @@ class ProjectSetupService {
             (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
                 const text = data.toString();
                 output += text;
-                // Log real-time output for debugging
-                console.log(`[${step.name}] ${text.trim()}`);
+                for (const line of text.split('\n')) {
+                    const trimmed = line.trim();
+                    if (trimmed)
+                        onLog === null || onLog === void 0 ? void 0 : onLog(trimmed);
+                }
             });
             (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
                 const text = data.toString();
                 error += text;
-                console.error(`[${step.name}] ERROR: ${text.trim()}`);
+                for (const line of text.split('\n')) {
+                    const trimmed = line.trim();
+                    if (trimmed)
+                        onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] ${trimmed}`);
+                }
             });
             child.on('close', (code) => {
                 const success = code === 0;

package/dist/server/utils/metrics-history.d.ts

@@ -0,0 +1,21 @@
+export interface MetricPoint {
+    timestamp: number;
+    cpu: number;
+    memory: number;
+    memoryMB: number;
+    memoryPercent: number;
+}
+export interface ProcessHistory {
+    pm_id: number;
+    name: string;
+    status: string;
+    history: MetricPoint[];
+}
+declare class MetricsHistoryStore {
+    private readonly store;
+    record(processList: any[]): void;
+    getOne(pm_id: number): ProcessHistory | null;
+    getAll(): ProcessHistory[];
+}
+export declare const metricsHistory: MetricsHistoryStore;
+export {};