suthep 0.1.0 → 0.2.0-beta.1

package/README.md

@@ -2,56 +2,83 @@
 
 A powerful CLI tool for deploying projects with automatic Nginx reverse proxy setup, HTTPS with Certbot, and zero-downtime deployments.
 
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Commands](#commands)
+- [Examples](#examples)
+- [Requirements](#requirements)
+- [Benefits](#benefits)
+- [License](#license)
+
 ## Features
 
-- ✅ Automatic Nginx reverse proxy setup
-- ✅ Automatic HTTPS with Certbot
-- ✅ Zero-downtime deployment
-- ✅ Docker container support
-- ✅ Multiple domain/subdomain support
-- ✅ Health check integration
-- ✅ YAML-based configuration
+- ✅ **Automatic Nginx Reverse Proxy** - Configures Nginx automatically for your services
+- ✅ **Automatic HTTPS** - Sets up SSL/TLS certificates with Let's Encrypt via Certbot
+- ✅ **Zero-Downtime Deployment** - Rolling deployment strategy ensures continuous availability
+- ✅ **Docker Support** - Deploy Docker containers or connect to existing containers
+- ✅ **Multiple Domains** - Support for multiple domains and subdomains per service
+- ✅ **Health Checks** - Built-in health check monitoring for service reliability
+- ✅ **YAML Configuration** - Simple, declarative configuration file format
 
 ## Installation
 
+Install Suthep globally using your preferred package manager:
+
 ```bash
-npm install
-npm link  # Makes 'deploy' command available globally
+npm install -g suthep
+# or
+yarn global add suthep
+# or
+pnpm add -g suthep
 ```
 
-The tool uses `tsx` to run TypeScript directly, so no build step is required for development. For production, you can still build:
+> **Note:** The tool uses `tsx` to run TypeScript directly, so no build step is required for development. For production builds, you can optionally compile to JavaScript using `npm run build`.
+
+## Quick Start
+
+### 1. Initialize Configuration
+
+Create a new configuration file interactively:
 
 ```bash
-npm run build  # Optional: compile to JavaScript
+suthep init
 ```
 
-## Quick Start
+This will create a `suthep.yml` file with interactive prompts, or you can use an example configuration:
 
-1. **Initialize a configuration file:**
-   ```bash
-   deploy init
-   ```
-   This will create a `deploy.yml` file with interactive prompts.
+```bash
+cp example/suthep.yml suthep.yml
+# Edit suthep.yml with your settings
+```
+
+### 2. Setup Prerequisites
 
-2. **Or use the example configuration:**
-   ```bash
-   cp example.yml deploy.yml
-   # Edit deploy.yml with your settings
-   ```
+Install and configure Nginx and Certbot on your system:
 
-3. **Setup prerequisites (Nginx and Certbot):**
-   ```bash
-   deploy setup
-   ```
+```bash
+suthep setup
+```
 
-4. **Deploy your project:**
-   ```bash
-   deploy deploy
-   ```
+This command will:
+- Install Nginx (if not already installed)
+- Install Certbot (if not already installed)
+- Configure system dependencies
+
+### 3. Deploy Your Project
+
+Deploy your project using the configuration file:
+
+```bash
+suthep deploy
+```
 
 ## Configuration
 
-The configuration file (`deploy.yml`) supports the following structure:
+The configuration file (`suthep.yml`) uses a YAML format to define your deployment. Here's the complete structure:
 
 ```yaml
 project:
@@ -95,56 +122,84 @@ deployment:
 
 ### Service Configuration
 
-Each service can have:
+Each service in the `services` array can have the following properties:
+
+| Property | Required | Description |
+|----------|----------|-------------|
+| `name` | ✅ Yes | Unique identifier for the service |
+| `port` | ✅ Yes | Port number the service runs on (host port) |
+| `domains` | ✅ Yes | Array of domain names or subdomains to route to this service |
+| `docker` | ❌ No | Docker configuration (see below) |
+| `healthCheck` | ❌ No | Health check configuration (see below) |
+| `environment` | ❌ No | Environment variables as key-value pairs |
+
+#### Docker Configuration
+
+When deploying Docker containers, use the `docker` object:
+
+- **`image`**: Docker image to pull and run (e.g., `nginx:latest`)
+- **`container`**: Name for the Docker container
+- **`port`**: Internal port the container listens on (mapped to the service `port`)
+
+#### Health Check Configuration
 
-- **name**: Unique service name
-- **port**: Port the service runs on
-- **domains**: Array of domain names or subdomains
-- **docker** (optional):
-  - **image**: Docker image to use
-  - **container**: Container name
-  - **port**: Container's internal port
-- **healthCheck** (optional):
-  - **path**: Health check endpoint path
-  - **interval**: Check interval in seconds
-- **environment** (optional): Environment variables
+Configure health monitoring for your service:
+
+- **`path`**: HTTP endpoint path for health checks (e.g., `/health`)
+- **`interval`**: Time between health checks in seconds (default: 30)
 
 ## Commands
 
-### `deploy init`
+### `suthep init`
 
-Initialize a new deployment configuration file.
+Initialize a new deployment configuration file with interactive prompts.
 
 ```bash
-deploy init [-f deploy.yml]
+suthep init [-f suthep.yml]
 ```
 
-### `deploy setup`
+**Options:**
+- `-f, --file`: Configuration file path (default: `suthep.yml`)
+
+### `suthep setup`
 
-Setup Nginx and Certbot on the system.
+Install and configure Nginx and Certbot on your system. This command checks for existing installations and sets up any missing components.
 
 ```bash
-deploy setup [--nginx-only] [--certbot-only]
+suthep setup [--nginx-only] [--certbot-only]
 ```
 
-### `deploy deploy`
+**Options:**
+- `--nginx-only`: Only install and configure Nginx
+- `--certbot-only`: Only install and configure Certbot
 
-Deploy a project using the configuration file.
+### `suthep deploy`
+
+Deploy your project using the configuration file. This command will:
+1. Configure Nginx reverse proxy for all services
+2. Obtain SSL certificates via Certbot (if enabled)
+3. Deploy services with zero-downtime strategy
 
 ```bash
-deploy deploy [-f deploy.yml] [--no-https] [--no-nginx]
+suthep deploy [-f suthep.yml] [--no-https] [--no-nginx]
 ```
 
-Options:
-- `-f, --file`: Configuration file path (default: `deploy.yml`)
-- `--no-https`: Skip HTTPS setup
-- `--no-nginx`: Skip Nginx configuration
+**Options:**
+- `-f, --file`: Configuration file path (default: `suthep.yml`)
+- `--no-https`: Skip HTTPS/SSL certificate setup
+- `--no-nginx`: Skip Nginx configuration (useful for testing)
 
 ## Examples
 
-### Simple Node.js Service
+### Example 1: Simple Node.js API Service
+
+Deploy a Node.js API service with health checks:
 
 ```yaml
+project:
+  name: my-api
+  version: 1.0.0
+
 services:
   - name: api
     port: 3000
@@ -152,9 +207,26 @@ services:
       - api.example.com
     healthCheck:
       path: /health
+      interval: 30
+    environment:
+      NODE_ENV: production
+
+nginx:
+  configPath: /etc/nginx/sites-available
+  reloadCommand: sudo nginx -t && sudo systemctl reload nginx
+
+certbot:
+  email: admin@example.com
+  staging: false
+
+deployment:
+  strategy: rolling
+  healthCheckTimeout: 30000
 ```
 
-### Docker Container Service
+### Example 2: Docker Container Service
+
+Deploy a web application using a Docker container:
 
 ```yaml
 services:
@@ -166,9 +238,12 @@ services:
       port: 80
     domains:
       - example.com
+      - www.example.com
 ```
 
-### Multiple Domains
+### Example 3: Multiple Domains for Single Service
+
+Route multiple domains to the same service:
 
 ```yaml
 services:
@@ -178,9 +253,13 @@ services:
       - dashboard.example.com
       - admin.example.com
       - app.example.com
+    healthCheck:
+      path: /api/health
 ```
 
-### Connect to Existing Docker Container
+### Example 4: Connect to Existing Docker Container
+
+Connect to an already running Docker container:
 
 ```yaml
 services:
@@ -193,21 +272,43 @@ services:
       - db.example.com
 ```
 
+> **Note:** When connecting to an existing container, omit the `image` field. The tool will use the existing container.
+
 ## Requirements
 
-- Node.js 16+
-- Nginx (installed via `deploy setup`)
-- Certbot (installed via `deploy setup`)
-- Docker (optional, for Docker-based services)
-- sudo access (for Nginx and Certbot operations)
+### System Requirements
+
+- **Node.js** 16 or higher
+- **Nginx** (installed automatically via `suthep setup`)
+- **Certbot** (installed automatically via `suthep setup`)
+- **Docker** (optional, required only for Docker-based services)
+- **sudo access** (required for Nginx and Certbot operations)
+
+### Permissions
+
+Suthep requires sudo privileges to:
+- Install system packages (Nginx, Certbot)
+- Modify Nginx configuration files
+- Reload Nginx service
+- Obtain SSL certificates from Let's Encrypt
+
+## Benefits
+
+### Cost Optimization
+
+Suthep helps optimize infrastructure costs by:
+
+- **Multi-Service Management** - Run multiple services on a single server efficiently
+- **Automated Configuration** - Eliminates manual Nginx and SSL setup, saving time and reducing errors
+- **Zero-Downtime Deployments** - Rolling deployment strategy ensures continuous service availability
+- **Health Monitoring** - Built-in health checks help maintain service reliability and catch issues early
 
-## Cost Optimization
+### Developer Experience
 
-This tool helps save costs on VMs by:
-- Efficiently managing multiple services on a single server
-- Automatic reverse proxy setup reduces manual configuration
-- Zero-downtime deployments reduce service interruptions
-- Health checks ensure service reliability
+- **Simple Configuration** - YAML-based configuration is easy to understand and maintain
+- **One Command Deployment** - Deploy entire infrastructure with a single command
+- **Automatic SSL** - HTTPS certificates are obtained and renewed automatically
+- **Docker Integration** - Seamless support for containerized applications
 
 ## License
 

package/dist/commands/deploy.js

@@ -1,11 +1,10 @@
 import chalk from "chalk";
 import fs from "fs-extra";
-import path from "path";
-import { requestCertificate } from "../utils/certbot.js";
+import { certificateExists, requestCertificate } from "../utils/certbot.js";
 import { loadConfig } from "../utils/config-loader.js";
 import { deployService, performHealthCheck } from "../utils/deployment.js";
-import { startDockerContainer } from "../utils/docker.js";
-import { generateNginxConfig, enableSite, reloadNginx } from "../utils/nginx.js";
+import { startDockerContainerZeroDowntime, startDockerContainer, swapContainersForZeroDowntime, cleanupTempContainer } from "../utils/docker.js";
+import { generateNginxConfig, generateMultiServiceNginxConfig, writeNginxConfig, enableSite, reloadNginx } from "../utils/nginx.js";
 async function deployCommand(options) {
   console.log(chalk.blue.bold("\n🚀 Deploying Services\n"));
   try {
@@ -17,51 +16,48 @@ async function deployCommand(options) {
     console.log(chalk.green(`✅ Configuration loaded for project: ${config.project.name}`));
     console.log(chalk.dim(`   Services: ${config.services.map((s) => s.name).join(", ")}
 `));
+    const domainToServices = /* @__PURE__ */ new Map();
+    const allDomains = /* @__PURE__ */ new Set();
+    for (const service of config.services) {
+      for (const domain of service.domains) {
+        allDomains.add(domain);
+        if (!domainToServices.has(domain)) {
+          domainToServices.set(domain, []);
+        }
+        domainToServices.get(domain).push(service);
+      }
+    }
+    const serviceTempInfo = /* @__PURE__ */ new Map();
     for (const service of config.services) {
       console.log(chalk.cyan(`
 📦 Deploying service: ${service.name}`));
       try {
         if (service.docker) {
           console.log(chalk.dim("  🐳 Managing Docker container..."));
-          await startDockerContainer(service);
-        }
-        await deployService(service, config.deployment);
-        if (options.nginx) {
-          console.log(chalk.dim("  ⚙️  Configuring Nginx reverse proxy..."));
-          const nginxConfigContent = generateNginxConfig(service, false);
-          const nginxConfigPath = path.join(config.nginx.configPath, `${service.name}.conf`);
-          await fs.writeFile(nginxConfigPath, nginxConfigContent);
-          await enableSite(service.name, config.nginx.configPath);
-          console.log(chalk.green(`  ✅ Nginx configured for ${service.domains.join(", ")}`));
-        }
-        if (options.https && service.domains.length > 0) {
-          console.log(chalk.dim("  🔐 Setting up HTTPS certificates..."));
-          for (const domain of service.domains) {
-            try {
-              await requestCertificate(domain, config.certbot.email, config.certbot.staging);
-              console.log(chalk.green(`  ✅ SSL certificate obtained for ${domain}`));
-            } catch (error) {
+          if (config.deployment.strategy === "blue-green" || config.deployment.strategy === "rolling") {
+            const tempInfo2 = await startDockerContainerZeroDowntime(service);
+            serviceTempInfo.set(service.name, tempInfo2);
+            if (tempInfo2 && tempInfo2.oldContainerExists) {
               console.log(
-                chalk.yellow(
-                  `  ⚠️  Failed to obtain SSL for ${domain}: ${error instanceof Error ? error.message : error}`
+                chalk.cyan(
+                  `  🔄 Zero-downtime deployment: new container on port ${tempInfo2.tempPort}`
                 )
               );
             }
+          } else {
+            await startDockerContainer(service);
+            serviceTempInfo.set(service.name, null);
           }
-          if (options.nginx) {
-            const nginxConfigContent = generateNginxConfig(service, true);
-            const nginxConfigPath = path.join(config.nginx.configPath, `${service.name}.conf`);
-            await fs.writeFile(nginxConfigPath, nginxConfigContent);
-          }
-        }
-        if (options.nginx) {
-          console.log(chalk.dim("  🔄 Reloading Nginx..."));
-          await reloadNginx(config.nginx.reloadCommand);
+        } else {
+          serviceTempInfo.set(service.name, null);
         }
+        const tempInfo = serviceTempInfo.get(service.name) || null;
+        await deployService(service, config.deployment, tempInfo);
         if (service.healthCheck) {
           console.log(chalk.dim(`  🏥 Performing health check...`));
+          const checkPort = tempInfo && tempInfo.oldContainerExists ? tempInfo.tempPort : service.port;
           const isHealthy = await performHealthCheck(
-            `http://localhost:${service.port}${service.healthCheck.path}`,
+            `http://localhost:${checkPort}${service.healthCheck.path}`,
             config.deployment.healthCheckTimeout
           );
           if (isHealthy) {
@@ -70,8 +66,7 @@ async function deployCommand(options) {
             throw new Error(`Health check failed for service ${service.name}`);
           }
         }
-        console.log(chalk.green.bold(`
-✨ Service ${service.name} deployed successfully!`));
+        console.log(chalk.green.bold(`✨ Service ${service.name} deployed successfully!`));
       } catch (error) {
         console.error(
           chalk.red(`
@@ -81,12 +76,231 @@ async function deployCommand(options) {
         throw error;
       }
     }
+    const generateNginxConfigsForDomain = (domain, withHttps, portOverrides) => {
+      const servicesForDomain = domainToServices.get(domain);
+      if (servicesForDomain.length === 1) {
+        const service = servicesForDomain[0];
+        const portOverride = portOverrides?.get(service.name);
+        return generateNginxConfig(service, withHttps, portOverride);
+      } else {
+        return generateMultiServiceNginxConfig(servicesForDomain, domain, withHttps, portOverrides);
+      }
+    };
+    const needsZeroDowntimeNginx = Array.from(serviceTempInfo.values()).some(
+      (info) => info !== null && info.oldContainerExists
+    );
+    if (options.nginx) {
+      if (needsZeroDowntimeNginx) {
+        console.log(chalk.cyan(`
+⚙️  Updating Nginx for zero-downtime deployment...`));
+        const tempPortOverrides = /* @__PURE__ */ new Map();
+        for (const service of config.services) {
+          const tempInfo = serviceTempInfo.get(service.name);
+          if (tempInfo && tempInfo.oldContainerExists) {
+            tempPortOverrides.set(service.name, tempInfo.tempPort);
+          }
+        }
+        for (const domain of allDomains) {
+          const configName = domain.replace(/\./g, "_");
+          try {
+            const nginxConfigContent = generateNginxConfigsForDomain(
+              domain,
+              false,
+              tempPortOverrides
+            );
+            await writeNginxConfig(configName, config.nginx.configPath, nginxConfigContent);
+            await enableSite(configName, config.nginx.configPath);
+            console.log(chalk.green(`  ✅ Nginx updated for ${domain} (temporary ports)`));
+          } catch (error) {
+            console.error(
+              chalk.red(`  ❌ Failed to update Nginx for ${domain}:`),
+              error instanceof Error ? error.message : error
+            );
+            throw error;
+          }
+        }
+        console.log(chalk.cyan(`
+🔄 Reloading Nginx to switch to new containers...`));
+        await reloadNginx(config.nginx.reloadCommand);
+        console.log(chalk.green(`  ✅ Nginx reloaded, traffic now routed to new containers`));
+        console.log(chalk.cyan(`
+🔄 Swapping containers for zero-downtime...`));
+        for (const service of config.services) {
+          const tempInfo = serviceTempInfo.get(service.name);
+          if (tempInfo && tempInfo.oldContainerExists && service.docker) {
+            try {
+              await swapContainersForZeroDowntime(service, tempInfo);
+              console.log(chalk.green(`  ✅ Container swapped for ${service.name}`));
+            } catch (error) {
+              console.error(
+                chalk.red(`  ❌ Failed to swap container for ${service.name}:`),
+                error instanceof Error ? error.message : error
+              );
+              throw error;
+            }
+          }
+        }
+        console.log(chalk.cyan(`
+⚙️  Updating Nginx back to production ports...`));
+        for (const domain of allDomains) {
+          const configName = domain.replace(/\./g, "_");
+          try {
+            const nginxConfigContent = generateNginxConfigsForDomain(domain, false);
+            await writeNginxConfig(configName, config.nginx.configPath, nginxConfigContent);
+            await enableSite(configName, config.nginx.configPath);
+            console.log(chalk.green(`  ✅ Nginx updated for ${domain} (production ports)`));
+          } catch (error) {
+            console.error(
+              chalk.red(`  ❌ Failed to update Nginx for ${domain}:`),
+              error instanceof Error ? error.message : error
+            );
+            throw error;
+          }
+        }
+        console.log(chalk.cyan(`
+🔄 Reloading Nginx to switch to production ports...`));
+        await reloadNginx(config.nginx.reloadCommand);
+        console.log(chalk.green(`  ✅ Nginx reloaded, traffic now routed to production containers`));
+        console.log(chalk.cyan(`
+🧹 Cleaning up temporary containers...`));
+        for (const service of config.services) {
+          const tempInfo = serviceTempInfo.get(service.name);
+          if (tempInfo && tempInfo.oldContainerExists) {
+            await cleanupTempContainer(tempInfo.tempContainerName);
+          }
+        }
+      } else {
+        console.log(chalk.cyan(`
+⚙️  Configuring Nginx reverse proxy...`));
+        for (const domain of allDomains) {
+          const servicesForDomain = domainToServices.get(domain);
+          const configName = domain.replace(/\./g, "_");
+          try {
+            if (servicesForDomain.length > 1) {
+              console.log(
+                chalk.cyan(
+                  `  📋 Configuring ${domain} with ${servicesForDomain.length} services: ${servicesForDomain.map((s) => s.name).join(", ")}`
+                )
+              );
+              console.log(
+                chalk.dim(
+                  `     All services will share the same nginx config file: ${configName}.conf`
+                )
+              );
+            }
+            const nginxConfigContent = generateNginxConfigsForDomain(domain, false);
+            const wasOverridden = await writeNginxConfig(
+              configName,
+              config.nginx.configPath,
+              nginxConfigContent
+            );
+            if (wasOverridden) {
+              console.log(
+                chalk.yellow(
+                  `  🔄 Nginx config "${configName}.conf" already exists, deleting and recreating with new configuration...`
+                )
+              );
+            }
+            await enableSite(configName, config.nginx.configPath);
+            console.log(chalk.green(`  ✅ Nginx configured for ${domain}`));
+          } catch (error) {
+            console.error(
+              chalk.red(`  ❌ Failed to configure Nginx for ${domain}:`),
+              error instanceof Error ? error.message : error
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (options.https && allDomains.size > 0) {
+      console.log(chalk.cyan(`
+🔐 Setting up HTTPS certificates...`));
+      for (const domain of allDomains) {
+        try {
+          const exists = await certificateExists(domain);
+          if (exists) {
+            console.log(
+              chalk.green(
+                `  ✅ SSL certificate already exists for ${domain}, skipping certificate creation`
+              )
+            );
+            console.log(
+              chalk.dim(`     Using existing certificate from /etc/letsencrypt/live/${domain}/`)
+            );
+          } else {
+            console.log(chalk.cyan(`  📜 Requesting SSL certificate for ${domain}...`));
+            try {
+              await requestCertificate(domain, config.certbot.email, config.certbot.staging);
+              console.log(chalk.green(`  ✅ SSL certificate obtained for ${domain}`));
+            } catch (error) {
+              const errorMessage = error?.message || String(error) || "";
+              if (errorMessage.includes("already exists") || errorMessage.includes("Skipping certificate creation")) {
+                console.log(
+                  chalk.green(
+                    `  ✅ SSL certificate already exists for ${domain} (detected during request), skipping...`
+                  )
+                );
+              } else {
+                throw error;
+              }
+            }
+          }
+        } catch (error) {
+          console.log(
+            chalk.yellow(
+              `  ⚠️  Failed to obtain SSL for ${domain}: ${error instanceof Error ? error.message : error}`
+            )
+          );
+        }
+      }
+      if (options.nginx) {
+        console.log(chalk.cyan(`
+🔄 Updating Nginx configs with HTTPS...`));
+        for (const domain of allDomains) {
+          const configName = domain.replace(/\./g, "_");
+          try {
+            const nginxConfigContent = generateNginxConfigsForDomain(domain, true);
+            const wasOverridden = await writeNginxConfig(
+              configName,
+              config.nginx.configPath,
+              nginxConfigContent
+            );
+            if (wasOverridden) {
+              console.log(
+                chalk.yellow(
+                  `  🔄 Nginx config "${configName}.conf" already exists, deleting and recreating with new HTTPS configuration...`
+                )
+              );
+            }
+            console.log(chalk.green(`  ✅ HTTPS config updated for ${domain}`));
+          } catch (error) {
+            console.error(
+              chalk.red(`  ❌ Failed to update HTTPS config for ${domain}:`),
+              error instanceof Error ? error.message : error
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (options.nginx && !needsZeroDowntimeNginx) {
+      console.log(chalk.cyan(`
+🔄 Reloading Nginx...`));
+      await reloadNginx(config.nginx.reloadCommand);
+    } else if (options.nginx && needsZeroDowntimeNginx) {
+      console.log(chalk.cyan(`
+🔄 Final Nginx reload with HTTPS...`));
+      await reloadNginx(config.nginx.reloadCommand);
+    }
     console.log(chalk.green.bold("\n🎉 All services deployed successfully!\n"));
     console.log(chalk.cyan("📋 Service URLs:"));
     for (const service of config.services) {
       for (const domain of service.domains) {
         const protocol = options.https ? "https" : "http";
-        console.log(chalk.dim(`   ${service.name}: ${protocol}://${domain}`));
+        const servicePath = service.path || "/";
+        const fullPath = servicePath === "/" ? "" : servicePath;
+        console.log(chalk.dim(`   ${service.name}: ${protocol}://${domain}${fullPath}`));
       }
     }
     console.log();