remote-deploy-cli 1.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/npm-publish.yml

@@ -0,0 +1,31 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    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/Dockerfile

@@ -0,0 +1,23 @@
+FROM node:18-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
+
+# Start the server listener by default
+CMD ["node", "bin/index.js", "listen"]

package/README.md

@@ -0,0 +1,119 @@
+# redep (Remote Deploy CLI)
+
+A lightweight Node.js CLI tool for remote execution using a Client-Server architecture. Designed to simplify deployment workflows (e.g., triggering Docker Compose on a remote server).
+
+## Features
+
+- **Client-Server Architecture**: Centralized control where Client sends commands and Server executes them.
+- **Secure Communication**: Uses Token-based authentication (Bearer Token) to ensure only authorized clients can execute commands.
+- **Configurable**: Easy configuration management for both Client and Server via CLI or Environment Variables.
+- **Docker Integration**: Built-in support for `deploy fe` which pulls and restarts containers using Docker Compose.
+- **Docker Support**: Can be run as a Docker container itself on the server machine.
+- **Logging**: Detailed logs for tracking execution status.
+
+## Architecture
+
+1.  **Client Machine**: The client that issues deployment commands (e.g., your laptop or CI runner).
+2.  **Server Machine**: The server that hosts the application and executes the deployment commands (e.g., `docker compose up`).
+
+Communication happens via HTTP/REST with a shared secret for authentication.
+
+## Installation
+
+You can install this package globally using npm:
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd remote-deploy-cli
+
+# Install globally (for development/local use)
+npm install -g .
+```
+
+## Usage
+
+### 1. Configure the Server Machine
+
+#### Option A: Running directly on Node.js
+
+On the machine where you want to run your application (Server):
+
+1.  **Set the Working Directory**: This is where your `docker-compose.yml` is located.
+    ```bash
+    redep config set working_dir /path/to/your/project
+    ```
+
+2.  **Set a Secret Key**: A secure password for authentication.
+    ```bash
+    redep config set secret_key super-secure-secret-123
+    ```
+
+3.  **Start the Listener**:
+    ```bash
+    redep listen
+    # Optional: Specify port (default 3000)
+    # redep listen --port 4000
+    ```
+
+#### Option B: Running with Docker (Recommended)
+
+You can run the server itself inside a Docker container. We provide a `docker-compose.server.yml` as an example.
+
+1.  **Prerequisites**: Ensure Docker and Docker Compose are installed on the server machine.
+2.  **Run the Server**:
+
+    ```bash
+    # Edit docker-compose.server.yml to map your project directory
+    # Then run:
+    docker compose -f docker-compose.server.yml up -d --build
+    ```
+
+    **Configuration via `docker-compose.server.yml`**:
+    -   `volumes`:
+        -   `/var/run/docker.sock:/var/run/docker.sock`: Required to allow the server to manage sibling containers.
+        -   `./your-project:/workspace`: Mount your project directory containing `docker-compose.yml` to `/workspace` inside the container.
+    -   `environment`:
+        -   `WORKING_DIR=/workspace`: Must match the container mount path.
+        -   `SECRET_KEY=your-secret-key`: Set the shared secret.
+
+### 2. Configure the Client Machine
+
+On your local machine or CI/CD server (Client):
+
+1.  **Set the Server URL**: The address of your server machine.
+    ```bash
+    redep config set server_url http://<server-ip>:3000
+    ```
+    Or use `SERVER_URL` env var.
+
+2.  **Set the Secret Key**: Must match the key set on the Server.
+    ```bash
+    redep config set secret_key super-secure-secret-123
+    ```
+    Or use `SECRET_KEY` env var.
+
+### 3. Execute Deployment
+
+To deploy the Frontend (triggers `docker compose up -d` on the server):
+
+```bash
+redep deploy fe
+```
+
+## Security Best Practices
+
+- **Secret Management**: Ensure your `secret_key` is strong and not committed to version control.
+- **Network Security**: In production, it is recommended to run the Server behind a reverse proxy (like Nginx) with SSL/TLS (HTTPS) to encrypt the traffic, especially since the secret key is sent in the header.
+- **Firewall**: Restrict access to the Server port (default 3000) to only allow IPs from known Client machines.
+
+## Development
+
+- `bin/index.js`: CLI entry point.
+- `lib/server/`: Server and execution logic.
+- `lib/client/`: Client and command logic.
+- `lib/config.js`: Configuration management using `conf`.
+
+## License
+
+ISC

package/bin/index.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import { Command } from 'commander';
+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';
+
+const program = new Command();
+
+program
+  .name('redep')
+  .description('Remote execution CLI for deployment')
+  .version('1.0.0');
+
+// 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);
+
+// 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 || process.env.SERVER_PORT || getConfig('server_port') || 3000;
+    const secret = process.env.SECRET_KEY || getConfig('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 = process.env.WORKING_DIR || getConfig('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);
+    }
+
+    startServer(port, secret, workingDir);
+  });
+
+// Client Command
+program
+  .command('deploy <type>')
+  .description('Deploy a service (e.g., "fe") to the server machine')
+  .action(async (type) => {
+    const serverUrl = process.env.SERVER_URL || getConfig('server_url');
+    const secret = process.env.SECRET_KEY || getConfig('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/lib/client/client.js

@@ -0,0 +1,26 @@
+import axios from 'axios';
+
+export const sendCommand = async (url, endpoint, secret, data) => {
+  try {
+    // Ensure url has no trailing slash and endpoint has leading slash
+    const cleanUrl = url.replace(/\/$/, '');
+    const cleanEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    const fullUrl = `${cleanUrl}${cleanEndpoint}`;
+
+    const response = await axios.post(fullUrl, data, {
+      headers: {
+        '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)}`);
+    } else if (error.request) {
+      throw new Error(`Connection failed: No response from ${url}. Is the server running?`);
+    } else {
+      throw new Error(`Request error: ${error.message}`);
+    }
+  }
+};

