ezpm2gui 1.0.0 → 1.2.0

package/dist/server/services/ProjectSetupService.js

@@ -0,0 +1,327 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSetupService = exports.ProjectSetupService = void 0;
+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 util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class ProjectSetupService {
+    constructor() {
+        this.loadConfigs();
+        this.logFile = path_1.default.join(__dirname, '../logs/deployment.log');
+        this.ensureLogDirectory();
+    }
+    loadConfigs() {
+        try {
+            const configPath = path_1.default.join(__dirname, '../config/project-configs.json');
+            const configData = fs_1.default.readFileSync(configPath, 'utf8');
+            const parsedConfig = JSON.parse(configData);
+            this.configs = parsedConfig.projectTypes;
+        }
+        catch (error) {
+            console.error('Failed to load project configurations:', error);
+            this.configs = {};
+        }
+    }
+    ensureLogDirectory() {
+        const logDir = path_1.default.dirname(this.logFile);
+        if (!fs_1.default.existsSync(logDir)) {
+            fs_1.default.mkdirSync(logDir, { recursive: true });
+        }
+    }
+    log(message) {
+        const timestamp = new Date().toISOString();
+        const logMessage = `[${timestamp}] ${message}\n`;
+        console.log(message);
+        try {
+            fs_1.default.appendFileSync(this.logFile, logMessage);
+        }
+        catch (error) {
+            console.error('Failed to write to log file:', error);
+        }
+    }
+    detectProjectType(projectPath) {
+        this.log(`Detecting project type for: ${projectPath}`);
+        for (const [type, config] of Object.entries(this.configs)) {
+            // Check for specific files
+            for (const file of config.detection.files) {
+                const filePath = path_1.default.join(projectPath, file);
+                if (fs_1.default.existsSync(filePath)) {
+                    this.log(`Detected ${type} project based on file: ${file}`);
+                    return type;
+                }
+            }
+            // Check for file patterns (e.g., *.csproj)
+            if (config.detection.files.some(file => file.includes('*'))) {
+                try {
+                    const files = fs_1.default.readdirSync(projectPath);
+                    for (const pattern of config.detection.files) {
+                        if (pattern.includes('*')) {
+                            const extension = pattern.replace('*', '');
+                            if (files.some(file => file.endsWith(extension))) {
+                                this.log(`Detected ${type} project based on pattern: ${pattern}`);
+                                return type;
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Directory doesn't exist or can't be read
+                }
+            }
+        }
+        this.log('Could not detect project type');
+        return null;
+    }
+    async setupProject(projectPath, projectType) {
+        this.log(`Starting setup for ${projectType} project at: ${projectPath}`);
+        const config = this.configs[projectType];
+        if (!config) {
+            throw new Error(`Unknown project type: ${projectType}`);
+        }
+        const result = {
+            success: true,
+            steps: [],
+            errors: [],
+            warnings: [],
+            environment: { ...config.setup.environment }
+        };
+        for (const step of config.setup.steps) {
+            const stepStart = Date.now();
+            try {
+                // Check if step should be skipped
+                if (this.shouldSkipStep(step, projectPath)) {
+                    result.steps.push({
+                        name: step.name,
+                        success: true,
+                        output: 'Skipped - condition not met',
+                        skipped: true,
+                        duration: 0
+                    });
+                    continue;
+                }
+                this.log(`Executing step: ${step.name}`);
+                const stepResult = await this.executeStep(step, projectPath, result.environment);
+                const duration = Date.now() - stepStart;
+                result.steps.push({
+                    ...stepResult,
+                    duration
+                });
+                if (!stepResult.success && step.required) {
+                    result.success = false;
+                    result.errors.push(`Required step failed: ${step.name} - ${stepResult.error}`);
+                    break;
+                }
+                else if (!stepResult.success) {
+                    result.warnings.push(`Optional step failed: ${step.name} - ${stepResult.error}`);
+                }
+            }
+            catch (error) {
+                const duration = Date.now() - stepStart;
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                result.steps.push({
+                    name: step.name,
+                    success: false,
+                    output: '',
+                    error: errorMessage,
+                    duration
+                });
+                if (step.required) {
+                    result.success = false;
+                    result.errors.push(`Required step failed: ${step.name} - ${errorMessage}`);
+                    break;
+                }
+                else {
+                    result.warnings.push(`Optional step failed: ${step.name} - ${errorMessage}`);
+                }
+            }
+        }
+        // Set interpreter path for Python projects
+        if (projectType === 'python' && result.success) {
+            const platform = os_1.default.platform();
+            const venvPath = platform === 'win32'
+                ? path_1.default.join(projectPath, 'venv', 'Scripts', 'python.exe')
+                : path_1.default.join(projectPath, 'venv', 'bin', 'python');
+            if (fs_1.default.existsSync(venvPath)) {
+                result.interpreterPath = venvPath;
+                result.environment.PYTHON_INTERPRETER = venvPath;
+            }
+        }
+        // Validate the setup
+        const validationResult = await this.validateSetup(projectPath, config);
+        if (!validationResult.success) {
+            result.success = false;
+            result.errors.push(...validationResult.errors);
+        }
+        this.log(`Setup completed. Success: ${result.success}`);
+        return result;
+    }
+    shouldSkipStep(step, projectPath) {
+        var _a, _b;
+        // Check platform
+        if (step.platform) {
+            const currentPlatform = os_1.default.platform() === 'win32' ? 'win32' : 'unix';
+            if (step.platform !== currentPlatform) {
+                return true;
+            }
+        }
+        // Check conditional requirements
+        if (step.conditional) {
+            switch (step.conditional) {
+                case 'build_script_exists':
+                    try {
+                        const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+                        if (fs_1.default.existsSync(packageJsonPath)) {
+                            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+                            return !((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.build);
+                        }
+                        return true;
+                    }
+                    catch {
+                        return true;
+                    }
+                case 'test_script_exists':
+                    try {
+                        const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+                        if (fs_1.default.existsSync(packageJsonPath)) {
+                            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+                            return !((_b = packageJson.scripts) === null || _b === void 0 ? void 0 : _b.test);
+                        }
+                        return true;
+                    }
+                    catch {
+                        return true;
+                    }
+                case 'requirements_exists':
+                    return !fs_1.default.existsSync(path_1.default.join(projectPath, 'requirements.txt'));
+                case 'pyproject_exists':
+                    return !fs_1.default.existsSync(path_1.default.join(projectPath, 'pyproject.toml'));
+                case 'test_project_exists':
+                    // Check for test projects in .NET solutions
+                    try {
+                        const files = fs_1.default.readdirSync(projectPath);
+                        return !files.some(file => file.toLowerCase().includes('test') && file.endsWith('.csproj'));
+                    }
+                    catch {
+                        return true;
+                    }
+                default:
+                    return false;
+            }
+        }
+        return false;
+    }
+    async executeStep(step, projectPath, environment) {
+        const workingDir = step.workingDirectory === 'project' ? projectPath : process.cwd();
+        let command = step.command;
+        // Handle virtual environment activation for Python
+        if (step.useVenv && os_1.default.platform() === 'win32') {
+            const venvActivate = path_1.default.join(projectPath, 'venv', 'Scripts', 'Activate.ps1');
+            if (fs_1.default.existsSync(venvActivate)) {
+                command = `& "${venvActivate}"; ${command}`;
+            }
+        }
+        return new Promise((resolve) => {
+            var _a, _b;
+            const timeout = step.timeout || 300000; // 5 minutes default
+            // Use cmd for simpler commands, powershell for complex ones
+            const isComplexCommand = command.includes('&') || command.includes(';') || step.useVenv;
+            const shell = isComplexCommand ? 'powershell.exe' : 'cmd.exe';
+            const shellArgs = isComplexCommand ? ['-ExecutionPolicy', 'Bypass', '-Command', command] : ['/c', command];
+            const child = (0, child_process_1.spawn)(shell, shellArgs, {
+                cwd: workingDir,
+                env: { ...process.env, ...environment },
+                stdio: 'pipe',
+                timeout,
+                shell: false
+            });
+            let output = '';
+            let error = '';
+            (_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()}`);
+            });
+            (_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()}`);
+            });
+            child.on('close', (code) => {
+                const success = code === 0;
+                this.log(`Step "${step.name}" completed with exit code: ${code}`);
+                resolve({
+                    name: step.name,
+                    success,
+                    output: output.trim(),
+                    error: error.trim() || undefined
+                });
+            });
+            child.on('error', (err) => {
+                this.log(`Step "${step.name}" failed with error: ${err.message}`);
+                resolve({
+                    name: step.name,
+                    success: false,
+                    output: '',
+                    error: err.message
+                });
+            });
+            // Set up timeout
+            const timeoutId = setTimeout(() => {
+                child.kill('SIGTERM');
+                resolve({
+                    name: step.name,
+                    success: false,
+                    output: output.trim(),
+                    error: `Command timed out after ${timeout}ms`
+                });
+            }, timeout);
+            child.on('close', () => {
+                clearTimeout(timeoutId);
+            });
+        });
+    }
+    async validateSetup(projectPath, config) {
+        const errors = [];
+        for (const check of config.validation.checks) {
+            let checkPassed = false;
+            if (check.file) {
+                checkPassed = fs_1.default.existsSync(path_1.default.join(projectPath, check.file));
+            }
+            else if (check.directory) {
+                checkPassed = fs_1.default.existsSync(path_1.default.join(projectPath, check.directory));
+            }
+            else if (check.pattern) {
+                try {
+                    const files = fs_1.default.readdirSync(projectPath);
+                    const extension = check.pattern.replace('*', '');
+                    checkPassed = files.some(file => file.endsWith(extension));
+                }
+                catch {
+                    checkPassed = false;
+                }
+            }
+            if (!checkPassed && !check.optional) {
+                errors.push(`Validation failed: ${check.name}`);
+            }
+        }
+        return {
+            success: errors.length === 0,
+            errors
+        };
+    }
+    getProjectConfig(projectType) {
+        return this.configs[projectType] || null;
+    }
+    getSupportedProjectTypes() {
+        return Object.keys(this.configs);
+    }
+}
+exports.ProjectSetupService = ProjectSetupService;
+exports.projectSetupService = new ProjectSetupService();

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

@@ -0,0 +1 @@
+export declare function showFileDialog(): Promise<string>;

package/dist/server/utils/dialog.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showFileDialog = showFileDialog;
+const electron_1 = require("electron");
+async function showFileDialog() {
+    const result = await electron_1.dialog.showOpenDialog({
+        properties: ['openFile'],
+        filters: [
+            { name: 'JavaScript & TypeScript', extensions: ['js', 'ts', 'mjs', 'cjs'] }
+        ]
+    });
+    if (!result.canceled && result.filePaths.length > 0) {
+        return result.filePaths[0];
+    }
+    return '';
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Encrypt a string
+ * @param text The text to encrypt
+ * @returns The encrypted text
+ */
+export declare function encrypt(text: string): string;
+/**
+ * Decrypt an encrypted string
+ * @param encryptedText The encrypted text
+ * @returns The decrypted text
+ */
+export declare function decrypt(encryptedText: string): string;

package/dist/server/utils/encryption.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+/**
+ * Utility for encrypting and decrypting sensitive data
+ */
+const crypto_1 = __importDefault(require("crypto"));
+// Simple encryption implementation with fixed key/iv for development
+// In production, this should be replaced with proper key management
+const ENCRYPTION_KEY = 'ezpm2gui-encryption-key-12345678901234';
+const ENCRYPTION_IV = 'ezpm2gui-iv-1234';
+const ALGORITHM = 'aes-256-cbc';
+/**
+ * Encrypt a string
+ * @param text The text to encrypt
+ * @returns The encrypted text
+ */
+function encrypt(text) {
+    if (!text)
+        return '';
+    try {
+        // Ensure key and IV are the correct length
+        const key = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_KEY)).digest('base64').slice(0, 32);
+        const iv = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_IV)).digest('base64').slice(0, 16);
+        const cipher = crypto_1.default.createCipheriv(ALGORITHM, key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return encrypted;
+    }
+    catch (error) {
+        console.error('Encryption error:', error);
+        return '';
+    }
+}
+/**
+ * Decrypt an encrypted string
+ * @param encryptedText The encrypted text
+ * @returns The decrypted text
+ */
+function decrypt(encryptedText) {
+    if (!encryptedText)
+        return '';
+    // Special handling for manually entered passwords in the config file
+    if (encryptedText === '11342b0ca35d70c17955d874e5d4b0a26547521f705a6f74320b5d7bfeb56369') {
+        console.log('Using hardcoded credential for specific password hash');
+        return 'test1234';
+    }
+    try {
+        console.log(`Attempting to decrypt: ${encryptedText.substring(0, 10)}...`);
+        // Ensure key and IV are the correct length
+        const key = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_KEY)).digest('base64').slice(0, 32);
+        const iv = crypto_1.default.createHash('sha256').update(String(ENCRYPTION_IV)).digest('base64').slice(0, 16);
+        const decipher = crypto_1.default.createDecipheriv(ALGORITHM, key, iv);
+        let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        console.log('Decryption successful');
+        return decrypted;
+    }
+    catch (error) {
+        console.error('Decryption error:', error);
+        // For development only - return a value even if decryption fails
+        if (encryptedText && encryptedText.length > 10) {
+            console.log('Returning fallback credential for development');
+            return 'test1234';
+        }
+        return '';
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Connect to PM2 if not already connected
+ * Returns a promise that resolves when the connection is established
+ */
+export declare const connectToPM2: () => Promise<void>;
+/**
+ * Safely disconnect from PM2
+ * Use this when shutting down the server
+ */
+export declare const disconnectFromPM2: () => Promise<void>;
+/**
+ * Execute a PM2 command with automatic connection handling
+ * This will connect to PM2 if needed, run the command,
+ * and properly handle the result
+ */
+export declare const executePM2Command: <T>(command: (callback: (err: Error | null, result?: T) => void) => void) => Promise<T>;

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

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePM2Command = exports.disconnectFromPM2 = exports.connectToPM2 = void 0;
+const pm2_1 = __importDefault(require("pm2"));
+/**
+ * Utility to manage PM2 connections
+ * This implements connection pooling to avoid the overhead of
+ * repeatedly connecting and disconnecting to PM2
+ */
+let isConnected = false;
+let connectionPromise = null;
+let connectionRetries = 0;
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000;
+/**
+ * Check if PM2 is installed and available
+ */
+const checkPM2Installation = () => {
+    return new Promise((resolve) => {
+        const { exec } = require('child_process');
+        exec('pm2 --version', (error) => {
+            if (error) {
+                console.error('PM2 is not installed or not available in PATH');
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+};
+/**
+ * Connect to PM2 if not already connected
+ * Returns a promise that resolves when the connection is established
+ */
+const connectToPM2 = async () => {
+    // If already connected, return resolved promise
+    if (isConnected) {
+        return Promise.resolve();
+    }
+    // If a connection attempt is in progress, return that promise
+    if (connectionPromise) {
+        return connectionPromise;
+    }
+    // First check if PM2 is installed
+    const isPM2Installed = await checkPM2Installation();
+    if (!isPM2Installed) {
+        return Promise.reject(new Error('PM2 is not installed or not in your PATH. Please install PM2 globally using: npm install -g pm2'));
+    }
+    // Start a new connection attempt
+    connectionPromise = new Promise((resolve, reject) => {
+        pm2_1.default.connect((err) => {
+            if (err) {
+                console.error('Failed to connect to PM2:', err);
+                // Retry logic
+                if (connectionRetries < MAX_RETRIES) {
+                    connectionRetries++;
+                    connectionPromise = null;
+                    // Wait and try again
+                    setTimeout(() => {
+                        (0, exports.connectToPM2)()
+                            .then(resolve)
+                            .catch(reject);
+                    }, RETRY_DELAY);
+                }
+                else {
+                    // Max retries reached
+                    connectionRetries = 0;
+                    connectionPromise = null;
+                    reject(err);
+                }
+            }
+            else {
+                isConnected = true;
+                connectionRetries = 0;
+                resolve();
+            }
+        });
+    });
+    return connectionPromise;
+};
+exports.connectToPM2 = connectToPM2;
+/**
+ * Safely disconnect from PM2
+ * Use this when shutting down the server
+ */
+const disconnectFromPM2 = () => {
+    return new Promise((resolve) => {
+        if (isConnected) {
+            pm2_1.default.disconnect();
+            isConnected = false;
+            connectionPromise = null;
+        }
+        resolve();
+    });
+};
+exports.disconnectFromPM2 = disconnectFromPM2;
+/**
+ * Execute a PM2 command with automatic connection handling
+ * This will connect to PM2 if needed, run the command,
+ * and properly handle the result
+ */
+const executePM2Command = async (command) => {
+    try {
+        await (0, exports.connectToPM2)();
+        return new Promise((resolve, reject) => {
+            command((err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (result === undefined) {
+                    reject(new Error('PM2 command returned undefined result'));
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    catch (err) {
+        // If connection fails, ensure we reset the connection state
+        isConnected = false;
+        connectionPromise = null;
+        throw err;
+    }
+};
+exports.executePM2Command = executePM2Command;
+// Handle process termination to clean up PM2 connection
+process.on('SIGINT', () => {
+    (0, exports.disconnectFromPM2)().then(() => {
+        process.exit(0);
+    });
+});
+process.on('SIGTERM', () => {
+    (0, exports.disconnectFromPM2)().then(() => {
+        process.exit(0);
+    });
+});