remote-deploy-cli 1.1.2 → 1.3.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

@@ -66,24 +66,34 @@ These commands are executed on your **local machine** or **CI/CD runner**.
 Triggers a deployment on the remote server.
 
 **Syntax:**
+
 ```bash
 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.
 - `SECRET_KEY` must match the server's key.
 
 **Example:**
+
 ```bash
 # Deploy frontend service
 redep deploy fe
+
+# Deploy custom command
+redep deploy custom
 ```
 
 **Expected Output:**
+
 ```
 [INFO] Deploying fe to http://192.168.1.50:3000...
 [SUCCESS] Deployment triggered successfully.
@@ -112,14 +122,17 @@ These commands are executed on the **remote server** (VPS, VM, etc.).
 Starts the server in the foreground. Useful for debugging or running inside Docker.
 
 **Syntax:**
+
 ```bash
 redep listen [--port <number>]
 ```
 
 **Options:**
+
 - `-p, --port`: Specify port (default: 3000).
 
 **Example:**
+
 ```bash
 redep listen --port 4000
 ```
@@ -127,19 +140,23 @@ redep listen --port 4000
 ### `start` (Background)
 
 Starts the server in background mode (Daemon).
-*   **Auto-PM2**: If `pm2` is installed, it uses PM2 for process management.
-*   **Native Fallback**: If `pm2` is missing, it uses Node.js `child_process` to detach.
+
+- **Auto-PM2**: If `pm2` is installed, it uses PM2 for process management.
+- **Native Fallback**: If `pm2` is missing, it uses Node.js `child_process` to detach.
 
 **Syntax:**
+
 ```bash
 redep start [--port <number>]
 ```
 
 **Related Commands:**
+
 - `redep stop`: Stops the background server.
 - `redep status`: Checks if the server is running.
 
 **Example:**
+
 ```bash
 redep start
 # [SUCCESS] Server started in background using PM2
@@ -155,6 +172,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,10 +192,25 @@ services:
     environment:
       - WORKING_DIR=/workspace
       - SECRET_KEY=secure-key
+      - DEPLOYMENT_COMMAND=docker compose restart app
 ```
 
 ---
 
+### `generate`
+
+Helper to generate configuration values.
+
+- `generate secret_key`: Generates a secure 32-character secret key and saves it to config.
+- `generate working_dir`: Sets the current directory as the `working_dir`.
+
+### `init`
+
+Interactive initialization for configuration.
+
+- `init client`: Prompts for `server_url` and `secret_key`.
+- `init server`: Prompts for `server_port`, `working_dir`, `deployment_command`, and `secret_key` (auto-generates if empty).
+
 ## Command Interactions
 
 ### Workflow: Deployment
@@ -184,11 +219,11 @@ services:
 sequenceDiagram
     participant Client (CI/Local)
     participant Server (Remote)
-    
+
     Note over Client: User runs "redep deploy fe"
     Client->>Client: Read Config (URL, Secret)
     Client->>Server: POST /deploy { type: "fe" } (Auth: Bearer Token)
-    
+
     Note over Server: Verify Secret Key
     alt Invalid Key
         Server-->>Client: 403 Forbidden
@@ -204,26 +239,30 @@ sequenceDiagram
 
 ## Configuration Reference
 
