suthep 0.1.0-beta.1

package/src/commands/deploy.ts

@@ -0,0 +1,405 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import type { ServiceConfig } from '../types/config'
+import { certificateExists, requestCertificate } from '../utils/certbot'
+import { loadConfig } from '../utils/config-loader'
+import { deployService, performHealthCheck } from '../utils/deployment'
+import {
+  cleanupTempContainer,
+  startDockerContainer,
+  startDockerContainerZeroDowntime,
+  swapContainersForZeroDowntime,
+  type ZeroDowntimeContainerInfo,
+} from '../utils/docker'
+import {
+  enableSite,
+  generateMultiServiceNginxConfig,
+  generateNginxConfig,
+  reloadNginx,
+  writeNginxConfig,
+} from '../utils/nginx'
+
+interface DeployOptions {
+  file: string
+  https: boolean
+  nginx: boolean
+}
+
+export async function deployCommand(options: DeployOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🚀 Deploying Services\n'))
+
+  try {
+    // Load configuration
+    if (!(await fs.pathExists(options.file))) {
+      throw new Error(`Configuration file not found: ${options.file}`)
+    }
+
+    console.log(chalk.cyan(`📄 Loading configuration from ${options.file}...`))
+    const config = await loadConfig(options.file)
+
+    console.log(chalk.green(`✅ Configuration loaded for project: ${config.project.name}`))
+    console.log(chalk.dim(`   Services: ${config.services.map((s) => s.name).join(', ')}\n`))
+
+    // Group services by domain
+    const domainToServices = new Map<string, ServiceConfig[]>()
+    const allDomains = new Set<string>()
+
+    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)
+      }
+    }
+
+    // Deploy each service (Docker, health checks, etc.)
+    // Track zero-downtime info for services that need it
+    const serviceTempInfo = new Map<string, ZeroDowntimeContainerInfo | null>()
+
+    for (const service of config.services) {
+      console.log(chalk.cyan(`\n📦 Deploying service: ${service.name}`))
+
+      try {
+        // Start Docker container if configured
+        if (service.docker) {
+          console.log(chalk.dim('  🐳 Managing Docker container...'))
+
+          // Use zero-downtime deployment if strategy is blue-green or rolling
+          if (
+            config.deployment.strategy === 'blue-green' ||
+            config.deployment.strategy === 'rolling'
+          ) {
+            const tempInfo = await startDockerContainerZeroDowntime(service)
+            serviceTempInfo.set(service.name, tempInfo)
+
+            if (tempInfo && tempInfo.oldContainerExists) {
+              console.log(
+                chalk.cyan(
+                  `  🔄 Zero-downtime deployment: new container on port ${tempInfo.tempPort}`
+                )
+              )
+            }
+          } else {
+            // Fallback to regular deployment
+            await startDockerContainer(service)
+            serviceTempInfo.set(service.name, null)
+          }
+        } else {
+          serviceTempInfo.set(service.name, null)
+        }
+
+        // Deploy the service (with temp info for zero-downtime)
+        const tempInfo = serviceTempInfo.get(service.name) || null
+        await deployService(service, config.deployment, tempInfo)
+
+        // Perform health check on appropriate port
+        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:${checkPort}${service.healthCheck.path}`,
+            config.deployment.healthCheckTimeout
+          )
+
+          if (isHealthy) {
+            console.log(chalk.green(`  ✅ Service ${service.name} is healthy`))
+          } else {
+            throw new Error(`Health check failed for service ${service.name}`)
+          }
+        }
+
+        console.log(chalk.green.bold(`✨ Service ${service.name} deployed successfully!`))
+      } catch (error) {
+        console.error(
+          chalk.red(`\n❌ Failed to deploy service ${service.name}:`),
+          error instanceof Error ? error.message : error
+        )
+        throw error
+      }
+    }
+
+    // Helper function to generate nginx configs with optional port overrides
+    const generateNginxConfigsForDomain = (
+      domain: string,
+      withHttps: boolean,
+      portOverrides?: Map<string, number>
+    ): string => {
+      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)
+      }
+    }
+
+    // Check if we need zero-downtime nginx updates (any service has temp container)
+    const needsZeroDowntimeNginx = Array.from(serviceTempInfo.values()).some(
+      (info) => info !== null && info.oldContainerExists
+    )
+
+    // Configure Nginx per domain
+    if (options.nginx) {
+      // If zero-downtime, first update nginx to point to temp ports
+      if (needsZeroDowntimeNginx) {
+        console.log(chalk.cyan(`\n⚙️  Updating Nginx for zero-downtime deployment...`))
+
+        // Build port override map for temp ports
+        const tempPortOverrides = new Map<string, number>()
+        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
+          }
+        }
+
+        // Reload nginx to switch to temp ports (graceful reload, no connection drops)
+        console.log(chalk.cyan(`\n🔄 Reloading Nginx to switch to new containers...`))
+        await reloadNginx(config.nginx.reloadCommand)
+        console.log(chalk.green(`  ✅ Nginx reloaded, traffic now routed to new containers`))
+
+        // Now swap containers (stop old, promote new)
+        console.log(chalk.cyan(`\n🔄 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
+            }
+          }
+        }
+
+        // Update nginx back to original ports (before stopping temp containers)
+        console.log(chalk.cyan(`\n⚙️  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
+          }
+        }
+
+        // Reload nginx to switch to production ports (graceful reload)
+        console.log(chalk.cyan(`\n🔄 Reloading Nginx to switch to production ports...`))
+        await reloadNginx(config.nginx.reloadCommand)
+        console.log(chalk.green(`  ✅ Nginx reloaded, traffic now routed to production containers`))
+
+        // Clean up temp containers (nginx already pointing to production, so safe to remove)
+        console.log(chalk.cyan(`\n🧹 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 {
+        // Regular nginx configuration (no zero-downtime needed)
+        console.log(chalk.cyan(`\n⚙️  Configuring Nginx reverse proxy...`))
+
+        for (const domain of allDomains) {
+          const servicesForDomain = domainToServices.get(domain)!
+          const configName = domain.replace(/\./g, '_')
+
+          try {
+            // Log domain and services configuration
+            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`
+                )
+              )
+            }
+
+            // Generate Nginx config
+            const nginxConfigContent = generateNginxConfigsForDomain(domain, false)
+
+            // Check if config file already exists and write/override it
+            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
+          }
+        }
+      }
+    }
+
+    // Setup HTTPS with Certbot (per domain, not per service)
+    if (options.https && allDomains.size > 0) {
+      console.log(chalk.cyan(`\n🔐 Setting up HTTPS certificates...`))
+
+      for (const domain of allDomains) {
+        try {
+          // Check if certificate already exists
+          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 {
+            // Request new certificate
+            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: any) {
+              // Check if error is because certificate already exists (race condition or check missed it)
+              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 // Re-throw if it's a different error
+              }
+            }
+          }
+        } catch (error) {
+          console.log(
+            chalk.yellow(
+              `  ⚠️  Failed to obtain SSL for ${domain}: ${
+                error instanceof Error ? error.message : error
+              }`
+            )
+          )
+        }
+      }
+
+      // Update Nginx configs with HTTPS
+      if (options.nginx) {
+        console.log(chalk.cyan(`\n🔄 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
+          }
+        }
+      }
+    }
+
+    // Final reload Nginx after all configurations (only if we didn't already reload for zero-downtime)
+    if (options.nginx && !needsZeroDowntimeNginx) {
+      console.log(chalk.cyan(`\n🔄 Reloading Nginx...`))
+      await reloadNginx(config.nginx.reloadCommand)
+    } else if (options.nginx && needsZeroDowntimeNginx) {
+      // Final reload after HTTPS update
+      console.log(chalk.cyan(`\n🔄 Final Nginx reload with HTTPS...`))
+      await reloadNginx(config.nginx.reloadCommand)
+    }
+
+    console.log(chalk.green.bold('\n🎉 All services deployed successfully!\n'))
+
+    // Print service URLs
+    console.log(chalk.cyan('📋 Service URLs:'))
+    for (const service of config.services) {
+      for (const domain of service.domains) {
+        const protocol = options.https ? 'https' : 'http'
+        const servicePath = service.path || '/'
+        const fullPath = servicePath === '/' ? '' : servicePath
+        console.log(chalk.dim(`   ${service.name}: ${protocol}://${domain}${fullPath}`))
+      }
+    }
+    console.log()
+  } catch (error) {
+    console.error(
+      chalk.red('\n❌ Deployment failed:'),
+      error instanceof Error ? error.message : error
+    )
+    process.exit(1)
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,214 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import inquirer from 'inquirer'
+import type { DeployConfig } from '../types/config'
+import { saveConfig } from '../utils/config-loader'
+
+interface InitOptions {
+  file: string
+}
+
+export async function initCommand(options: InitOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🚀 Suthep Deployment Configuration\n'))
+
+  // Check if file already exists
+  if (await fs.pathExists(options.file)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `File ${options.file} already exists. Overwrite?`,
+        default: false,
+      },
+    ])
+
+    if (!overwrite) {
+      console.log(chalk.yellow('Aborted.'))
+      return
+    }
+  }
+
+  // Gather project information
+  const projectAnswers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: 'my-app',
+    },
+    {
+      type: 'input',
+      name: 'projectVersion',
+      message: 'Project version:',
+      default: '1.0.0',
+    },
+  ])
+
+  // Gather service information
+  const services = []
+  let addMoreServices = true
+
+  while (addMoreServices) {
+    console.log(chalk.cyan(`\n📦 Service ${services.length + 1} Configuration`))
+
+    const serviceAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Service name:',
+        validate: (input) => input.trim() !== '' || 'Service name is required',
+      },
+      {
+        type: 'number',
+        name: 'port',
+        message: 'Service port:',
+        default: 3000,
+        validate: (input: number | undefined) => {
+          if (input === undefined) return 'Port is required'
+          return (input > 0 && input < 65536) || 'Port must be between 1 and 65535'
+        },
+      },
+      {
+        type: 'input',
+        name: 'domains',
+        message: 'Domain names (comma-separated):',
+        validate: (input) => input.trim() !== '' || 'At least one domain is required',
+        filter: (input: string) => input.split(',').map((d: string) => d.trim()),
+      },
+      {
+        type: 'confirm',
+        name: 'useDocker',
+        message: 'Use Docker?',
+        default: false,
+      },
+    ])
+
+    // Docker configuration
+    let dockerConfig = undefined
+    if (serviceAnswers.useDocker) {
+      const dockerAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'image',
+          message: 'Docker image (leave empty to connect to existing container):',
+        },
+        {
+          type: 'input',
+          name: 'container',
+          message: 'Container name:',
+          validate: (input) => input.trim() !== '' || 'Container name is required',
+        },
+        {
+          type: 'number',
+          name: 'port',
+          message: 'Container port:',
+          default: serviceAnswers.port,
+        },
+      ])
+
+      dockerConfig = {
+        image: dockerAnswers.image || undefined,
+        container: dockerAnswers.container,
+        port: dockerAnswers.port,
+      }
+    }
+
+    // Health check configuration
+    const { addHealthCheck } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'addHealthCheck',
+        message: 'Add health check?',
+        default: true,
+      },
+    ])
+
+    let healthCheck = undefined
+    if (addHealthCheck) {
+      const healthCheckAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'path',
+          message: 'Health check path:',
+          default: '/health',
+        },
+        {
+          type: 'number',
+          name: 'interval',
+          message: 'Health check interval (seconds):',
+          default: 30,
+        },
+      ])
+
+      healthCheck = healthCheckAnswers
+    }
+
+    services.push({
+      name: serviceAnswers.name,
+      port: serviceAnswers.port,
+      domains: serviceAnswers.domains,
+      docker: dockerConfig,
+      healthCheck,
+    })
+
+    const { addMore } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'addMore',
+        message: 'Add another service?',
+        default: false,
+      },
+    ])
+
+    addMoreServices = addMore
+  }
+
+  // Certbot configuration
+  const certbotAnswers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'email',
+      message: 'Email for SSL certificates:',
+      validate: (input) => {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+        return emailRegex.test(input) || 'Please enter a valid email address'
+      },
+    },
+    {
+      type: 'confirm',
+      name: 'staging',
+      message: 'Use Certbot staging environment? (for testing)',
+      default: false,
+    },
+  ])
+
+  // Build configuration object
+  const config: DeployConfig = {
+    project: {
+      name: projectAnswers.projectName,
+      version: projectAnswers.projectVersion,
+    },
+    services,
+    nginx: {
+      configPath: '/etc/nginx/sites-available',
+      reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+    },
+    certbot: {
+      email: certbotAnswers.email,
+      staging: certbotAnswers.staging,
+    },
+    deployment: {
+      strategy: 'rolling',
+      healthCheckTimeout: 30000,
+    },
+  }
+
+  // Save configuration
+  await saveConfig(options.file, config)
+
+  console.log(chalk.green(`\n✅ Configuration saved to ${options.file}`))
+  console.log(chalk.dim('\nNext steps:'))
+  console.log(chalk.dim(`  1. Review and edit ${options.file} if needed`))
+  console.log(chalk.dim('  2. Run: suthep setup'))
+  console.log(chalk.dim('  3. Run: suthep deploy\n'))
+}