redep 2.0.0

package/.env.example

@@ -0,0 +1,7 @@
+# Server Configuration
+SERVER_PORT=3000
+SECRET_KEY=your-secret-key
+WORKING_DIR=/path/to/your/project
+
+# Client Configuration
+SERVER_URL=http://localhost:3000

package/.github/workflows/ci-cd.yml

@@ -0,0 +1,69 @@
+name: CI/CD Pipeline
+
+on:
+  release:
+    types: [created]
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  docker:
+    name: Build and Push Docker Image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: nafies1/redep
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest,enable=${{ !github.event.release.prerelease }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+  npm:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    needs: docker # Wait for docker build to ensure code is stable/buildable
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

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/Dockerfile

@@ -0,0 +1,27 @@
+FROM node:25.3.0-alpine
+
+# Install Docker CLI and Docker Compose plugin
+# We need these to execute docker commands from the slave
+RUN apk add --no-cache docker-cli docker-cli-compose
+
+WORKDIR /app
+
+# Install app dependencies
+COPY package*.json ./
+RUN npm install --production
+
+# Bundle app source
+COPY . .
+
+# Make the CLI executable
+RUN chmod +x bin/index.js
+
+# Expose the default port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+# Start the server listener by default
+CMD ["node", "bin/index.js", "listen"]

package/README.md

@@ -0,0 +1,172 @@
+# redep (Remote Deployment Tool)
+
+> A secure, streaming deployment tool for Node.js and Docker environments. Real-time logs, multi-server support, and secure execution.
+
+[![npm version](https://img.shields.io/npm/v/redep.svg)](https://www.npmjs.com/package/redep)
+[![Docker Pulls](https://img.shields.io/docker/pulls/nafies1/redep)](https://hub.docker.com/r/nafies1/redep)
+[![License](https://img.shields.io/npm/l/redep.svg)](LICENSE)
+[![Build Status](https://github.com/nafies1/redep/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/nafies1/redep/actions)
+
+## 📖 Project Overview
+
+**redep** is a lightweight, secure Command Line Interface (CLI) designed to simplify remote deployment workflows. It solves the problem of "blind deployments" by establishing a real-time WebSocket connection between your local machine (or CI/CD runner) and your remote servers.
+
+### Key Features
+
+- **📺 Real-time Streaming**: Watch your deployment logs (stdout/stderr) stream live to your terminal.
+- **🔒 Secure**: Uses Token-based authentication and strictly isolated command execution.
+- **⚡ Multi-Server**: Manage multiple environments (Development, UAT, Production) from a single config.
+- **🐳 Docker Ready**: Comes with a production-ready Docker image for instant server setup.
+- **🛠️ Flexible**: Execute any command you define (`docker compose`, `kubectl`, shell scripts, etc.).
+
+---
+
+## 🚀 Installation
+
+### npm Package (Client & Server)
+
+Install globally to use the CLI on your local machine or server.
+
+```bash
+npm install -g redep
+```
+
+### Docker Image (Server Only)
+
+Pull the official image for running the server component.
+
+```bash
+docker pull nafies1/redep:latest
+```
+
+---
+
+## 📖 Usage Guide
+
+### 1. Setting up the Server
+
+The server is the agent that runs on your remote machine and executes the deployment commands.
+
+#### Option A: Using Docker (Recommended)
+
+```bash
+docker run -d \
+  --name redep-server \
+  --restart always \
+  -p 3000:3000 \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  -v $(pwd):/app/workspace \
+  -e SECRET_KEY=your-super-secret-key \
+  -e WORKING_DIR=/app/workspace \
+  -e DEPLOYMENT_COMMAND="docker compose pull && docker compose up -d" \
+  nafies1/redep:latest
+```
+
+#### Option B: Using npm & PM2
+
+```bash
+# Initialize configuration
+redep init server
+# Follow the prompts to set port, working dir, and secret key
+
+# Start the server
+redep start
+```
+
+### 2. Setting up the Client
+
+The client runs on your local machine or CI pipeline.
+
+```bash
+# Initialize a server profile
+redep init client
+# ? Enter Server Name: prod
+# ? Enter Server URL (Host): http://your-server-ip:3000
+# ? Enter Secret Key: your-super-secret-key
+```
+
+### 3. Deploying
+
+Trigger a deployment to your configured server.
+
+```bash
+redep deploy prod
+```
+
+You will see:
+```text
+(INFO) Connecting to http://your-server-ip:3000...
+(SUCCESS) Connected to server. requesting deployment...
+(INFO) [10:00:01 AM] Status: Deployment Started
+(INFO) [10:00:02 AM] [STDOUT] Pulling images...
+(INFO) [10:00:05 AM] [STDOUT] Container recreated.
+(SUCCESS) [10:00:06 AM] Status: Deployment Completed
+```
+
+---
+
+## ⚙️ Configuration
+
+`redep` uses a hierarchical configuration system:
+1.  **Environment Variables** (Highest Priority)
+2.  **Config File** (Managed via CLI)
+
+See [Advanced Configuration](docs/ADVANCED_CONFIG.md) for full details on environment variables and config management.
+
+---
+
+## 💻 Development Setup
+
+### Prerequisites
+- Node.js >= 18
+- Docker (for testing container builds)
+
+### Local Development
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/nafies1/redep.git
+    cd redep
+    ```
+
+2.  **Install dependencies:**
+    ```bash
+    npm install
+    ```
+
+3.  **Link globally (optional):**
+    ```bash
+    npm link
+    ```
+
+4.  **Run tests:**
+    Currently, we rely on manual verification using the `test-target` directory.
+    ```bash
+    # Start server
+    npm run start -- listen
+    ```
+
+---
+
+## 🔄 CI/CD Pipeline
+
+This project uses GitHub Actions for automation:
+
+- **Build & Push Docker Image**: Triggered on new release tags. Pushes to Docker Hub.
+- **Publish npm Package**: Triggered on new release tags. Publishes to npm registry.
+
+See [.github/workflows/ci-cd.yml](.github/workflows/ci-cd.yml) for details.
+
+---
+
+## 📚 Additional Documentation
+
+- [Troubleshooting Guide](docs/TROUBLESHOOTING.md) - Solutions for common connection and auth issues.
+- [Advanced Configuration](docs/ADVANCED_CONFIG.md) - Deep dive into config options and PM2.
+- [API Reference](docs/API.md) - Socket.IO events and protocol details.
+
+---
+
+## 📄 License
+
+This project is licensed under the ISC License.

package/bin/index.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+
+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' with { 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
+  .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');
+
+configCommand
+  .command('set <key> <value>')
+  .description('Set a configuration key')
+  .action((key, value) => {
+    setConfig(key, value);
+    logger.success(`Configuration updated: ${key} = ${value}`);
+  });
+
+configCommand
+  .command('get <key>')
+  .description('Get a configuration key')
+  .action((key) => {
+    const value = getConfig(key);
+    logger.info(`${key}: ${value}`);
+  });
+
+configCommand
+  .command('list')
+  .description('List all configurations')
+  .action(() => {
+    const all = getAllConfig();
+    logger.info('Current Configuration:');
+    console.table(all);
+  });
+
+configCommand
+  .command('clear')
+  .description('Clear all configurations')
+  .action(() => {
+    clearConfig();
+    logger.success('All configurations have been cleared.');
+  });
+
+program.addCommand(configCommand);
+
+// Background Process Management
+program
+  .command('start')
+  .description('Start the server in background (daemon mode) using PM2 if available')
+  .option('-p, --port <port>', 'Port to listen on')
+  .action((options) => {
+    // Try to use PM2 first
+    try {
+      // 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'];
+
+      // 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;
+      }
+
+      const pm2 = spawn('pm2', args, {
+        stdio: 'inherit',
+        shell: true,
+        env: env, // Pass modified env with port
+      });
+
+      pm2.on('error', () => {
+        // Fallback to native spawn if PM2 is not found/fails
+        logger.info('PM2 not found, falling back to native background process...');
+        startNativeBackground(options);
+      });
+
+      pm2.on('close', (code) => {
+        if (code !== 0) {
+          logger.warn('PM2 start failed, falling back to native background process...');
+          startNativeBackground(options);
+        } else {
+          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 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}`);
+}
+
+program
+  .command('stop')
+  .description('Stop the background server')
+  .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) {
+        logger.warn('No active server found.');
+        return;
+      }
+
+      try {
+        process.kill(pid);
+        setConfig('server_pid', null);
+        logger.success(`Server stopped (PID ${pid})`);
+      } catch (e) {
+        if (e.code === 'ESRCH') {
+          logger.warn(`Process ${pid} not found. Cleaning up config.`);
+          setConfig('server_pid', null);
+        } else {
+          logger.error(`Failed to stop server: ${e.message}`);
+        }
+      }
+    });
+  });
+
+program
+  .command('status')
+  .description('Check server status')
+  .action(() => {
+    // 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);
+        }
+      }
+    });
+  });
+
+// Server Command
+program
+  .command('listen')
+  .description('Start the server to listen for commands')
+  .option('-p, --port <port>', 'Port to listen on', 3000)
+  .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.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.'
+      );
+      process.exit(1);
+    }
+
+    const deploymentCommand = getConfig('deployment_command') || process.env.DEPLOYMENT_COMMAND;
+    if (!deploymentCommand) {
+      logger.error(
+        'Error: "deployment_command" is not set. Please set it using "redep config set deployment_command <cmd>" or DEPLOYMENT_COMMAND env var.'
+      );
+      process.exit(1);
+    }
+
+    startServer(port, secret, workingDir, deploymentCommand);
+  });
+
+// Client Command
+program
+  .command('deploy <type>')
+  .description('Deploy a service (e.g., "fe") to the server machine')
+  .action(async (type) => {
+    const serverUrl = getConfig('server_url') || process.env.SERVER_URL;
+    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>"'
+      );
+      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>"'
+      );
+      process.exit(1);
+    }
+
+    try {
+      await deploy(type, serverUrl, secret);
+    } catch (error) {
+      logger.error(`Deploy failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/docker-compose.server.yml

@@ -0,0 +1,22 @@
+services:
+  deploy-server:
+    build: .
+    container_name: deploy-server
+    restart: unless-stopped
+
+    env_file:
+      - .env
+
+    ports:
+      - '${SERVER_PORT}:3000'
+    environment:
+      # Override WORKING_DIR to match the internal container path
+      - WORKING_DIR=/workspace
+    volumes:
+      # Required: Give access to the host's Docker Daemon
+      - /var/run/docker.sock:/var/run/docker.sock
+
+      # Required: Mount the project directory that contains docker-compose.yml
+      # Host Path : Container Path
+      # CHANGE THIS to your actual project path
+      - ${WORKING_DIR}:/workspace

package/docs/ADVANCED_CONFIG.md

@@ -0,0 +1,60 @@
+# Advanced Configuration
+
+## Server Configuration
+
+The server can be configured via Environment Variables or the CLI configuration store. Environment variables take precedence.
+
+| Variable             | Config Key           | Description                                                                | Default |
+| -------------------- | -------------------- | -------------------------------------------------------------------------- | ------- |
+| `SERVER_PORT`        | `server_port`        | The TCP port the server listens on.                                        | `3000`  |
+| `SECRET_KEY`         | `secret_key`         | A shared secret string for authentication. **Required**.                   | -       |
+| `WORKING_DIR`        | `working_dir`        | The absolute path where the deployment command is executed. **Required**.  | -       |
+| `DEPLOYMENT_COMMAND` | `deployment_command` | The shell command to execute when a deployment is triggered. **Required**. | -       |
+
+### Using PM2
+
+For production usage without Docker, we recommend using PM2.
+
+```bash
+# Start with PM2
+pm2 start server-entry.js --name redep-server --env SECRET_KEY=xyz --env WORKING_DIR=/app
+```
+
+The CLI `redep start` command automatically attempts to use PM2 if installed.
+
+## Client Configuration
+
+Clients can be configured to talk to multiple servers (e.g., `dev`, `staging`, `prod`).
+
+```json
+{
+  "servers": {
+    "prod": {
+      "host": "https://deploy.example.com",
+      "secret_key": "prod-secret"
+    },
+    "staging": {
+      "host": "http://10.0.0.5:3000",
+      "secret_key": "staging-secret"
+    }
+  }
+}
+```
+
+### Managing Servers via CLI
+
+```bash
+# Set a server
+redep config set servers.dev.host http://localhost:3000
+redep config set servers.dev.secret_key mysecret
+
+# Get a server config
+redep config get servers.dev
+```
+
+## Security Best Practices
+
+1.  **TLS/SSL**: Always use HTTPS for the `host` URL in production. The WebSocket connection will automatically use WSS (Secure WebSocket).
+2.  **Secret Rotation**: Rotate your `SECRET_KEY` periodically.
+3.  **Firewall**: Restrict access to the server port (3000) to known IP addresses (e.g., your VPN or CI/CD runner IPs).
+4.  **Least Privilege**: Run the server process with a user that has only the necessary permissions (e.g., access to Docker socket and the working directory).

package/docs/API.md

@@ -0,0 +1,59 @@
+# API Reference
+
+`redep` uses `socket.io` for real-time communication. If you want to build a custom client, you can connect to the server using any Socket.IO client.
+
+## Connection
+
+**URL**: `http://<server-ip>:<port>` (or `https://` if configured)
+
+**Authentication**:
+You must provide the `token` in the `auth` object during the handshake.
+
+```javascript
+const socket = io('http://localhost:3000', {
+  auth: {
+    token: 'YOUR_SECRET_KEY',
+  },
+});
+```
+
+## Events
+
+### Client -> Server
+
+| Event    | Data   | Description                                 |
+| -------- | ------ | ------------------------------------------- |
+| `deploy` | `null` | Triggers the configured deployment command. |
+
+### Server -> Client
+
+| Event    | Data Structure                                                          | Description                                                                  |
+| -------- | ----------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `status` | `{ status: string, message?: string, error?: string, timestamp: Date }` | Updates on the deployment state. Statuses: `started`, `completed`, `failed`. |
+| `log`    | `{ type: 'stdout' \| 'stderr', data: string, timestamp: Date }`         | Real-time log output from the deployment process.                            |
+
+## Example Custom Client (Node.js)
+
+```javascript
+import { io } from 'socket.io-client';
+
+const socket = io('http://localhost:3000', {
+  auth: { token: 'my-secret' },
+});
+
+socket.on('connect', () => {
+  console.log('Connected!');
+  socket.emit('deploy');
+});
+
+socket.on('log', (data) => {
+  console.log(`[${data.type}] ${data.data}`);
+});
+
+socket.on('status', (data) => {
+  console.log(`Status: ${data.status}`);
+  if (data.status === 'completed' || data.status === 'failed') {
+    socket.close();
+  }
+});
+```

package/docs/TROUBLESHOOTING.md

@@ -0,0 +1,64 @@
+# Troubleshooting Guide
+
+## Common Issues
+
+### 1. Connection Refused
+**Error:** `Connection failed: connect ECONNREFUSED 127.0.0.1:3000`
+
+**Possible Causes:**
+- The server is not running.
+- The server is running on a different port.
+- The server is running inside Docker but the port is not mapped correctly.
+- Firewall blocking the connection.
+
+**Solutions:**
+- Check if the server is running: `redep status` or `docker ps`.
+- Verify the port: `redep config get server_port`.
+- If using Docker, ensure `-p 3000:3000` is used.
+- Check firewall settings.
+
+### 2. Authentication Failed
+**Error:** `Authentication error: Invalid secret key` or `403 Forbidden`
+
+**Possible Causes:**
+- The `SECRET_KEY` on the client does not match the server's key.
+- The `SECRET_KEY` was not set on the server.
+
+**Solutions:**
+- Verify client key: `redep config get servers.<name>.secret_key`.
+- Verify server key: Check `SECRET_KEY` env var or `redep config get secret_key`.
+- Regenerate keys if necessary: `redep generate secret_key` (on server) and update client.
+
+### 3. Deployment Command Failed
+**Error:** `Deployment failed: Process exited with code 1`
+
+**Possible Causes:**
+- The `DEPLOYMENT_COMMAND` failed to execute successfully.
+- Missing dependencies (e.g., `docker`, `npm`, `git`) in the server environment.
+- Permission issues in `WORKING_DIR`.
+
+**Solutions:**
+- Check the streamed logs for the specific error message from the command.
+- Ensure the `WORKING_DIR` exists and is writable.
+- If running in Docker, ensure the necessary tools are installed or volumes are mounted correctly (e.g., `/var/run/docker.sock` for Docker commands).
+
+### 4. "socket hang up" or Disconnects
+**Possible Causes:**
+- Network instability.
+- Server crashed during execution.
+- Timeout settings on intermediate proxies (Nginx, etc.).
+
+**Solutions:**
+- Check server logs: `docker logs redep-server` or `pm2 logs redep-server`.
+- If using a reverse proxy, ensure WebSocket support is enabled and timeouts are increased.
+
+### 5. Config Not Saving
+**Error:** Changes to config don't persist.
+
+**Possible Causes:**
+- Permission issues with the config file location.
+- Corrupted config file.
+
+**Solutions:**
+- Run `redep config path` to see where the config is stored.
+- Try clearing config: `redep config clear`.

package/lib/client/client.js

@@ -0,0 +1,59 @@
+import { io } from 'socket.io-client';
+import { logger } from '../logger.js';
+
+export const connectAndDeploy = (serverUrl, secret) => {
+  return new Promise((resolve, reject) => {
+    logger.info(`Connecting to ${serverUrl}...`);
+
+    const socket = io(serverUrl, {
+      auth: {
+        token: secret,
+      },
+      reconnection: false, // Don't auto reconnect for a single command execution
+    });
+
+    socket.on('connect', () => {
+      logger.success('Connected to server. requesting deployment...');
+      socket.emit('deploy');
+    });
+
+    socket.on('connect_error', (err) => {
+      logger.error(`Connection error: ${err.message}`);
+      socket.close();
+      reject(err);
+    });
+
+    socket.on('status', (data) => {
+      const time = new Date(data.timestamp).toLocaleTimeString();
+      
+      if (data.status === 'started') {
+        logger.info(`[${time}] Status: ${data.message || 'Deployment Started'}`);
+      } else if (data.status === 'completed') {
+        logger.success(`[${time}] Status: ${data.message || 'Deployment Completed'}`);
+        socket.close();
+        resolve();
+      } else if (data.status === 'failed') {
+        logger.error(`[${time}] Status: ${data.error || 'Deployment Failed'}`);
+        socket.close();
+        reject(new Error(data.error));
+      }
+    });
+
+    socket.on('log', (data) => {
+      const time = new Date(data.timestamp).toLocaleTimeString();
+      const msg = data.data.trim();
+      if (msg) {
+        if (data.type === 'stderr') {
+          console.error(`[${time}] [STDERR] ${msg}`);
+        } else {
+          console.log(`[${time}] [STDOUT] ${msg}`);
+        }
+      }
+    });
+
+    socket.on('disconnect', () => {
+      // If disconnected without completion/failure, it might be an issue
+      // But usually 'status' events close the socket.
+    });
+  });
+};

package/lib/client/index.js

@@ -0,0 +1,13 @@
+import { connectAndDeploy } from './client.js';
+import { logger } from '../logger.js';
+
+export const deploy = async (serverName, serverUrl, secret) => {
+  logger.info(`Starting deployment sequence for target: ${serverName}`);
+  
+  try {
+    await connectAndDeploy(serverUrl, secret);
+  } catch (err) {
+    logger.error(`Deployment failed: ${err.message}`);
+    throw err;
+  }
+};

package/lib/config.js

@@ -0,0 +1,22 @@
+import Conf from 'conf';
+
+const config = new Conf({
+  projectName: 'redep',
+  encryptionKey: 'redep-secure-storage', // Obfuscates the config file
+});
+
+export const getConfig = (key) => {
+  return config.get(key);
+};
+
+export const setConfig = (key, value) => {
+  config.set(key, value);
+};
+
+export const clearConfig = () => {
+  config.clear();
+};
+
+export const getAllConfig = () => {
+  return config.store;
+};

package/lib/logger.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg) => console.log(chalk.blue('ℹ') + ' ' + msg),
+  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),
+};