-| Config Key    | Env Variable  | Description                                      | Context          |
-| :------------ | :------------ | :----------------------------------------------- | :--------------- |
-| `server_port` | `SERVER_PORT` | Port for the server to listen on (Default: 3000) | **Server**       |
-| `working_dir` | `WORKING_DIR` | Directory to execute commands in                 | **Server**       |
-| `server_url`  | `SERVER_URL`  | URL of the remote `redep` server                 | **Client**       |
-| `secret_key`  | `SECRET_KEY`  | Shared secret for authentication                 | **Both**         |
+| Config Key           | Env Variable         | Description                                      | Context    |
+| :------------------- | :------------------- | :----------------------------------------------- | :--------- |
+| `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**   |
 
 ---
 
 ## Troubleshooting
 
 ### `Error: "working_dir" is not set`
+
 - **Context**: Server
 - **Fix**: Run `redep config set working_dir /path` or check `docker-compose.yml` environment.
 
 ### `Connection Refused`
+
 - **Context**: Client
 - **Fix**: Ensure server is running (`redep status` or `docker ps`) and port 3000 is open.
 
 ### `403 Forbidden`
+
 - **Context**: Client
 - **Fix**: Re-check `SECRET_KEY` on both machines. They must match exactly.
 

package/bin/index.js

@@ -3,21 +3,138 @@
 import 'dotenv/config';
 import { Command } from 'commander';
 import { spawn } from 'child_process';
+import crypto from 'crypto';
+import inquirer from 'inquirer';
 import { logger } from '../lib/logger.js';
 import { getConfig, setConfig, getAllConfig, clearConfig } from '../lib/config.js';
 import { startServer } from '../lib/server/index.js';
 import { deploy } from '../lib/client/index.js';
+import pkg from '../package.json' assert { type: 'json' };
 
 const program = new Command();
 
+program.name('redep').description(pkg.description).version(pkg.version);
+
+// Helper to generate secure token
+const generateSecureToken = (length = 32) => {
+  return crypto
+    .randomBytes(Math.ceil(length * 0.75))
+    .toString('base64')
+    .slice(0, length)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_');
+};
+
+// Init Command
 program
-  .name('redep')
-  .description('Remote execution CLI for deployment')
-  .version('1.0.0');
+  .command('init <type>')
+  .description('Initialize configuration for client or server')
+  .action(async (type) => {
+    if (type !== 'client' && type !== 'server') {
+      logger.error('Type must be either "client" or "server"');
+      process.exit(1);
+    }
+
+    try {
+      if (type === 'client') {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'server_url',
+            message: 'Enter Server URL:',
+            validate: (input) => (input ? true : 'Server URL is required'),
+          },
+          {
+            type: 'input',
+            name: 'secret_key',
+            message: 'Enter Secret Key:',
+            validate: (input) => (input ? true : 'Secret Key is required'),
+          },
+        ]);
+
+        setConfig('server_url', answers.server_url);
+        setConfig('secret_key', answers.secret_key);
+        logger.success('Client configuration saved successfully.');
+      } else {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'server_port',
+            message: 'Enter Server Port:',
+            default: '3000',
+            validate: (input) => (!isNaN(input) ? true : 'Port must be a number'),
+          },
+          {
+            type: 'input',
+            name: 'working_dir',
+            message: 'Enter Working Directory:',
+            validate: (input) => (input ? true : 'Working Directory is required'),
+          },
+          {
+            type: 'input',
+            name: 'deployment_command',
+            message: 'Enter Custom Deployment Command (Optional):',
+          },
+          {
+            type: 'input',
+            name: 'secret_key',
+            message: 'Enter Secret Key (Leave empty to generate):',
+          },
+        ]);
+
+        let secret = answers.secret_key;
+        if (!secret) {
+          secret = generateSecureToken();
+          logger.info(`Generated Secret Key: ${secret}`);
+        }
+
+        setConfig('server_port', answers.server_port);
+        setConfig('working_dir', answers.working_dir);
+        if (answers.deployment_command) {
+          setConfig('deployment_command', answers.deployment_command);
+        }
+        setConfig('secret_key', secret);
+        logger.success('Server configuration saved successfully.');
+      }
+    } catch (error) {
+      logger.error(`Initialization failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Generate Command
+const generateCommand = new Command('generate').description('Generate configuration values');
+
+generateCommand
+  .command('secret_key')
+  .description('Generate a new secret key')
+  .action(() => {
+    try {
+      const secret = generateSecureToken();
+      setConfig('secret_key', secret);
+      logger.success(`Secret Key generated and saved: ${secret}`);
+    } catch (error) {
+      logger.error(`Generation failed: ${error.message}`);
+    }
+  });
+
+generateCommand
+  .command('working_dir')
+  .description('Set working directory to current path')
+  .action(() => {
+    try {
+      const cwd = process.cwd();
+      setConfig('working_dir', cwd);
+      logger.success(`Working Directory set to: ${cwd}`);
+    } catch (error) {
+      logger.error(`Failed to set working directory: ${error.message}`);
+    }
+  });
+
+program.addCommand(generateCommand);
 
 // Configuration Command
