remote-deploy-cli 1.1.1 → 1.2.0

package/.prettierignore

@@ -0,0 +1,9 @@
+# Ignore artifacts:
+build
+coverage
+dist
+node_modules
+.git
+
+# Ignore config files that don't need formatting
+package-lock.json

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "printWidth": 100
+}

package/README.md

@@ -71,7 +71,9 @@ redep deploy <type>
 ```
 
 **Parameters:**
-- `<type>`: The service type to deploy. Currently supports `fe` (frontend).
+- `<type>`: The service type to deploy.
+  - `fe`: Frontend (pre-configured to run `docker compose pull && docker compose up -d`).
+  - `custom`: Custom command (configured on server via `deployment_command`).
 
 **Requirements:**
 - `SERVER_URL` must be configured.
@@ -81,6 +83,9 @@ redep deploy <type>
 ```bash
 # Deploy frontend service
 redep deploy fe
+
+# Deploy custom command
+redep deploy custom
 ```
 
 **Expected Output:**
@@ -155,6 +160,9 @@ redep config set working_dir /path/to/project
 
 # Set Secret Key
 redep config set secret_key my-secret-key
+
+# Set Custom Deployment Command (Optional)
+redep config set deployment_command "git pull && npm install && pm2 restart app"
 ```
 
 #### Running with Docker (Recommended)
@@ -172,6 +180,7 @@ services:
     environment:
       - WORKING_DIR=/workspace
       - SECRET_KEY=secure-key
