ezpm2gui 1.1.0 → 1.2.0

package/dist/server/utils/remote-connection.js

@@ -0,0 +1,590 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remoteConnectionManager = exports.RemoteConnectionManager = exports.RemoteConnection = void 0;
+const ssh2_1 = require("ssh2");
+const events_1 = require("events");
+/**
+ * Class to manage SSH connections to remote servers
+ */
+class RemoteConnection extends events_1.EventEmitter {
+    // Getters for secure access to authentication details
+    get hasPassword() {
+        return !!this.config.password;
+    }
+    get hasPrivateKey() {
+        return !!this.config.privateKey;
+    }
+    get hasPassphrase() {
+        return !!this.config.passphrase;
+    }
+    // Getter for secure config (without sensitive data)
+    get secureConfig() {
+        return {
+            name: this.name,
+            host: this.host,
+            port: this.port,
+            username: this.username
+        };
+    }
+    // Method to get the full config for use by connection manager
+    getFullConfig() {
+        return this.config;
+    }
+    constructor(config) {
+        super();
+        this._isConnected = false;
+        this.isPM2Installed = false;
+        this.client = new ssh2_1.Client();
+        this.config = config;
+        // Initialize public properties
+        this.name = config.name || config.host;
+        this.host = config.host;
+        this.port = config.port || 22;
+        this.username = config.username;
+    }
+    /**
+     * Check if the connection is active
+     */
+    isConnected() {
+        return this._isConnected;
+    }
+    /**
+     * Connect to the remote server
+     */ async connect() {
+        if (this._isConnected) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.client.on('ready', () => {
+                this._isConnected = true;
+                console.log(`Successfully connected to ${this.config.host}`);
+                this.emit('connected');
+                resolve();
+            });
+            this.client.on('error', (err) => {
+                this._isConnected = false;
+                console.error(`SSH connection error for ${this.config.host}:`, err.message);
+                reject(err);
+            });
+            this.client.on('end', () => {
+                this._isConnected = false;
+                console.log(`Disconnected from ${this.config.host}`);
+                this.emit('disconnected');
+            });
+            // Attempt connection with the provided configuration
+            const connectionConfig = {
+                host: this.config.host,
+                port: this.config.port || 22,
+                username: this.config.username,
+                // Add reasonable timeouts
+                readyTimeout: 10000,
+                keepaliveInterval: 30000
+            };
+            // Debug output
+            console.log(`Connecting to ${this.config.host}:${this.config.port} as ${this.config.username}`);
+            console.log(`Authentication methods available: ${this.config.password ? 'Password' : 'No password'}, ${this.config.privateKey ? 'Private key' : 'No private key'}`);
+            // Add authentication method
+            if (this.config.privateKey) {
+                connectionConfig.privateKey = this.config.privateKey;
+                if (this.config.passphrase) {
+                    connectionConfig.passphrase = this.config.passphrase;
+                }
+            }
+            else if (this.config.password) {
+                connectionConfig.password = this.config.password;
+            }
+            else {
+                console.error('No authentication method provided for', this.config.host);
+                return reject(new Error('No authentication method provided'));
+            }
+            this.client.connect(connectionConfig);
+        });
+    }
+    /**
+     * Disconnect from the remote server
+     */
+    disconnect() {
+        return new Promise((resolve) => {
+            if (!this._isConnected) {
+                resolve();
+                return;
+            }
+            this.client.once('end', () => {
+                this._isConnected = false;
+                resolve();
+            });
+            this.client.end();
+        });
+    } /**
+     * Execute a command on the remote server
+     * @param command The command to execute
+     * @param forceSudo Whether to force using sudo for this specific command
+     */
+    async executeCommand(command, forceSudo) {
+        // Connect if not already connected
+        if (!this._isConnected) {
+            await this.connect();
+        }
+        // Apply sudo if configured or explicitly requested for this command
+        const useElevatedPrivileges = forceSudo || this.config.useSudo;
+        let finalCommand = command;
+        // Only apply sudo if it's requested and we have a password
+        if (useElevatedPrivileges && this.config.password) {
+            finalCommand = `echo '${this.config.password}' | sudo -S ${command}`;
+        }
+        console.log(`Executing command: ${useElevatedPrivileges ? '[sudo] ' : ''}${command}`);
+        return new Promise((resolve, reject) => {
+            this.client.exec(finalCommand, (err, channel) => {
+                if (err) {
+                    console.error('Error executing command:', err);
+                    return reject(err);
+                }
+                let stdout = '';
+                let stderr = '';
+                let exitCode = null;
+                channel.on('data', (data) => {
+                    stdout += data.toString();
+                });
+                channel.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                });
+                channel.on('exit', (code) => {
+                    exitCode = code;
+                });
+                channel.on('close', () => {
+                    // Remove sudo password from stdout/stderr if present
+                    if (useElevatedPrivileges && this.config.password) {
+                        stdout = stdout.replace(this.config.password, '[PASSWORD REDACTED]');
+                        stderr = stderr.replace(this.config.password, '[PASSWORD REDACTED]');
+                    }
+                    resolve({
+                        stdout,
+                        stderr,
+                        code: exitCode
+                    });
+                });
+                channel.on('error', (err) => {
+                    console.error('Channel error:', err);
+                    reject(err);
+                });
+            });
+        });
+    }
+    /**
+     * Check if PM2 is installed on the remote server
+     */
+    async checkPM2Installation() {
+        try {
+            const result = await this.executeCommand('which pm2 || echo "not installed"');
+            this.isPM2Installed = !result.stdout.includes('not installed');
+            return this.isPM2Installed;
+        }
+        catch (error) {
+            this.isPM2Installed = false;
+            return false;
+        }
+    }
+    /**
+     * Get PM2 processes from the remote server
+     */
+    async getPM2Processes() {
+        try {
+            // Connect if not already connected
+            if (!this._isConnected) {
+                await this.connect();
+            }
+            // Check if PM2 is installed
+            if (!this.isPM2Installed) {
+                const isPM2Installed = await this.checkPM2Installation();
+                if (!isPM2Installed) {
+                    throw new Error('PM2 is not installed on the remote server');
+                }
+            }
+            const result = await this.executeCommand('pm2 jlist');
+            // Clean the output to ensure it's valid JSON
+            // Sometimes pm2 jlist can include non-JSON data at the beginning or end
+            let cleanedOutput = result.stdout.trim();
+            // Find the beginning of the JSON array
+            const startIndex = cleanedOutput.indexOf('[');
+            // Find the end of the JSON array
+            const endIndex = cleanedOutput.lastIndexOf(']') + 1;
+            if (startIndex === -1 || endIndex === 0) {
+                console.log('Invalid PM2 output format, trying alternative approach');
+                // Try using pm2 list --format=json instead
+                const listResult = await this.executeCommand('pm2 list --format=json');
+                cleanedOutput = listResult.stdout.trim();
+            }
+            else if (startIndex > 0 || endIndex < cleanedOutput.length) {
+                // Extract just the JSON array part
+                cleanedOutput = cleanedOutput.substring(startIndex, endIndex);
+            }
+            try {
+                const processList = JSON.parse(cleanedOutput);
+                // Format process data similar to local PM2 format
+                return processList.map((proc) => ({
+                    name: proc.name,
+                    pm_id: proc.pm_id,
+                    status: proc.pm2_env ? proc.pm2_env.status : 'unknown',
+                    cpu: proc.monit ? (proc.monit.cpu || 0).toFixed(1) : '0.0',
+                    memory: proc.monit ? this.formatMemory(proc.monit.memory) : '0 B',
+                    uptime: proc.pm2_env ? this.formatUptime(proc.pm2_env.pm_uptime) : 'N/A',
+                    restarts: proc.pm2_env ? (proc.pm2_env.restart_time || 0) : 0
+                }));
+            }
+            catch (error) {
+                console.error('Error parsing PM2 process list:', error);
+                console.log('Raw output:', result.stdout);
+                // Return an empty array instead of throwing
+                return [];
+            }
+        }
+        catch (error) {
+            console.error('Error getting PM2 processes:', error);
+            throw error;
+        }
+    }
+    /**
+     * Format memory size to human readable format
+     */
+    formatMemory(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(1024));
+        return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    /**
+     * Format uptime to human readable format
+     */ formatUptime(timestamp) {
+        if (!timestamp || isNaN(timestamp))
+            return 'N/A';
+        try {
+            const uptime = Date.now() - timestamp;
+            if (uptime < 0)
+                return 'N/A'; // Invalid timestamp
+            const seconds = Math.floor(uptime / 1000);
+            if (seconds < 60) {
+                return `${seconds}s`;
+            }
+            else if (seconds < 3600) {
+                return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+            }
+            else if (seconds < 86400) {
+                const hours = Math.floor(seconds / 3600);
+                const mins = Math.floor((seconds % 3600) / 60);
+                return `${hours}h ${mins}m`;
+            }
+            else {
+                const days = Math.floor(seconds / 86400);
+                const hours = Math.floor((seconds % 86400) / 3600);
+                return `${days}d ${hours}h`;
+            }
+        }
+        catch (error) {
+            console.error('Error formatting uptime:', error);
+            return 'N/A';
+        }
+    }
+    /**
+     * Start a PM2 process
+     */
+    async startPM2Process(processName) {
+        return await this.executeCommand(`pm2 start ${processName}`);
+    }
+    /**
+     * Stop a PM2 process
+     */
+    async stopPM2Process(processName) {
+        return await this.executeCommand(`pm2 stop ${processName}`);
+    }
+    /**
+     * Restart a PM2 process
+     */
+    async restartPM2Process(processName) {
+        return await this.executeCommand(`pm2 restart ${processName}`);
+    }
+    /**
+     * Delete a PM2 process
+     */
+    async deletePM2Process(processName) {
+        return await this.executeCommand(`pm2 delete ${processName}`);
+    }
+    /**
+     * Get system information from the remote server
+     */
+    async getSystemInfo() {
+        try {
+            // Connect if not already connected
+            if (!this._isConnected) {
+                await this.connect();
+            }
+            // Run a series of commands to get system information
+            const [hostname, platform, arch, nodeVersion, memInfo, cpuInfo] = await Promise.all([
+                this.executeCommand('hostname'),
+                this.executeCommand('uname -s'),
+                this.executeCommand('uname -m'),
+                this.executeCommand('node -v'),
+                this.executeCommand('free -b'),
+                this.executeCommand('cat /proc/cpuinfo | grep processor | wc -l')
+            ]);
+            // Parse memory information
+            const memLines = memInfo.stdout.split('\n');
+            let totalMemory = 0;
+            let freeMemory = 0;
+            if (memLines.length > 1) {
+                const memValues = memLines[1].split(/\s+/);
+                if (memValues.length > 6) {
+                    totalMemory = parseInt(memValues[1], 10);
+                    freeMemory = parseInt(memValues[3], 10);
+                }
+            }
+            // Get load average
+            const loadAvgResult = await this.executeCommand('cat /proc/loadavg');
+            const loadAvg = loadAvgResult.stdout.trim().split(' ').slice(0, 3).map(parseFloat);
+            return {
+                hostname: hostname.stdout.trim(),
+                platform: platform.stdout.trim(),
+                arch: arch.stdout.trim(),
+                nodeVersion: nodeVersion.stdout.trim(),
+                totalMemory: this.formatMemory(totalMemory),
+                freeMemory: this.formatMemory(freeMemory),
+                cpuCount: parseInt(cpuInfo.stdout.trim(), 10),
+                loadAverage: loadAvg
+            };
+        }
+        catch (error) {
+            console.error('Error getting system info:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get logs for a PM2 process
+     */
+    async getPM2Logs(processName, lines = 100) {
+        return await this.executeCommand(`pm2 logs ${processName} --lines ${lines} --nostream`);
+    } /**
+     * Create a streaming log connection for a command
+     */
+    async createLogStream(command, useSudo = false) {
+        if (!this._isConnected) {
+            throw new Error('Connection not established');
+        }
+        let finalCommand = command;
+        let isInitialized = false;
+        // Apply sudo if requested and we have a password
+        if (useSudo && this.config.useSudo && this.config.password) {
+            // Use echo to pipe the password to sudo for streaming commands
+            finalCommand = `echo '${this.config.password}' | sudo -S ${command}`;
+        }
+        console.log(`[createLogStream] Executing command: ${finalCommand.replace(this.config.password || '', '[PASSWORD]')}`);
+        return new Promise((resolve, reject) => {
+            this.client.exec(finalCommand, (err, stream) => {
+                var _a;
+                if (err) {
+                    console.error(`[createLogStream] Exec error:`, err);
+                    reject(err);
+                    return;
+                }
+                const logEmitter = new events_1.EventEmitter();
+                stream.on('data', (data) => {
+                    const dataStr = data.toString();
+                    console.log(`[createLogStream] Raw data:`, dataStr);
+                    // Skip the sudo password prompt and initial setup messages
+                    if (!isInitialized) {
+                        if (dataStr.includes('[sudo] password') ||
+                            dataStr.includes('Password:') ||
+                            dataStr.trim() === '') {
+                            return; // Skip initialization messages
+                        }
+                        isInitialized = true;
+                    }
+                    logEmitter.emit('data', dataStr);
+                });
+                (_a = stream.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                    const dataStr = data.toString();
+                    console.log(`[createLogStream] Stderr data:`, dataStr);
+                    // Don't emit stderr data for sudo prompts or permission messages
+                    if (!dataStr.includes('[sudo] password') &&
+                        !dataStr.includes('Password:') &&
+                        !dataStr.includes('Sorry, try again')) {
+                        logEmitter.emit('data', dataStr);
+                    }
+                });
+                stream.on('close', (code) => {
+                    console.log(`[createLogStream] Stream closed with code:`, code);
+                    logEmitter.emit('close', code);
+                });
+                stream.on('error', (error) => {
+                    console.error(`[createLogStream] Stream error:`, error);
+                    logEmitter.emit('error', error);
+                });
+                // Add a method to kill the stream
+                logEmitter.kill = () => {
+                    console.log(`[createLogStream] Killing stream`);
+                    stream.close();
+                };
+                resolve(logEmitter);
+            });
+        });
+    }
+}
+exports.RemoteConnection = RemoteConnection;
+/**
+ * Connection manager to handle multiple remote connections
+ */
+class RemoteConnectionManager {
+    constructor() {
+        this.connections = new Map();
+        this.configFilePath = 'D:/Personal/ezpm2gui/src/server/config/remote-connections.json';
+        this.loadConnectionsFromDisk();
+    }
+    /**
+     * Create a new remote connection
+     * @param config Connection configuration
+     * @returns The connection ID
+     */
+    createConnection(config) {
+        const connectionId = `${config.host}-${config.port}-${config.username}`;
+        if (this.connections.has(connectionId)) {
+            return connectionId;
+        }
+        const connection = new RemoteConnection(config);
+        this.connections.set(connectionId, connection);
+        // Save the updated connections to disk
+        this.saveConnectionsToDisk();
+        return connectionId;
+    }
+    /**
+     * Get a connection by ID
+     * @param connectionId The connection ID
+     */
+    getConnection(connectionId) {
+        return this.connections.get(connectionId);
+    }
+    /**
+     * Close a connection by ID (disconnect but keep the configuration)
+     * @param connectionId The connection ID
+     */
+    async closeConnection(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+            await connection.disconnect();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Close all connections
+     */ async closeAllConnections() {
+        const closePromises = Array.from(this.connections.values()).map((conn) => conn.disconnect());
+        await Promise.all(closePromises);
+        this.connections.clear();
+    }
+    /**
+     * Get all connections
+     * @returns Map of all connections
+     */
+    getAllConnections() {
+        return this.connections;
+    }
+    /**
+   * Delete a connection by ID
+   * @param connectionId The connection ID
+   * @returns True if the connection was deleted, false if it didn't exist
+   */
+    deleteConnection(connectionId) {
+        const deleted = this.connections.delete(connectionId);
+        if (deleted) {
+            // Save the updated connections to disk
+            this.saveConnectionsToDisk();
+        }
+        return deleted;
+    }
+    /**
+     * Load connection configurations from disk
+     */
+    loadConnectionsFromDisk() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const { decrypt } = require('./encryption');
+            // Ensure the config directory exists
+            const configDir = path.dirname(this.configFilePath);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            // Create the file with default content if it doesn't exist
+            if (!fs.existsSync(this.configFilePath)) {
+                fs.writeFileSync(this.configFilePath, JSON.stringify({ connections: [] }, null, 2));
+            }
+            // Read the configuration file
+            const data = fs.readFileSync(this.configFilePath, 'utf8');
+            const config = JSON.parse(data);
+            if (config && Array.isArray(config.connections)) {
+                // Create connections from saved configs
+                config.connections.forEach((conn) => {
+                    const connectionConfig = {
+                        name: conn.name,
+                        host: conn.host,
+                        port: conn.port,
+                        username: conn.username,
+                        // Decrypt sensitive data if it exists
+                        password: conn.password ? decrypt(conn.password) : undefined,
+                        privateKey: conn.privateKey ? decrypt(conn.privateKey) : undefined,
+                        passphrase: conn.passphrase ? decrypt(conn.passphrase) : undefined,
+                        useSudo: conn.useSudo
+                    };
+                    // Re-create the connection with the original ID
+                    const connection = new RemoteConnection(connectionConfig);
+                    this.connections.set(conn.id, connection);
+                });
+                console.log(`Loaded ${config.connections.length} remote connections from disk`);
+            }
+        }
+        catch (error) {
+            console.error('Error loading remote connections from disk:', error);
+        }
+    }
+    /**
+   * Save connection configurations to disk
+   */
+    saveConnectionsToDisk() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const { encrypt } = require('./encryption');
+            // Ensure the config directory exists
+            const configDir = path.dirname(this.configFilePath);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            // Convert connections map to serializable array with encrypted sensitive data
+            const savedConnections = Array.from(this.connections.entries()).map(([id, conn]) => {
+                // Get the original configuration to access sensitive data
+                const config = conn.getFullConfig();
+                return {
+                    id,
+                    name: conn.name,
+                    host: conn.host,
+                    port: conn.port,
+                    username: conn.username,
+                    password: config.password ? encrypt(config.password) : undefined,
+                    privateKey: config.privateKey ? encrypt(config.privateKey) : undefined,
+                    passphrase: config.passphrase ? encrypt(config.passphrase) : undefined,
+                    useSudo: config.useSudo
+                };
+            });
+            // Write to file
+            fs.writeFileSync(this.configFilePath, JSON.stringify({
+                connections: savedConnections
+            }, null, 2));
+            console.log(`Saved ${savedConnections.length} remote connections to disk`);
+        }
+        catch (error) {
+            console.error('Error saving remote connections to disk:', error);
+        }
+    }
+}
+exports.RemoteConnectionManager = RemoteConnectionManager;
+// Create a singleton instance of the connection manager
+exports.remoteConnectionManager = new RemoteConnectionManager();

package/dist/server/utils/upload.d.ts

@@ -0,0 +1,3 @@
+import multer from 'multer';
+declare const upload: multer.Multer;
+export default upload;

package/dist/server/utils/upload.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const multer_1 = __importDefault(require("multer"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Create uploads directory if it doesn't exist
+const uploadsDir = path_1.default.join(process.cwd(), 'uploads');
+if (!fs_1.default.existsSync(uploadsDir)) {
+    fs_1.default.mkdirSync(uploadsDir, { recursive: true });
+}
+// Configure multer for file upload
+const storage = multer_1.default.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, uploadsDir);
+    },
+    filename: function (req, file, cb) {
+        // Use original filename to preserve extension
+        cb(null, file.originalname);
+    }
+});
+// Create the multer instance
+const upload = (0, multer_1.default)({
+    storage: storage,
+    fileFilter: (req, file, cb) => {
+        // Allow only JavaScript and TypeScript files
+        const allowedExtensions = ['.js', '.ts', '.mjs', '.cjs'];
+        const ext = path_1.default.extname(file.originalname).toLowerCase();
+        if (allowedExtensions.includes(ext)) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error('Only JavaScript and TypeScript files are allowed'));
+        }
+    }
+});
+exports.default = upload;