redep 2.0.2 → 2.1.0

package/.dockerignore

@@ -0,0 +1,63 @@
+# Node.js artifacts
+node_modules
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build and dependency artifacts
+coverage/
+dist/
+build/
+*.tgz
+*.tar.gz
+
+# Development and IDE files
+.git/
+.gitignore
+.gitattributes
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment and configuration
+.env
+.env.*
+!.env.example
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Documentation and licenses
+README.md
+LICENSE
+docs/
+CHANGELOG.md
+CONTRIBUTING.md
+
+# Test files
+test-target/
+*.test.js
+*.spec.js
+__tests__/
+__mocks__/
+
+# Log files
+*.log
+logs/
+
+# Docker files themselves
+Dockerfile
+.dockerignore
+
+# OS and backup files
+.DS_Store
+Thumbs.db
+
+# Package manager files
+package-lock.json
+npm-shrinkwrap.json
+yarn.lock
+sonar-project.js

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

@@ -46,6 +46,14 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
+      - name: Update Docker Hub Description
+        uses: peter-evans/dockerhub-description@v4
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          repository: nafies1/redep
+          readme-filepath: ./docs/DOCKER.md
+
   npm:
     name: Publish to npm
     runs-on: ubuntu-latest

package/Dockerfile

@@ -1,27 +1,57 @@
-FROM node:25.3.0-alpine
+# Stage 1: Dependencies
+FROM node:20-alpine AS deps
+WORKDIR /app
+
+# Copy package files to install dependencies
+COPY package.json ./
 
-# 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
+# Install only production dependencies for smaller image size
+# First try with package-lock.json, fallback to npm install if not available
+RUN if [ -f package-lock.json ]; then \
+  npm ci --only=production; \
+  else \
+  npm install --only=production; \
+  fi && \
+  npm cache clean --force
 
+# Stage 2: Runtime
+FROM node:20-alpine AS runner
 WORKDIR /app
 