+      - DEPLOYMENT_COMMAND=docker compose restart app
 ```
 
 ---
@@ -208,6 +217,7 @@ sequenceDiagram
 | :------------ | :------------ | :----------------------------------------------- | :--------------- |
 | `server_port` | `SERVER_PORT` | Port for the server to listen on (Default: 3000) | **Server**       |
 | `working_dir` | `WORKING_DIR` | Directory to execute commands in                 | **Server**       |
+| `deployment_command` | `DEPLOYMENT_COMMAND` | Custom command for `deploy custom` | **Server**       |
 | `server_url`  | `SERVER_URL`  | URL of the remote `redep` server                 | **Client**       |
 | `secret_key`  | `SECRET_KEY`  | Shared secret for authentication                 | **Both**         |
 

package/bin/index.js

@@ -66,14 +66,28 @@ program
       // We'll use a dynamic import or checking for the pm2 binary in a real scenario
       // But here we can just try to spawn 'pm2' command
       
-      const args = ['start', process.argv[1], '--name', 'redep-server', '--', 'listen'];
+      // Use dedicated server entry point for PM2 to avoid CLI/ESM issues
+      // Resolve absolute path to server-entry.js
+      const scriptPath = new URL('../server-entry.js', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'); 
+      
+      const args = [
+        'start', 
+        scriptPath,
+        '--name', 'redep-server'
+      ];
+      
+      // We don't pass 'listen' arg because server-entry.js starts immediately
+      // But we do need to ensure env vars are passed if port is customized
+      
+      const env = { ...process.env };
       if (options.port) {
-        args.push('--port', options.port);
+        env.SERVER_PORT = options.port;
       }
 
       const pm2 = spawn('pm2', args, {
         stdio: 'inherit',
-        shell: true // Required to find pm2 in PATH
+        shell: true,
+        env: env // Pass modified env with port
       });
 
       pm2.on('error', () => {

package/lib/client/index.js

@@ -16,16 +16,35 @@ export const deploy = async (type, serverUrl, secret) => {
         if (result.output.stdout) console.log(result.output.stdout);
         if (result.output.stderr) console.log(result.output.stderr);
         logger.log('---------------------');
+      } else if (type === 'custom') {
+          logger.info('Sending custom deployment instruction to server machine...');
+          
+            try {
+              const result = await sendCommand(serverUrl, '/deploy/custom', secret, {});
+              
+              if (result.status === 'success') {
+                logger.success('Server successfully executed the custom deployment command.');
+                logger.log('--- Remote Output ---');
+                if (result.output.stdout) console.log(result.output.stdout);
+                if (result.output.stderr) console.log(result.output.stderr);
+                logger.log('---------------------');
+              } else {
+                logger.error('Server reported failure.');
+                console.error(result);
+              }
+            } catch (err) {
+              throw err;
+            }
       } else {
-        logger.error('Server reported failure.');
-        console.error(result);
-      }
-    } catch (err) {
-      throw err;
-    }
+            logger.error('Server reported failure.');
+            console.error(result);
+          }
+        } catch (err) {
+          throw err;
+        }
 
-  } else {
-    logger.error(`Deployment type "${type}" is not supported yet.`);
-    throw new Error(`Unsupported deployment type: ${type}`);
-  }
-};
+      } else {
+        logger.error(`Deployment type "${type}" is not supported yet.`);
+        throw new Error(`Unsupported deployment type: ${type}`);
+      }
+    };

package/lib/server/server.js

@@ -5,6 +5,7 @@ import helmet from 'helmet';
 import morgan from 'morgan';
 import { logger } from '../logger.js';
 import { executeCommand } from './executor.js';
+import { getConfig } from '../config.js';
 
 export const createServer = (secretKey, workingDir) => {
   const app = express();
@@ -59,5 +60,31 @@ export const createServer = (secretKey, workingDir) => {
     }
   });
 
+  // Endpoint for custom deployment command
+  app.post('/deploy/custom', authenticate, async (req, res) => {
+    logger.info('Received custom deploy request');
+
+    // Get command from environment variable or config
+    const deploymentCommand = getConfig('deployment_command') || process.env.DEPLOYMENT_COMMAND;
+
+    if (!deploymentCommand) {
+      logger.error('No DEPLOYMENT_COMMAND set');
+      return res.status(400).json({ 
+        status: 'error', 
+        error: 'No DEPLOYMENT_COMMAND configured. Set it via env var or "redep config set deployment_command <cmd>"' 
+      });
+    }
+
+    logger.info(`Executing custom command: ${deploymentCommand}`);
+
+    try {
+      const result = await executeCommand(deploymentCommand, workingDir);
+      res.json({ status: 'success', output: result });
+    } catch (error) {
+      logger.error(`Deployment failed: ${error}`);
+      res.status(500).json({ status: 'error', error: error.message || error });
+    }
+  });
+
   return app;
 };

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "remote-deploy-cli",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main": "index.js",
   "type": "module",
   "bin": {
     "redep": "./bin/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "update": "node scripts/update.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "sonar": "node sonar-project.js"
   },
   "keywords": [],
   "author": "",
@@ -25,5 +29,9 @@
     "helmet": "^7.1.0",
     "morgan": "^1.10.0",
     "pm2": "^6.0.14"
+  },
+  "devDependencies": {
+    "prettier": "^3.8.0",
+    "sonarqube-scanner": "^4.3.4"
   }
 }

package/scripts/update.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import { execSync } from 'child_process';
+import path from 'path';
+
+// Get arguments from command line
+// Usage: node scripts/update.js <updateType> <commitMessage>
+const updateType = process.argv[2];
+const commitMessage = process.argv[3];
+
+// Valid update types
+const VALID_TYPES = ['patch', 'minor', 'major'];
+
+// --- Validation ---
+
+if (!updateType || !VALID_TYPES.includes(updateType)) {
+  console.error(`Error: Invalid or missing updateType. Must be one of: ${VALID_TYPES.join(', ')}`);
+  process.exit(1);
+}
+
+if (!commitMessage) {
+  console.error('Error: Missing commitMessage.');
+  process.exit(1);
+}
+
+const packageJsonPath = path.resolve('package.json');
+
+if (!fs.existsSync(packageJsonPath)) {
+  console.error('Error: package.json not found.');
+  process.exit(1);
+}
+
+// --- Version Update Logic ---
+
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+  if (!packageJson.version) {
+    console.error('Error: package.json does not contain a "version" field.');
+    process.exit(1);
+  }
+
+  const currentVersion = packageJson.version;
+  const versionParts = currentVersion.split('.').map(Number);
+
+  if (versionParts.length !== 3 || versionParts.some(isNaN)) {
+    console.error(`Error: Invalid semantic version format in package.json: ${currentVersion}`);
+    process.exit(1);
+  }
+
+  let [major, minor, patch] = versionParts;
+
+  switch (updateType) {
+    case 'major':
+      major++;
+      minor = 0;
+      patch = 0;
+      break;
+    case 'minor':
+      minor++;
+      patch = 0;
+      break;
+    case 'patch':
+      patch++;
+      break;
+  }
+
+  const newVersion = `${major}.${minor}.${patch}`;
+  packageJson.version = newVersion;
+
+  // Write updated package.json
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+  console.log(`Version updated: ${currentVersion} -> ${newVersion}`);
+
+  // --- Git Operations ---
+
+  console.log('Staging changes...');
+  execSync('git add .', { stdio: 'inherit' });
+
+  console.log(`Committing with message: "${commitMessage}"...`);
+  execSync(`git commit -m "${commitMessage}"`, { stdio: 'inherit' });
+
+  console.log('Pushing to origin main...');
+  execSync('git push origin main', { stdio: 'inherit' });
+
+  console.log('Update process completed successfully!');
+
+} catch (error) {
+  console.error(`Error during update process: ${error.message}`);
+  process.exit(1);
+}

package/server-entry.js

@@ -0,0 +1,22 @@
+import { startServer } from './lib/server/index.js';
+import { logger } from './lib/logger.js';
+import { getConfig } from './lib/config.js';
+import 'dotenv/config';
+
+// Dedicated entry point for PM2 to ensure clean ESM handling
+// PM2 sometimes struggles with CLI binaries directly in ESM mode
+
+const port = process.env.SERVER_PORT || getConfig('server_port') || 3000;
+const secret = process.env.SECRET_KEY || getConfig('secret_key');
+const workingDir = process.env.WORKING_DIR || getConfig('working_dir');
+
+if (!secret) {
+  logger.warn('Warning: No "secret_key" set. Communication might be insecure.');
+}
+
+if (!workingDir) {
+  logger.error('Error: "working_dir" is not set.');
+  process.exit(1);
+}
+
+startServer(port, secret, workingDir);

package/sonar-project.js

@@ -0,0 +1,18 @@
+const scanner = require('sonarqube-scanner');
+
+scanner(
+  {
+    serverUrl: process.env.SONAR_HOST_URL || 'http://localhost:9000',
+    token: process.env.SONAR_TOKEN,
+    options: {
+      'sonar.projectKey': 'remote-deploy-cli',
+      'sonar.projectName': 'Remote Deploy CLI',
+      'sonar.projectVersion': '1.0.0',
+      'sonar.sources': 'bin,lib',
+      'sonar.tests': 'test', // Assuming tests are in a 'test' directory
+      'sonar.javascript.lcov.reportPaths': 'coverage/lcov.info',
+      'sonar.sourceEncoding': 'UTF-8',
+    },
+  },
+  () => process.exit()
+);