ezpm2gui 1.1.0 → 1.2.0

package/dist/server/config/project-configs.json

@@ -0,0 +1,236 @@
+{
+  "projectTypes": {
+    "node": {
+      "name": "Node.js",
+      "detection": {
+        "files": ["package.json"],
+        "extensions": [".js", ".ts", ".jsx", ".tsx"]
+      },
+      "setup": {
+        "steps": [
+          {
+            "name": "Check Node.js version",
+            "command": "node --version",
+            "description": "Verifying Node.js installation",
+            "required": true
+          },
+          {
+            "name": "Install dependencies",
+            "command": "npm install",
+            "description": "Installing project dependencies",
+            "required": true,
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Build project (if build script exists)",
+            "command": "npm run build",
+            "description": "Building the project",
+            "required": false,
+            "conditional": "build_script_exists",
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Run tests (if test script exists)",
+            "command": "npm test",
+            "description": "Running tests",
+            "required": false,
+            "conditional": "test_script_exists",
+            "workingDirectory": "project"
+          }
+        ],
+        "environment": {
+          "NODE_ENV": "production"
+        }
+      },
+      "validation": {
+        "checks": [
+          {
+            "name": "package.json exists",
+            "file": "package.json"
+          },
+          {
+            "name": "node_modules exists after install",
+            "directory": "node_modules"
+          }
+        ]
+      },
+      "defaultConfig": {
+        "interpreter": "node",
+        "execMode": "fork",
+        "supportsCluster": true,
+        "startScript": "npm start"
+      }
+    },
+    "python": {
+      "name": "Python",
+      "detection": {
+        "files": ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"],
+        "extensions": [".py"]
+      },
+      "setup": {
+        "steps": [
+          {
+            "name": "Check Python version",
+            "command": "python --version",
+            "description": "Verifying Python installation",
+            "required": true
+          },
+          {
+            "name": "Create virtual environment",
+            "command": "python -m venv venv",
+            "description": "Creating Python virtual environment",
+            "required": true,
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Activate virtual environment (Windows)",
+            "command": ".\\venv\\Scripts\\Activate.ps1",
+            "description": "Activating virtual environment",
+            "required": true,
+            "platform": "win32",
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Activate virtual environment (Unix)",
+            "command": "source venv/bin/activate",
+            "description": "Activating virtual environment",
+            "required": true,
+            "platform": "unix",
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Upgrade pip",
+            "command": "python -m pip install --upgrade pip",
+            "description": "Upgrading pip",
+            "required": true,
+            "workingDirectory": "project",
+            "useVenv": true
+          },
+          {
+            "name": "Install requirements",
+            "command": "pip install -r requirements.txt",
+            "description": "Installing Python dependencies",
+            "required": true,
+            "conditional": "requirements_exists",
+            "workingDirectory": "project",
+            "useVenv": true
+          },
+          {
+            "name": "Install from pyproject.toml",
+            "command": "pip install -e .",
+            "description": "Installing from pyproject.toml",
+            "required": true,
+            "conditional": "pyproject_exists",
+            "workingDirectory": "project",
+            "useVenv": true
+          }
+        ],
+        "environment": {
+          "PYTHONPATH": ".",
+          "PYTHON_UNBUFFERED": "1"
+        }
+      },
+      "validation": {
+        "checks": [
+          {
+            "name": "Virtual environment created",
+            "directory": "venv"
+          },
+          {
+            "name": "Requirements file exists",
+            "file": "requirements.txt",
+            "optional": true
+          }
+        ]
+      },
+      "defaultConfig": {
+        "interpreter": "python",
+        "execMode": "fork",
+        "supportsCluster": false,
+        "interpreterPath": "venv/Scripts/python.exe"
+      }
+    },
+    "dotnet": {
+      "name": ".NET",
+      "detection": {
+        "files": ["*.csproj", "*.fsproj", "*.vbproj", "*.sln"],
+        "extensions": [".cs", ".fs", ".vb"]
+      },
+      "setup": {
+        "steps": [
+          {
+            "name": "Check .NET version",
+            "command": "dotnet --version",
+            "description": "Verifying .NET installation",
+            "required": true
+          },
+          {
+            "name": "Restore packages",
+            "command": "dotnet restore",
+            "description": "Restoring NuGet packages",
+            "required": true,
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Build project",
+            "command": "dotnet build --configuration Release",
+            "description": "Building .NET project",
+            "required": true,
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Publish project",
+            "command": "dotnet publish --configuration Release --output ./publish",
+            "description": "Publishing .NET project",
+            "required": true,
+            "workingDirectory": "project"
+          },
+          {
+            "name": "Run tests",
+            "command": "dotnet test",
+            "description": "Running .NET tests",
+            "required": false,
+            "conditional": "test_project_exists",
+            "workingDirectory": "project"
+          }
+        ],
+        "environment": {
+          "DOTNET_ENVIRONMENT": "Production",
+          "ASPNETCORE_ENVIRONMENT": "Production"
+        }
+      },
+      "validation": {
+        "checks": [
+          {
+            "name": "Project file exists",
+            "pattern": "*.csproj"
+          },
+          {
+            "name": "Publish directory exists",
+            "directory": "publish"
+          }
+        ]
+      },
+      "defaultConfig": {
+        "interpreter": "dotnet",
+        "execMode": "fork",
+        "supportsCluster": false,
+        "startCommand": "dotnet run"
+      }
+    }
+  },
+  "global": {
+    "timeouts": {
+      "setup": 300000,
+      "validation": 30000
+    },
+    "retries": {
+      "setup": 2,
+      "validation": 1
+    },
+    "logging": {
+      "level": "info",
+      "file": "deployment.log"
+    }
+  }
+}