-const configCommand = new Command('config')
-  .description('Manage configuration');
+const configCommand = new Command('config').description('Manage configuration');
 
 configCommand
   .command('set <key> <value>')
@@ -65,20 +182,19 @@ program
       // Check if PM2 is available via API
       // 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
-      
+
       // 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'
-      ];
-      
+      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) {
         env.SERVER_PORT = options.port;
@@ -87,7 +203,7 @@ program
       const pm2 = spawn('pm2', args, {
         stdio: 'inherit',
         shell: true,
-        env: env // Pass modified env with port
+        env: env, // Pass modified env with port
       });
 
       pm2.on('error', () => {
@@ -98,46 +214,45 @@ program
 
       pm2.on('close', (code) => {
         if (code !== 0) {
-           logger.warn('PM2 start failed, falling back to native background process...');
-           startNativeBackground(options);
+          logger.warn('PM2 start failed, falling back to native background process...');
+          startNativeBackground(options);
         } else {
-           logger.success('Server started in background using PM2');
+          logger.success('Server started in background using PM2');
         }
       });
-
     } catch (e) {
       startNativeBackground(options);
     }
   });
 
 function startNativeBackground(options) {
-    const existingPid = getConfig('server_pid');
-    
-    if (existingPid) {
-      try {
-        process.kill(existingPid, 0);
-        logger.warn(`Server is already running with PID ${existingPid}`);
-        return;
-      } catch (e) {
-        // Process doesn't exist, clear stale PID
-        setConfig('server_pid', null);
-      }
-    }
+  const existingPid = getConfig('server_pid');
 
-    const args = ['listen'];
-    if (options.port) {
-      args.push('--port', options.port);
+  if (existingPid) {
+    try {
+      process.kill(existingPid, 0);
+      logger.warn(`Server is already running with PID ${existingPid}`);
+      return;
+    } catch (e) {
+      // Process doesn't exist, clear stale PID
+      setConfig('server_pid', null);
     }
+  }
 
-    const child = spawn(process.argv[0], [process.argv[1], ...args], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true
-    });
+  const args = ['listen'];
+  if (options.port) {
+    args.push('--port', options.port);
+  }
+
+  const child = spawn(process.argv[0], [process.argv[1], ...args], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+  });
 
-    child.unref();
-    setConfig('server_pid', child.pid);
-    logger.success(`Server started in background (native) with PID ${child.pid}`);
+  child.unref();
+  setConfig('server_pid', child.pid);
+  logger.success(`Server started in background (native) with PID ${child.pid}`);
 }
 
 program