package/lib/server/executor.js

@@ -0,0 +1,46 @@
+import { spawn } from 'child_process';
+import { logger } from '../logger.js';
+
+export const spawnCommand = (command, workingDir, onStdout, onStderr) => {
+  return new Promise((resolve, reject) => {
+    logger.info(`Executing: ${command} in ${workingDir}`);
+
+    // Parse command string into command and args for spawn
+    // This is a simple split, for complex commands with quotes, we might need a parser or use shell: true
+    // Using shell: true is easier for compatibility with the existing full command strings
+    const child = spawn(command, {
+      cwd: workingDir,
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    if (child.stdout) {
+      child.stdout.on('data', (data) => {
+        const output = data.toString();
+        if (onStdout) onStdout(output);
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        const output = data.toString();
+        if (onStderr) onStderr(output);
+      });
+    }
+
+    child.on('error', (error) => {
+      logger.error(`Execution error: ${error.message}`);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Execution successful');
+        resolve();
+      } else {
+        logger.error(`Process exited with code ${code}`);
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+  });
+};

package/lib/server/index.js

@@ -0,0 +1,23 @@
+import { createServer } from 'http';
+import { createApp, setupSocket } from './server.js';
+import { logger } from '../logger.js';
+
+export const startServer = (port, secret, workingDir, deploymentCommand) => {
+  if (!secret) {
+    logger.error('Cannot start server: Secret key is required for security.');
+    process.exit(1);
+  }
+
+  const app = createApp();
+  const httpServer = createServer(app);
+  
+  // Attach Socket.io
+  setupSocket(httpServer, secret, workingDir, deploymentCommand);
+
+  httpServer.listen(port, () => {
+    logger.success(`Server is running on port ${port}`);
+    logger.info(`Working Directory: ${workingDir}`);
+    logger.info(`Deployment Command: ${deploymentCommand}`);
+    logger.info(`Waiting for connections...`);
+  });
+};

package/lib/server/server.js

@@ -0,0 +1,70 @@
+import express from 'express';
+import { Server } from 'socket.io';
+import helmet from 'helmet';
+import cors from 'cors';
+import { spawnCommand } from './executor.js';
+import { logger } from '../logger.js';
+
+export const createApp = () => {
+  const app = express();
+  app.use(helmet());
+  app.use(cors());
+
+  app.get('/health', (req, res) => res.status(200).json({ status: 'ok' }));
+
+  return app;
+};
+
+export const setupSocket = (httpServer, secretKey, workingDir, deploymentCommand) => {
+  const io = new Server(httpServer, {
+    cors: {
+      origin: '*',
+      methods: ['GET', 'POST'],
+    },
+  });
+
+  // Authentication Middleware
+  io.use((socket, next) => {
+    const token = socket.handshake.auth.token;
+    if (token === secretKey) {
+      next();
+    } else {
+      logger.warn(`Authentication failed for socket: ${socket.id}`);
+      next(new Error('Authentication error: Invalid secret key'));
+    }
+  });
+
+  io.on('connection', (socket) => {
+    logger.info(`Client connected: ${socket.id}`);
+
+    socket.on('deploy', async () => {
+      logger.info(`Starting deployment sequence triggered by ${socket.id}`);
+      socket.emit('status', { status: 'started', message: 'Deployment started', timestamp: new Date() });
+
+      try {
+        await spawnCommand(
+          deploymentCommand,
+          workingDir,
+          (log) => {
+            socket.emit('log', { type: 'stdout', data: log, timestamp: new Date() });
+          },
+          (log) => {
+            socket.emit('log', { type: 'stderr', data: log, timestamp: new Date() });
+          }
+        );
+
+        socket.emit('status', { status: 'completed', message: 'Deployment finished successfully', timestamp: new Date() });
+        logger.success('Deployment completed successfully');
+      } catch (error) {
+        socket.emit('status', { status: 'failed', error: error.message, timestamp: new Date() });
+        logger.error(`Deployment failed: ${error.message}`);
+      }
+    });
+
+    socket.on('disconnect', () => {
+      logger.info(`Client disconnected: ${socket.id}`);
+    });
+  });
+
+  return io;
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "redep",
+  "author": "nafies1",
+  "version": "2.0.0",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "redep": "./bin/index.js"
+  },
+  "scripts": {
+    "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": [
+    "deployment",
+    "cli",
+    "remote-execution",
+    "docker",
+    "streaming",
+    "websocket",
+    "devops"
+  ],
+  "homepage": "https://github.com/nafies1/redep#readme",
+  "bugs": {
+    "url": "https://github.com/nafies1/redep/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nafies1/redep.git"
+  },
+  "license": "ISC",
+  "description": "Remote execution CLI for deployment",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "body-parser": "^1.20.2",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "conf": "^12.0.0",
+    "cors": "^2.8.5",
+    "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

@@ -0,0 +1,89 @@
+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,28 @@
+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');
+const deploymentCommand = process.env.DEPLOYMENT_COMMAND || getConfig('deployment_command');
+
+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);
+}
+
+if (!deploymentCommand) {
+  logger.error('Error: "deployment_command" is not set.');
+  process.exit(1);
+}
+
+startServer(port, secret, workingDir, deploymentCommand);

package/sonar-project.js

@@ -0,0 +1,23 @@
+import { createRequire } from 'module';
+import pkg from './package.json' with { type: 'json' };
+
+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()
+);