package/lib/client/index.js

@@ -0,0 +1,31 @@
+import { sendCommand } from './client.js';
+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 {
+        logger.error('Server reported failure.');
+        console.error(result);
+      }
+    } catch (err) {
+      throw err;
+    }
+
+  } else {
+    logger.error(`Deployment type "${type}" is not supported yet.`);
+    throw new Error(`Unsupported deployment type: ${type}`);
+  }
+};

package/lib/config.js

@@ -0,0 +1,21 @@
+import Conf from 'conf';
+
+const config = new Conf({
+  projectName: 'redep'
+});
+
+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,23 @@
+import { exec } from 'child_process';
+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}`);
+      }
+
+      logger.success('Execution successful');
+      resolve({ stdout, stderr });
+    });
+  });
+};

package/lib/server/index.js

@@ -0,0 +1,17 @@
+import { createServer } from './server.js';
+import { logger } from '../logger.js';
+
+export const startServer = (port, secret, workingDir) => {
+  if (!secret) {
+    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}`);
+    logger.info(`Waiting for commands...`);
+  });
+};

package/lib/server/server.js

@@ -0,0 +1,63 @@
+import express from 'express';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import helmet from 'helmet';
+import morgan from 'morgan';
+import { logger } from '../logger.js';
+import { executeCommand } from './executor.js';
+
+export const createServer = (secretKey, workingDir) => {
+  const app = express();
+
+  app.use(helmet());
+  app.use(cors());
+  app.use(bodyParser.json());
+  app.use(morgan('tiny'));
+
+  // Auth Middleware
+  const authenticate = (req, res, next) => {
+    const authHeader = req.headers['authorization'];
+    if (!authHeader) {
+      return res.status(401).json({ error: 'Missing Authorization header' });
+    }
+
+    const token = authHeader.replace('Bearer ', '');
+    if (token !== secretKey) {
+      return res.status(403).json({ error: 'Invalid token' });
+    }
+    next();
+  };
+
+  app.post('/execute', authenticate, async (req, res) => {
+    const { command } = req.body;
+
+    if (!command) {
+      return res.status(400).json({ error: 'Missing command' });
+    }
+
+    try {
+      const result = await executeCommand(command, workingDir);
+      res.json({ status: 'success', output: result });
+    } catch (error) {
+      res.status(500).json({ status: 'error', error: error });
+    }
+  });
+
+  // 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';
+
+    try {
+      const result = await executeCommand(command, workingDir);
+      res.json({ status: 'success', output: result });
+    } catch (error) {
+      res.status(500).json({ status: 'error', error: error });
+    }
+  });
+
+  return app;
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "remote-deploy-cli",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "redep": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "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",
+    "morgan": "^1.10.0"
+  }
+}