-# Install app dependencies
-COPY package*.json ./
-RUN npm install --production
+# Install minimal Docker CLI and dumb-init (remove compose plugin if not essential)
+RUN apk add --no-cache \
+  docker-cli \
+  dumb-init && \
+  # Clean up apk cache to save space
+  rm -rf /var/cache/apk/*
+
+# Set environment to production
+ENV NODE_ENV=production
 
-# Bundle app source
-COPY . .
+# Copy dependencies from deps stage
+COPY --from=deps /app/node_modules ./node_modules
+
+# Copy only essential application files (avoid copying everything)
+COPY package.json ./
+COPY bin/ ./bin/
+COPY lib/ ./lib/
 
 # Make the CLI executable
-RUN chmod +x bin/index.js
+RUN chmod +x bin/index.js && \
+  # Remove development files that might have been copied
+  find . -name "*.md" -delete && \
+  find . -name "*.test.js" -delete && \
+  find . -name "test" -type d -exec rm -rf {} + 2>/dev/null || true
 
-# Expose the default port
+# Expose the port the server listens on
 EXPOSE 3000
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s \
-  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+# Health check to ensure the server is responsive
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:${SERVER_PORT:-3000}/health || exit 1
+
+# Use dumb-init as the entrypoint to handle signals
+ENTRYPOINT ["/usr/bin/dumb-init", "--"]
 
-# Start the server listener by default
-CMD ["node", "bin/index.js", "listen"]
+# Default command to start the server
+CMD ["node", "bin/index.js", "listen"]

package/README.md

@@ -49,6 +49,8 @@ The server is the agent that runs on your remote machine and executes the deploy
 
 #### Option A: Using Docker (Recommended)
 
+**Linux / macOS (Bash):**
+
 ```bash
 docker run -d \
   --name redep-server \
@@ -62,6 +64,21 @@ docker run -d \
   nafies1/redep:latest
 ```
 
+**Windows (PowerShell):**
+
+```powershell
+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
@@ -94,6 +111,7 @@ redep deploy prod
 ```
 
 You will see:
+
 ```text
 (INFO) Connecting to http://your-server-ip:3000...
 (SUCCESS) Connected to server. requesting deployment...
@@ -108,6 +126,7 @@ You will see:
 ## ⚙️ Configuration
 
 `redep` uses a hierarchical configuration system:
+
 1.  **Environment Variables** (Highest Priority)
 2.  **Config File** (Managed via CLI)
 
@@ -118,23 +137,27 @@ See [Advanced Configuration](docs/ADVANCED_CONFIG.md) for full details on enviro
 ## 💻 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
     ```
@@ -161,6 +184,7 @@ See [.github/workflows/ci-cd.yml](.github/workflows/ci-cd.yml) for details.
 
 ## 📚 Additional Documentation
 
+- [Docker Guide](docs/DOCKER.md) - Full reference for Docker deployment, configuration, and security.
 - [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.

package/bin/index.js

@@ -5,8 +5,10 @@ import { Command } from 'commander';
 import { spawn } from 'child_process';
 import crypto from 'crypto';
 import inquirer from 'inquirer';
+import Table from 'cli-table3';
+import chalk from 'chalk';
 import { logger } from '../lib/logger.js';
-import { getConfig, setConfig, getAllConfig, clearConfig } from '../lib/config.js';
+import { getConfig, setConfig, getAllConfig, clearConfig, getDetailedConfig, getClientConfig, getServerConfig, validateMandatoryConfig, getMissingConfigMessage } 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' };
@@ -38,10 +40,17 @@ program
     try {
       if (type === 'client') {
         const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'server_name',
+            message: 'Enter Server Name:',
+            default: 'prod',
+            validate: (input) => (input ? true : 'Server Name is required'),
+          },
           {
             type: 'input',
             name: 'server_url',
-            message: 'Enter Server URL:',
+            message: 'Enter Server URL (Host):',
             validate: (input) => (input ? true : 'Server URL is required'),
           },
           {
@@ -52,9 +61,13 @@ program
           },
         ]);
 
-        setConfig('server_url', answers.server_url);
-        setConfig('secret_key', answers.secret_key);
-        logger.success('Client configuration saved successfully.');
+        const servers = getConfig('servers') || {};
+        servers[answers.server_name] = {
+          url: answers.server_url,
+          secret: answers.secret_key,
+        };
+        setConfig('servers', servers);
+        logger.success(`Client configuration for '${answers.server_name}' saved successfully.`);
       } else {
         const answers = await inquirer.prompt([
           {
@@ -153,12 +166,182 @@ configCommand
   });
 
 configCommand
-  .command('list')
-  .description('List all configurations')
-  .action(() => {
-    const all = getAllConfig();
-    logger.info('Current Configuration:');
-    console.table(all);
+  .command('list [type]')
+  .description('List configurations (client, server, or all)')
+  .option('--json', 'Output as JSON')
+  .option('--sort <field>', 'Sort by: key, modified, source, security', 'key')
+  .action((type, options) => {
+    // Handle different list types
+    if (type === 'client') {
+      const clientConfig = getClientConfig();
+      
+      if (options.json) {
+        console.log(JSON.stringify(clientConfig, null, 2));
+        return;
+      }
+
+      if (clientConfig.length === 0) {
+        logger.warn('No client servers configured. Use "redep init client" to add servers.');
+        return;
+      }
+
+      // Create table for client config
+      const table = new Table({
+        head: ['Server', 'Host', 'Secret Key', 'Description', 'Security'],
+        style: { head: ['bold', 'white'] },
+        wordWrap: true,
+        colWidths: [15, 35, 15, 30, 12],
+      });
+
+      clientConfig.forEach((item) => {
+        let server = item.server;
+        let host = item.host;
+        let secret = item.secret_key;
+        let description = item.description;
+        let security = item.security;
+
+        // Color coding based on security
+        if (item.security === 'high') {
+          security = chalk.green(security);
+          server = chalk.green(server);
+        } else if (item.security === 'medium') {
+          security = chalk.yellow(security);
+          server = chalk.yellow(server);
+        } else if (item.security === 'low') {
+          security = chalk.cyan(security);
+          server = chalk.cyan(server);
+        }
+
+        table.push([server, host, secret, description, security]);
+      });
+
+      logger.info('Client Server Configurations:');
+      console.log(table.toString());
+      
+    } else if (type === 'server') {
+      const serverConfig = getServerConfig();
+      
+      if (options.json) {
+        console.log(JSON.stringify(serverConfig, null, 2));
+        return;
+      }
+
+      // Create table for server config
+      const table = new Table({
+        head: ['Key', 'Value', 'Default', 'Source', 'Updated', 'Security'],
+        style: { head: ['bold', 'white'] },
+        wordWrap: true,
+        colWidths: [20, 30, 15, 15, 25, 10],
+      });
+
+      serverConfig.forEach((item) => {
+        let key = item.key;
+        let value = typeof item.value === 'object' ? JSON.stringify(item.value) : String(item.value || '');
+        let def = typeof item.defaultValue === 'object' ? JSON.stringify(item.defaultValue) : String(item.defaultValue !== undefined ? item.defaultValue : '-');
+        let source = item.source;
+        let updated = item.updatedAt === 'N/A' ? '-' : new Date(item.updatedAt).toLocaleString();
+        let security = item.security || 'unknown';
+
+        // Color coding
+        if (item.source === 'Environment') {
+          source = chalk.cyan(source);
+          key = chalk.cyan(key);
+        } else if (item.isModified) {
+          source = chalk.yellow(source);
+          key = chalk.yellow(key);
+        }
+
+        if (['critical', 'high'].includes(item.security)) {
+          security = chalk.red(security);
+          if (item.security === 'critical') value = '********';
+        }
+
+        table.push([key, value, def, source, updated, security]);
+      });
+
+      logger.info('Server Configuration:');
+      console.log(table.toString());
+
+    } else {
+      // Default behavior - show all config (backward compatibility)
+      const detailed = getDetailedConfig();
+
+      // Sorting Logic
+      detailed.sort((a, b) => {
+        if (options.sort === 'key') return a.key.localeCompare(b.key);
+        if (options.sort === 'modified') return (b.updatedAt || '').localeCompare(a.updatedAt || '');
+        if (options.sort === 'source') return a.source.localeCompare(b.source);
+        if (options.sort === 'security') {
+          const levels = { critical: 0, high: 1, medium: 2, low: 3, unknown: 4 };
+          return (levels[a.security] || 4) - (levels[b.security] || 4);
+        }
+        return 0;
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(detailed, null, 2));
+        return;
+      }
+
+      // Table Setup (existing code)
+      const table = new Table({
+        head: ['Key', 'Value', 'Default', 'Source', 'Updated', 'Sec'],
+        style: { head: ['bold', 'white'] },
+        wordWrap: true,
+        colWidths: [20, 30, 15, 15, 25, 10],
+      });
+
+      let stats = { total: 0, modified: 0, env: 0, security: 0 };
+
+      detailed.forEach((item) => {
+        stats.total++;
+        if (item.source === 'Environment') stats.env++;
+        if (item.isModified) stats.modified++;
+        if (['critical', 'high'].includes(item.security)) stats.security++;
+
+        let key = item.key;
+        let value = typeof item.value === 'object' ? JSON.stringify(item.value) : String(item.value || '');
+        let def = typeof item.defaultValue === 'object' ? JSON.stringify(item.defaultValue) : String(item.defaultValue !== undefined ? item.defaultValue : '-');
+        let source = item.source;
+        let updated = item.updatedAt === 'N/A' ? '-' : new Date(item.updatedAt).toLocaleString();
+        let sec = item.security || 'unknown';
+
+        // Color Coding
+        if (item.source === 'Environment') {
+          source = chalk.cyan(source);
+          key = chalk.cyan(key);
+        } else if (item.isModified) {
+          source = chalk.yellow(source);
+          key = chalk.yellow(key);
+        }
+
+        if (['critical', 'high'].includes(item.security)) {
+          sec = chalk.red(sec);
+          if (item.security === 'critical') value = '********';
+        }
+
+        table.push([key, value, def, source, updated, sec]);
+      });
+
+      logger.info('Current Configuration:');
+      console.log(table.toString());
+
+      // Summary Statistics
+      console.log('\nSummary Statistics:');
+      console.log(
+        `Total: ${stats.total} | Modified: ${chalk.yellow(stats.modified)} | Env Overrides: ${chalk.cyan(
+          stats.env
+        )} | Security Critical: ${chalk.red(stats.security)}`
+      );
+
+      // Help Section
+      console.log('\nLegend:');
+      console.log(
+        `${chalk.cyan('Cyan')}: Environment Override | ${chalk.yellow(
+          'Yellow'
+        )}: Modified/File | ${chalk.red('Red')}: High Security`
+      );
+    }
   });
 
 configCommand
@@ -177,6 +360,14 @@ program
   .description('Start the server in background (daemon mode) using PM2 if available')
   .option('-p, --port <port>', 'Port to listen on')
   .action((options) => {
+    // Validate mandatory configuration before starting
+    const missingParams = validateMandatoryConfig();
+    if (missingParams.length > 0) {
+      const errorMessage = getMissingConfigMessage(missingParams);
+      logger.error(errorMessage);
+      process.exit(1);
+    }
+
     // Try to use PM2 first
     try {
       // Check if PM2 is available via API
@@ -322,49 +513,46 @@ program
 program
   .command('listen')
   .description('Start the server to listen for commands')
-  .option('-p, --port <port>', 'Port to listen on', 3000)
+  .option('-p, --port <port>', 'Port to listen on')
   .action((options) => {
+    // Validate mandatory configuration before starting
+    const missingParams = validateMandatoryConfig();
+    if (missingParams.length > 0) {
+      const errorMessage = getMissingConfigMessage(missingParams);
+      logger.error(errorMessage);
+      process.exit(1);
+    }
+
     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;
+  .command('deploy <serverName>')
+  .description('Deploy to a specific server (e.g., "prod")')
+  .action(async (serverName) => {
+    const servers = getConfig('servers') || {};
+    let serverUrl, secret;
+
+    if (servers[serverName]) {
+      serverUrl = servers[serverName].url;
+      secret = servers[serverName].secret;
+    } else {
+      serverUrl = getConfig('server_url') || process.env.SERVER_URL;
+      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>"'
+        `Error: Server "${serverName}" not found in config, and global "server_url" is not set.`
       );
+      logger.info('Run "redep init client" to configure a server.');
       process.exit(1);
     }
 
@@ -376,7 +564,7 @@ program
     }
 
     try {
-      await deploy(type, serverUrl, secret);
+      await deploy(serverName, serverUrl, secret);
     } catch (error) {
       logger.error(`Deploy failed: ${error.message}`);
       process.exit(1);

package/docs/ADVANCED_CONFIG.md

@@ -26,21 +26,29 @@ The CLI `redep start` command automatically attempts to use PM2 if installed.
 
 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"
-    }
-  }
-}
+### Client Server Configuration Table
+
+| Servers   | Host                          | Secret Key       | Description                         |
+| --------- | ----------------------------- | ---------------- | ----------------------------------- |
+| `prod`    | `https://deploy.example.com`  | `prod-secret`    | Production server with HTTPS        |
+| `staging` | `http://10.0.0.5:3000`        | `staging-secret` | Staging server on internal network  |
+| `uat`     | `http://uat.company.com:3000` | `uat-secret`     | User Acceptance Testing environment |
+| `dev`     | `http://localhost:3000`       | `dev-secret`     | Local development server            |
+
+### Viewing Client Configuration
+
+Use the new `redep config list client` command to display your client configurations in a structured table format:
+
+```bash
+# Display all client server configurations
+redep config list client
+
+# Display with custom sorting
+redep config list client --sort host
 ```
 
+This will show a formatted table with columns for Server Name, Host URL, and Security Level, making it easy to review all your configured deployment targets.
+
 ### Managing Servers via CLI
 
 ```bash
@@ -52,6 +60,51 @@ redep config set servers.dev.secret_key mysecret
 redep config get servers.dev
 ```
 
+### Viewing Configuration with New List Commands
+
+The enhanced `redep config list` command now supports viewing client and server configurations separately:
+
+```bash
+# View all client server configurations
+redep config list client
+
+# View server configuration only
+redep config list server
+
+# View all configurations (backward compatibility)
+redep config list
+
+# View with JSON output
+redep config list client --json
+redep config list server --json
+```
+
+**Client Configuration Table Example:**
+
+```
+┌─────────┬──────────────────────────────┬─────────────┬─────────────────────────────────────┬──────────┐
+│ Server  │ Host                         │ Secret Key  │ Description                         │ Security │
+├─────────┼──────────────────────────────┼─────────────┼─────────────────────────────────────┼──────────┤
+│ prod    │ https://deploy.example.com   │ ********    │ Production environment with HTTPS   │ high     │
+│ staging │ http://10.0.0.5:3000         │ ********    │ Staging environment for testing     │ medium   │
+│ uat     │ http://uat.company.com:3000  │ ********    │ User Acceptance Testing environment │ medium   │
+│ dev     │ http://localhost:3000        │ ********    │ Local development server            │ low      │
+└─────────┴──────────────────────────────┴─────────────┴─────────────────────────────────────┴──────────┘
+```
+
+**Server Configuration Table Example:**
+
+```
+┌────────────────────┬──────────────────────────────┬───────────────┬───────────────┬─────────────────────────┬──────────┐
+│ Key                │ Value                        │ Default       │ Source        │ Updated                 │ Security │
+├────────────────────┼──────────────────────────────┼───────────────┼───────────────┼─────────────────────────┼──────────┤
+│ server_port        │ 3000                         │ 3000          │ Environment   │ 2026-01-22 14:28:14     │ low      │
+│ secret_key         │ ********                     │ null          │ File          │ 2026-01-22 14:30:22     │ critical │
+│ working_dir        │ /app/workspace               │ null          │ Environment   │ -                       │ medium   │
+│ deployment_command │ docker compose up -d         │ null          │ File          │ -                       │ high     │
+└────────────────────┴──────────────────────────────┴───────────────┴───────────────┴─────────────────────────┴──────────┘
+```
+
 ## Security Best Practices
 
 1.  **TLS/SSL**: Always use HTTPS for the `host` URL in production. The WebSocket connection will automatically use WSS (Secure WebSocket).

package/docs/DOCKER.md

@@ -0,0 +1,189 @@
+# 🐳 Docker Configuration & Usage Guide
+
+This guide provides comprehensive instructions for running `redep` server using Docker. The Docker image is optimized for size and security, based on Alpine Linux.
+
+## 🚀 Quick Start
+
+### 1. Pull the Image
+
+```bash
+docker pull nafies1/redep:latest
+```
+
+### 2. Run the Server
+
+To run the server, you need to provide a **Secret Key** and mount the **Docker Socket** (so `redep` can execute Docker commands on the host).
+
+#### Linux / macOS (Bash)
+
+```bash
+docker run -d \
+  --name redep-server \
+  --restart always \
+  -p 3000:3000 \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  -v $(pwd)/workspace:/app/workspace \
+  -e SECRET_KEY=your-super-secret-key \
+  -e WORKING_DIR=/app/workspace \
+  -e DEPLOYMENT_COMMAND="docker compose up -d" \
+  nafies1/redep:latest
+```
+
+#### Windows (PowerShell)
+
+```powershell
+docker run -d `
+  --name redep-server `
+  --restart always `
+  -p 3000:3000 `
+  -v /var/run/docker.sock:/var/run/docker.sock `
+  -v ${PWD}/workspace:/app/workspace `
+  -e SECRET_KEY=your-super-secret-key `
+  -e WORKING_DIR=/app/workspace `
+  -e DEPLOYMENT_COMMAND="docker compose up -d" `
+  nafies1/redep:latest
+```
+
+#### Windows (Command Prompt)
+
+```cmd
+docker run -d ^
+  --name redep-server ^
+  --restart always ^
+  -p 3000:3000 ^
+  -v /var/run/docker.sock:/var/run/docker.sock ^
+  -v %cd%/workspace:/app/workspace ^
+  -e SECRET_KEY=your-super-secret-key ^
+  -e WORKING_DIR=/app/workspace ^
+  -e DEPLOYMENT_COMMAND="docker compose up -d" ^
+  nafies1/redep:latest
+```
+
+---
+
+## ⚙️ Configuration Reference
+
+### Environment Variables
+
+| Variable             | Description                                                 | Default      | Required |
+| -------------------- | ----------------------------------------------------------- | ------------ | -------- |
+| `SECRET_KEY`         | Secret token for authentication with the client.            | -            | **Yes**  |
+| `WORKING_DIR`        | Directory inside the container where commands are executed. | -            | **Yes**  |
+| `DEPLOYMENT_COMMAND` | Command to execute when a deployment is triggered.          | -            | **Yes**  |
+| `SERVER_PORT`        | Port the server listens on inside the container.            | `3000`       | No       |
+| `NODE_ENV`           | Node.js environment mode.                                   | `production` | No       |
+
+### Volume Mounts
+
+| Host Path              | Container Path         | Purpose                                                                                                      |
+| ---------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `/var/run/docker.sock` | `/var/run/docker.sock` | **Required**. Allows the container to control the host's Docker daemon.                                      |
+| `./workspace`          | `/app/workspace`       | **Recommended**. Persist your project files (e.g., `docker-compose.yml`) so they survive container restarts. |
+
+---
+
+## 📦 Docker Compose Examples
+
+### Basic Setup
+
+Create a `docker-compose.redep.yml`:
+
+```yaml
+services:
+  redep-server:
+    image: nafies1/redep:latest
+    container_name: redep-server
+    restart: always
+    ports:
+      - '3000:3000'
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./my-project:/app/workspace
+    environment:
+      - SECRET_KEY=change-me-to-something-secure
+      - WORKING_DIR=/app/workspace
+      - DEPLOYMENT_COMMAND=docker compose pull && docker compose up -d
+```
+
+Run with:
+
+```bash
+docker compose -f docker-compose.redep.yml up -d
+```
+
+### Advanced Setup (Traefik + Watchtower)
+
+```yaml
+services:
+  redep-server:
+    image: nafies1/redep:latest
+    networks:
+      - web
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./workspace:/app/workspace
+    environment:
+      - SECRET_KEY=${REDEP_SECRET}
+      - WORKING_DIR=/app/workspace
+      - DEPLOYMENT_COMMAND=docker compose up -d --build
+    labels:
+      - 'traefik.enable=true'
+      - 'traefik.http.routers.redep.rule=Host(`deploy.example.com`)'
+
+networks:
+  web:
+    external: true
+```
+
+---
+
+## 🛠️ Troubleshooting
+
+### 1. "Docker command not found" or Permission Denied
+
+- **Symptom**: Deployment logs show `docker: not found` or `permission denied`.
+- **Cause**: The container cannot access the host's Docker socket.
+- **Fix**: Ensure you passed `-v /var/run/docker.sock:/var/run/docker.sock`. On some systems, you may need to run the container with `--group-add $(getent group docker | cut -d: -f3)` or `user: root` (though root is not recommended if avoidable).
+
+### 2. "Connection Refused"
+
+- **Symptom**: Client says `xhr poll error`.
+- **Cause**: The server is not running, or the port is not mapped correctly.
+- **Fix**: Check `docker ps`. Ensure `-p 3000:3000` matches the internal `SERVER_PORT`.
+
+### 3. "Directory not found"
+
+- **Symptom**: Error regarding `WORKING_DIR`.
+- **Fix**: Ensure the `WORKING_DIR` path exists inside the container. Mounting a volume automatically creates the directory.
+
+---
+
+## 🔒 Security Best Practices
+
+1.  **Least Privilege**: The container runs as `root` by default to access the Docker socket easily. For higher security, consider using a non-root user and adding them to the docker group (requires custom image extension).
+2.  **Network Isolation**: Don't expose port 3000 to the public internet directly. Use a reverse proxy (Nginx, Traefik) with SSL/TLS and IP whitelisting if possible.
+3.  **Secret Management**: Do not commit your `SECRET_KEY` to version control. Use `.env` files (excluded from git) or Docker Secrets.
+4.  **Socket Exposure**: Mounting `/var/run/docker.sock` gives the container full control over the host. Ensure only trusted commands are executed via `DEPLOYMENT_COMMAND`.
+
+---
+
+## 🚀 Performance Tuning
+
+- **Base Image**: We use `node:20-alpine` for a lightweight footprint (<100MB).
+- **Memory Limit**: The server is lightweight. You can limit memory usage:
+  ```bash
+  --memory="256m" --cpus="0.5"
+  ```
+- **Layer Caching**: The Dockerfile uses multi-stage builds. Dependencies are cached in a separate layer, so rebuilding the image after code changes is fast.
+
+## 📋 Version Compatibility
+
+| redep Version | Docker Tag | Node.js Version |
+| ------------- | ---------- | --------------- |
+| 2.x           | `latest`   | 20 (LTS)        |
+| 1.x           | `v1`       | 18              |
+
+## 🔗 Additional Resources
+
+- [Official Docker Documentation](https://docs.docker.com/)
+- [Node.js Docker Best Practices](https://github.com/nodejs/docker-node/blob/main/docs/BestPractices.md)

package/lib/client/client.js

@@ -18,7 +18,11 @@ export const connectAndDeploy = (serverUrl, secret) => {
     });
 
     socket.on('connect_error', (err) => {
-      logger.error(`Connection error: ${err.message}`);
+      let msg = err.message;
+      if (msg === 'xhr poll error' || msg.includes('ECONNREFUSED')) {
+        msg = `Could not connect to server at ${serverUrl}. Is the server running?`;
+      }
+      logger.error(`Connection error: ${msg}`);
       socket.close();
       reject(err);
     });

package/lib/config.js

@@ -5,12 +5,78 @@ const config = new Conf({
   encryptionKey: 'redep-secure-storage', // Obfuscates the config file
 });
 
+export const CONFIG_SCHEMA = {
+  server_port: {
+    default: 3000,
+    security: 'low',
+    env: 'SERVER_PORT',
+    description: 'Server Port',
+  },
+  secret_key: {
+    default: null,
+    security: 'critical',
+    env: 'SECRET_KEY',
+    description: 'Authentication Secret',
+  },
+  working_dir: {
+    default: null,
+    security: 'medium',
+    env: 'WORKING_DIR',
+    description: 'Working Directory',
+  },
+  deployment_command: {
+    default: null,
+    security: 'high',
+    env: 'DEPLOYMENT_COMMAND',
+    description: 'Deployment Command',
+  },
+  server_url: {
+    default: null,
+    security: 'low',
+    env: 'SERVER_URL',
+    description: 'Default Server URL',
+  },
+  servers: {
+    default: {},
+    security: 'medium',
+    env: null,
+    description: 'Server Profiles',
+  },
+  server_pid: {
+    default: null,
+    security: 'low',
+    env: null,
+    description: 'Server Process ID',
+  },
+};
+
 export const getConfig = (key) => {
-  return config.get(key);
+  // Check environment variables first (highest priority)
+  if (CONFIG_SCHEMA[key] && CONFIG_SCHEMA[key].env) {
+    const envValue = process.env[CONFIG_SCHEMA[key].env];
+    if (envValue !== undefined) {
+      return envValue;
+    }
+  }
+  
+  // Then check stored config
+  const value = config.get(key);
+  
+  // If value is undefined but key exists in schema, return default value
+  if (value === undefined && CONFIG_SCHEMA[key]) {
+    return CONFIG_SCHEMA[key].default;
+  }
+  
+  return value;
 };
 
 export const setConfig = (key, value) => {
   config.set(key, value);
+  // Store metadata for timestamp
+  // We use a flat key for metadata to avoid interfering with nested config objects if possible,
+  // but since we want per-key tracking, we store it in a hidden _meta object.
+  const now = new Date().toISOString();
+  config.set(`_meta.${key}`, { updatedAt: now });
 };
 
 export const clearConfig = () => {
@@ -20,3 +86,141 @@ export const clearConfig = () => {
 export const getAllConfig = () => {
   return config.store;
 };
+
+export const getDetailedConfig = () => {
+  const all = config.store;
+  const meta = all._meta || {};
+  const result = [];
+
+  // Process Schema Keys
+  Object.keys(CONFIG_SCHEMA).forEach((key) => {
+    const schema = CONFIG_SCHEMA[key];
+    const fileValue = config.get(key);
+    const envValue = schema.env ? process.env[schema.env] : undefined;
+
+    let currentValue = fileValue;
+    let source = 'File';
+
+    if (envValue !== undefined) {
+      currentValue = envValue;
+      source = 'Environment';
+    } else if (fileValue !== undefined) {
+      currentValue = fileValue;
+      source = 'File';
+    } else {
+      currentValue = schema.default;
+      source = 'Default';
+    }
+
+    result.push({
+      key,
+      value: currentValue,
+      defaultValue: schema.default,
+      source,
+      security: schema.security,
+      updatedAt: meta[key]?.updatedAt || 'N/A',
+      description: schema.description,
+    });
+  });
+
+  // Process Custom Keys (not in schema)
+  Object.keys(all).forEach((key) => {
+    if (!CONFIG_SCHEMA[key] && key !== '_meta') {
+      result.push({
+        key,
+        value: all[key],
+        defaultValue: undefined,
+        source: 'File', // Assumed file for custom keys
+        security: 'unknown',
+        updatedAt: meta[key]?.updatedAt || 'N/A',
+        description: 'Custom Configuration',
+      });
+    }
+  });
+
+  return result;
+};
+
+export const getClientConfig = () => {
+  const servers = config.get('servers') || {};
+  const result = [];
+
+  Object.keys(servers).forEach((serverName) => {
+    const server = servers[serverName];
+    result.push({
+      server: serverName,
+      host: server.url || 'Not configured',
+      secret_key: server.secret ? '********' : 'Not set',
+      description: getServerDescription(serverName),
+      security: getServerSecurityLevel(server.url),
+    });
+  });
+
+  return result;
+};
+
+export const getServerConfig = () => {
+  const detailed = getDetailedConfig();
+  // Filter hanya konfigurasi server (bukan client servers)
+  return detailed.filter((item) => 
+    ['server_port', 'secret_key', 'working_dir', 'deployment_command', 'server_pid'].includes(item.key)
+  );
+};
+
+function getServerDescription(serverName) {
+  const descriptions = {
+    prod: 'Production environment with high security',
+    staging: 'Staging environment for testing',
+    uat: 'User Acceptance Testing environment',
+    dev: 'Development environment',
+    test: 'Testing environment',
+  };
+  return descriptions[serverName.toLowerCase()] || 'Custom environment';
+}
+
+export const validateMandatoryConfig = () => {
+  const errors = [];
+  
+  // Check SECRET_KEY
+  const secretKey = getConfig('secret_key');
+  if (!secretKey) {
+    errors.push('secret_key');
+  }
+  
+  // Check WORKING_DIR
+  const workingDir = getConfig('working_dir');
+  if (!workingDir) {
+    errors.push('working_dir');
+  }
+  
+  // Check DEPLOYMENT_COMMAND
+  const deploymentCommand = getConfig('deployment_command');
+  if (!deploymentCommand) {
+    errors.push('deployment_command');
+  }
+  
+  return errors;
+};
+
+export const getMissingConfigMessage = (missingParams) => {
+  if (missingParams.length === 0) return null;
+  
+  const paramList = missingParams.map(param => `'${param}'`).join(', ');
+  const instructions = missingParams.map(param => {
+    const envVar = CONFIG_SCHEMA[param]?.env;
+    if (envVar) {
+      return `  - Set '${param}' using 'redep config set ${param} <value>' or add '${envVar}=<value>' to your .env file`;
+    }
+    return `  - Set '${param}' using 'redep config set ${param} <value>'`;
+  }).join('\n');
+  
+  return `Error: Required configuration parameter(s) ${paramList} are not set.\n${instructions}`;
+};
+
+function getServerSecurityLevel(host) {
+  if (!host) return 'unknown';
+  if (host.startsWith('https://')) return 'high';
+  if (host.startsWith('http://localhost') || host.startsWith('http://127.0.0.1')) return 'low';
+  if (host.startsWith('http://')) return 'medium';
+  return 'unknown';
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "redep",
   "author": "nafies1",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -37,6 +37,7 @@
     "axios": "^1.7.9",
     "body-parser": "^1.20.2",
     "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
     "commander": "^12.0.0",
     "conf": "^12.0.0",
     "cors": "^2.8.5",
@@ -53,9 +54,5 @@
     "@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/test-target/html/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Redep Test Deployment</title>
+</head>
+<body>
+    <h1>Redep Docker Deployment Test</h1>
+    <p>Server successfully deployed via redep!</p>
+    <p>Time: <span id="time"></span></p>
+    <script>
+        document.getElementById('time').textContent = new Date().toLocaleString();
+    </script>
+</body>
+</html>