@@ -146,13 +261,13 @@ program
   .action(() => {
     // Try PM2 stop first
     const pm2 = spawn('pm2', ['stop', 'redep-server'], { stdio: 'ignore', shell: true });
-    
+
     pm2.on('close', (code) => {
       if (code === 0) {
         logger.success('Server stopped (PM2)');
         return;
       }
-      
+
       // Fallback to native stop
       const pid = getConfig('server_pid');
       if (!pid) {
@@ -179,28 +294,28 @@ program
   .command('status')
   .description('Check server status')
   .action(() => {
-     // Try PM2 status first
-     const pm2 = spawn('pm2', ['describe', 'redep-server'], { stdio: 'inherit', shell: true });
+    // Try PM2 status first
+    const pm2 = spawn('pm2', ['describe', 'redep-server'], { stdio: 'inherit', shell: true });
 
-     pm2.on('close', (code) => {
-        if (code !== 0) {
-             // Fallback to native status
-            const pid = getConfig('server_pid');
-            
-            if (!pid) {
-              logger.info('Server is NOT running.');
-              return;
-            }
-
-            try {
-              process.kill(pid, 0);
-              logger.success(`Server is RUNNING (PID ${pid})`);
-            } catch (e) {
-              logger.warn(`Server is NOT running (Stale PID ${pid} found).`);
-              setConfig('server_pid', null);
-            }
+    pm2.on('close', (code) => {
+      if (code !== 0) {
+        // Fallback to native status
+        const pid = getConfig('server_pid');
+
+        if (!pid) {
+          logger.info('Server is NOT running.');
+          return;
+        }
+
+        try {
+          process.kill(pid, 0);
+          logger.success(`Server is RUNNING (PID ${pid})`);
+        } catch (e) {
+          logger.warn(`Server is NOT running (Stale PID ${pid} found).`);
+          setConfig('server_pid', null);
         }
-     });
+      }
+    });
   });
 
 // Server Command
@@ -211,15 +326,19 @@ program
   .action((options) => {
     const port = options.port || getConfig('server_port') || process.env.SERVER_PORT || 3000;
     const secret = getConfig('secret_key') || process.env.SECRET_KEY;
-    
+
     if (!secret) {
-      logger.warn('Warning: No "secret_key" set in config or SECRET_KEY env var. Communication might be insecure or fail if client requires it.');
+      logger.warn(
+        'Warning: No "secret_key" set in config or SECRET_KEY env var. Communication might be insecure or fail if client requires it.'
+      );
       logger.info('Run "redep config set secret_key <your-secret>" or set SECRET_KEY env var.');
     }
 
     const workingDir = getConfig('working_dir') || process.env.WORKING_DIR;
     if (!workingDir) {
-      logger.error('Error: "working_dir" is not set. Please set it using "redep config set working_dir <path>" or WORKING_DIR env var.');
+      logger.error(
+        'Error: "working_dir" is not set. Please set it using "redep config set working_dir <path>" or WORKING_DIR env var.'
+      );
       process.exit(1);
     }
 
@@ -235,12 +354,16 @@ program
     const secret = getConfig('secret_key') || process.env.SECRET_KEY;
 
     if (!serverUrl) {
-      logger.error('Error: "server_url" is not set. Set SERVER_URL env var or run "redep config set server_url <url>"');
+      logger.error(
+        'Error: "server_url" is not set. Set SERVER_URL env var or run "redep config set server_url <url>"'
+      );
       process.exit(1);
     }
 
     if (!secret) {
-      logger.error('Error: "secret_key" is not set. Set SECRET_KEY env var or run "redep config set secret_key <your-secret>"');
+      logger.error(
+        'Error: "secret_key" is not set. Set SECRET_KEY env var or run "redep config set secret_key <your-secret>"'
+      );
       process.exit(1);
     }
 

package/docker-compose.server.yml

@@ -3,12 +3,12 @@ services:
     build: .
     container_name: deploy-server
     restart: unless-stopped
-    
+
     env_file:
       - .env
 
     ports:
-      - "${SERVER_PORT}:3000"
+      - '${SERVER_PORT}:3000'
     environment:
       # Override WORKING_DIR to match the internal container path
       - WORKING_DIR=/workspace

package/lib/client/client.js

@@ -9,14 +9,16 @@ export const sendCommand = async (url, endpoint, secret, data) => {
 
     const response = await axios.post(fullUrl, data, {
       headers: {
-        'Authorization': `Bearer ${secret}`,
-        'Content-Type': 'application/json'
-      }
+        Authorization: `Bearer ${secret}`,
+        'Content-Type': 'application/json',
+      },
     });
     return response.data;
   } catch (error) {
     if (error.response) {
-      throw new Error(`Server error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
+      throw new Error(
+        `Server error (${error.response.status}): ${JSON.stringify(error.response.data)}`
+      );
     } else if (error.request) {
       throw new Error(`Connection failed: No response from ${url}. Is the server running?`);
     } else {

package/lib/client/index.js

@@ -3,19 +3,38 @@ import { logger } from '../logger.js';
 
 export const deploy = async (type, serverUrl, secret) => {
   logger.info(`Starting deployment sequence for target: ${type}`);
-  
+
   if (type === 'fe') {
     logger.info('Sending deployment instruction to server machine...');
-    
+
     try {
       const result = await sendCommand(serverUrl, '/deploy/fe', secret, {});
-      
+
       if (result.status === 'success') {
         logger.success('Server successfully executed the 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 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);
@@ -23,7 +42,6 @@ export const deploy = async (type, serverUrl, secret) => {
     } catch (err) {
       throw err;
     }
-
   } else {
     logger.error(`Deployment type "${type}" is not supported yet.`);
     throw new Error(`Unsupported deployment type: ${type}`);

package/lib/config.js

@@ -1,7 +1,7 @@
 import Conf from 'conf';
 
 const config = new Conf({
-  projectName: 'redep'
+  projectName: 'redep',
 });
 
 export const getConfig = (key) => {

package/lib/logger.js

@@ -5,5 +5,5 @@ export const logger = {
   success: (msg) => console.log(chalk.green('✔') + ' ' + msg),
   warn: (msg) => console.log(chalk.yellow('⚠') + ' ' + msg),
   error: (msg) => console.error(chalk.red('✖') + ' ' + msg),
-  log: (msg) => console.log(msg)
+  log: (msg) => console.log(msg),
 };

package/lib/server/executor.js

@@ -4,13 +4,13 @@ import { logger } from '../logger.js';
 export const executeCommand = (command, workingDir) => {
   return new Promise((resolve, reject) => {
     logger.info(`Executing: ${command} in ${workingDir}`);
-    
+
     exec(command, { cwd: workingDir }, (error, stdout, stderr) => {
       if (error) {
         logger.error(`Execution error: ${error.message}`);
         return reject({ error: error.message, stderr });
       }
-      
+
       if (stderr) {
         // Docker often outputs to stderr even for info, so we log it but don't fail unless error is set
         logger.warn(`Stderr: ${stderr}`);

package/lib/server/index.js

@@ -6,9 +6,9 @@ export const startServer = (port, secret, workingDir) => {
     logger.error('Cannot start server: Secret key is required for security.');
     process.exit(1);
   }
-  
+
   const app = createServer(secret, workingDir);
-  
+
   app.listen(port, () => {
     logger.success(`Server is running on port ${port}`);
     logger.info(`Working Directory: ${workingDir}`);

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();
@@ -46,7 +47,7 @@ export const createServer = (secretKey, workingDir) => {
   // Specific endpoint for deploy fe to map the requirement exactly
   app.post('/deploy/fe', authenticate, async (req, res) => {
     logger.info('Received deploy fe request');
-    
+
     // Requirement: cd to working dir and run docker compose up -d
     // We use 'docker compose pull && docker compose up -d' to ensure latest image is used
     const command = 'docker compose pull && docker compose up -d';
@@ -59,5 +60,32 @@ 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,6 +1,7 @@
 {
   "name": "remote-deploy-cli",
-  "version": "1.1.2",
+  "author": "nafies1",
+  "version": "1.3.0",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -8,10 +9,12 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "update": "node scripts/update.js"
+    "update": "node scripts/update.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "sonar": "node sonar-project.js"
   },
   "keywords": [],
-  "author": "",
   "license": "ISC",
   "description": "Remote execution CLI for deployment",
   "dependencies": {
@@ -24,7 +27,17 @@
     "dotenv": "^17.2.3",
     "express": "^4.18.2",
     "helmet": "^7.1.0",
+    "inquirer": "^13.2.0",
     "morgan": "^1.10.0",
     "pm2": "^6.0.14"
+  },
+  "devDependencies": {
+    "@sonar/scan": "^4.3.4",
+    "prettier": "^3.8.0",
+    "sonarqube-scanner": "^4.3.4"
+  },
+  "redep": {
+    "secret_key": "4k94jLuEIT_jWPHJYPActmGxn2x72eR0",
+    "working_dir": "C:\\Users\\nafie\\Documents\\trae_projects\\remote-deploy-cli"
   }
 }

package/scripts/update.js

@@ -83,7 +83,6 @@ try {
   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/sonar-project.js

@@ -0,0 +1,22 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const sonarScannerModule = require('@sonar/scan');
+const sonarScanner = sonarScannerModule.scan || sonarScannerModule.default || sonarScannerModule;
+
+sonarScanner(
+  {
+    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': pkg.version,
+      'sonar.sources': 'bin,lib',
+      'sonar.tests': 'test',
+      'sonar.javascript.lcov.reportPaths': 'coverage/lcov.info',
+      'sonar.sourceEncoding': 'UTF-8',
+    },
+  },
+  () => process.exit()
+);