package/dist/server/index.js

@@ -9,13 +9,13 @@ const http_1 = __importDefault(require("http"));
 const socket_io_1 = require("socket.io");
 const pm2_1 = __importDefault(require("pm2"));
 const os_1 = __importDefault(require("os"));
-// Import routes
-const clusterManagement_1 = __importDefault(require("./routes/clusterManagement"));
 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 logStreaming_1 = require("./routes/logStreaming");
 const pm2_connection_1 = require("./utils/pm2-connection");
+const remote_connection_1 = require("./utils/remote-connection");
 /**
  * Create and configure the express server
  */
@@ -41,11 +41,11 @@ function createServer() {
     else {
         console.error('Static files directory not found at:', staticPath);
     }
-    // Register routes
-    app.use('/api/cluster', clusterManagement_1.default);
+    // Register routes  app.use('/api/cluster', clusterManagementRoutes);
     app.use('/api/config', processConfig_1.default);
     app.use('/api/deploy', deployApplication_1.default);
     app.use('/api/modules', modules_1.default);
+    app.use('/api/remote', remoteConnections_1.default);
     // Setup log streaming with Socket.IO
     (0, logStreaming_1.setupLogStreaming)(io); // PM2 API endpoints
     app.get('/api/processes', async (req, res) => {
@@ -90,7 +90,7 @@ function createServer() {
                         pm2_1.default.restart(id, cb);
                         break;
                     case 'delete':
-                        pm2_1.default.del(id, cb);
+                        pm2_1.default.delete(id, cb);
                         break;
                     default:
                         cb(new Error('Invalid action'));
@@ -236,4 +236,29 @@ if (require.main === module) {
     server.listen(PORT, () => {
         console.log(`Server running on http://${HOST}:${PORT}`);
     });
+    // Handle shutdown gracefully
+    process.on('SIGINT', async () => {
+        console.log('\nGracefully shutting down...');
+        try {
+            await (0, pm2_connection_1.disconnectFromPM2)();
+            await remote_connection_1.remoteConnectionManager.closeAllConnections();
+        }
+        catch (error) {
+            console.error('Error during shutdown:', error);
+        }
+        server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        console.log('\nGracefully shutting down...');
+        try {
+            await (0, pm2_connection_1.disconnectFromPM2)();
+            await remote_connection_1.remoteConnectionManager.closeAllConnections();
+        }
+        catch (error) {
+            console.error('Error during shutdown:', error);
+        }
+        server.close();
+        process.exit(0);
+    });
 }

package/dist/server/logs/deployment.log

@@ -0,0 +1,12 @@
+[2025-05-25T18:02:41.395Z] Starting setup for python project at: D:\Projects\FaceDetection
+[2025-05-25T18:02:41.396Z] Executing step: Check Python version
+[2025-05-25T18:02:41.954Z] Step "Check Python version" completed with exit code: 0
+[2025-05-25T18:02:41.955Z] Executing step: Create virtual environment
+[2025-05-25T18:03:20.998Z] Step "Create virtual environment" completed with exit code: 0
+[2025-05-25T18:03:20.999Z] Executing step: Activate virtual environment (Windows)
+[2025-05-25T18:03:21.176Z] Step "Activate virtual environment (Windows)" completed with exit code: 0
+[2025-05-25T18:03:21.176Z] Executing step: Upgrade pip
+[2025-05-25T18:03:48.644Z] Step "Upgrade pip" completed with exit code: 0
+[2025-05-25T18:03:48.645Z] Executing step: Install requirements
+[2025-05-25T18:04:56.318Z] Step "Install requirements" completed with exit code: 0
+[2025-05-25T18:04:56.322Z] Setup completed. Success: true

package/dist/server/routes/deployApplication.js

@@ -7,10 +7,11 @@ const express_1 = require("express");
 const pm2_1 = __importDefault(require("pm2"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const ProjectSetupService_1 = require("../services/ProjectSetupService");
 const router = (0, express_1.Router)();
 // Deploy a new application
-router.post('/', (req, res) => {
-    const { name, script, cwd, instances, exec_mode, autorestart, watch, max_memory_restart, env } = req.body;
+router.post('/', async (req, res) => {
+    const { name, script, cwd, instances, exec_mode, autorestart, watch, max_memory_restart, env, appType, autoSetup = true } = req.body;
     // Validate required fields
     if (!name || !script) {
         return res.status(400).json({ error: 'Name and script path are required' });
@@ -19,37 +20,103 @@ router.post('/', (req, res) => {
     if (!fs_1.default.existsSync(script)) {
         return res.status(400).json({ error: `Script file not found: ${script}` });
     }
-    // Create deployment configuration
-    const appConfig = {
-        name,
-        script,
-        cwd: cwd || path_1.default.dirname(script),
-        instances: parseInt(instances) || 1,
-        exec_mode: exec_mode || 'fork',
-        autorestart: autorestart !== undefined ? autorestart : true,
-        watch: watch || false,
-        max_memory_restart: max_memory_restart || '150M',
-        env: env || {}
-    };
-    pm2_1.default.connect((err) => {
-        if (err) {
-            console.error(err);
-            return res.status(500).json({ error: 'Failed to connect to PM2' });
+    try {
+        const projectPath = cwd || path_1.default.dirname(script);
+        let setupResult = null;
+        let finalEnv = env || {};
+        let interpreterPath = '';
+        // Auto-detect project type if not provided
+        let detectedType = appType;
+        if (!detectedType) {
+            detectedType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
+            if (detectedType) {
+                console.log(`Auto-detected project type: ${detectedType}`);
+            }
         }
-        pm2_1.default.start(appConfig, (err) => {
-            pm2_1.default.disconnect();
-            if (err) {
-                console.error('PM2 start error:', err);
+        // Run project setup if auto-setup is enabled and project type is detected
+        if (autoSetup && detectedType && ['node', 'python', 'dotnet'].includes(detectedType)) {
+            console.log(`Running setup for ${detectedType} project...`);
+            try {
+                setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, detectedType);
+                if (!setupResult.success) {
+                    return res.status(500).json({
+                        error: 'Project setup failed',
+                        details: setupResult.errors,
+                        warnings: setupResult.warnings,
+                        steps: setupResult.steps
+                    });
+                }
+                // Merge environment variables from setup
+                finalEnv = { ...setupResult.environment, ...finalEnv };
+                // Set interpreter path for Python projects
+                if (setupResult.interpreterPath) {
+                    interpreterPath = setupResult.interpreterPath;
+                }
+                console.log('Project setup completed successfully');
+            }
+            catch (setupError) {
+                console.error('Setup error:', setupError);
                 return res.status(500).json({
-                    error: `Failed to deploy application: ${err.message || 'Unknown error'}`
+                    error: 'Project setup failed',
+                    details: setupError instanceof Error ? setupError.message : 'Unknown setup error'
                 });
             }
-            res.json({
-                success: true,
-                message: `Application ${name} deployed successfully`
+        }
+        // Create deployment configuration
+        const appConfig = {
+            name,
+            script,
+            cwd: projectPath,
+            instances: parseInt(instances) || 1,
+            exec_mode: exec_mode || 'fork',
+            autorestart: autorestart !== undefined ? autorestart : true,
+            watch: watch || false,
+            max_memory_restart: max_memory_restart || '150M',
+            env: finalEnv
+        };
+        // Set interpreter for Python projects
+        if (detectedType === 'python' && interpreterPath) {
+            appConfig.interpreter = interpreterPath;
+        }
+        else if (detectedType === 'dotnet') {
+            appConfig.interpreter = 'dotnet';
+            // For .NET projects, update script to point to the published DLL if available
+            const publishedDll = path_1.default.join(projectPath, 'publish', `${path_1.default.basename(projectPath)}.dll`);
+            if (fs_1.default.existsSync(publishedDll)) {
+                appConfig.script = publishedDll;
+            }
+        }
+        pm2_1.default.connect((err) => {
+            if (err) {
+                console.error(err);
+                return res.status(500).json({ error: 'Failed to connect to PM2' });
+            }
+            pm2_1.default.start(appConfig, (err) => {
+                pm2_1.default.disconnect();
+                if (err) {
+                    console.error('PM2 start error:', err);
+                    return res.status(500).json({
+                        error: `Failed to deploy application: ${err.message || 'Unknown error'}`
+                    });
+                }
+                res.json({
+                    success: true,
+                    message: `Application ${name} deployed successfully`,
+                    setupResult: setupResult ? {
+                        steps: setupResult.steps,
+                        warnings: setupResult.warnings
+                    } : null
+                });
             });
         });
-    });
+    }
+    catch (error) {
+        console.error('Deployment error:', error);
+        return res.status(500).json({
+            error: 'Deployment failed',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
 });
 // Generate ecosystem.config.js file
 router.post('/generate-ecosystem', (req, res) => {
@@ -160,4 +227,84 @@ router.get('/generate-ecosystem-preview', (req, res) => {
         }
     });
 });
+// Detect project type
+router.post('/detect-project', (req, res) => {
+    const { projectPath } = req.body;
+    if (!projectPath) {
+        return res.status(400).json({ error: 'Project path is required' });
+    }
+    if (!fs_1.default.existsSync(projectPath)) {
+        return res.status(400).json({ error: 'Project path does not exist' });
+    }
+    try {
+        const projectType = ProjectSetupService_1.projectSetupService.detectProjectType(projectPath);
+        const config = projectType ? ProjectSetupService_1.projectSetupService.getProjectConfig(projectType) : null;
+        res.json({
+            success: true,
+            projectType,
+            config: config ? {
+                name: config.name,
+                defaultConfig: config.defaultConfig,
+                setupSteps: config.setup.steps.length
+            } : null
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Failed to detect project type',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// Setup project (without deployment)
+router.post('/setup-project', async (req, res) => {
+    const { projectPath, projectType } = req.body;
+    if (!projectPath || !projectType) {
+        return res.status(400).json({ error: 'Project path and type are required' });
+    }
+    if (!fs_1.default.existsSync(projectPath)) {
+        return res.status(400).json({ error: 'Project path does not exist' });
+    }
+    try {
+        const setupResult = await ProjectSetupService_1.projectSetupService.setupProject(projectPath, projectType);
+        res.json({
+            success: setupResult.success,
+            steps: setupResult.steps,
+            errors: setupResult.errors,
+            warnings: setupResult.warnings,
+            environment: setupResult.environment,
+            interpreterPath: setupResult.interpreterPath
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Project setup failed',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// Get supported project types
+router.get('/project-types', (req, res) => {
+    try {
+        const types = ProjectSetupService_1.projectSetupService.getSupportedProjectTypes();
+        const typeConfigs = types.map(type => {
+            const config = ProjectSetupService_1.projectSetupService.getProjectConfig(type);
+            return {
+                type,
+                name: config === null || config === void 0 ? void 0 : config.name,
+                defaultConfig: config === null || config === void 0 ? void 0 : config.defaultConfig
+            };
+        });
+        res.json({
+            success: true,
+            types: typeConfigs
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Failed to get project types',
+            details: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
 exports.default = router;