suthep 0.1.0 → 0.2.0-beta.1

package/src/commands/down.ts

@@ -0,0 +1,240 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import type { ServiceConfig } from '../types/config'
+import { loadConfig } from '../utils/config-loader'
+import { isContainerRunning, removeDockerContainer, stopDockerContainer } from '../utils/docker'
+import {
+  disableSite,
+  enableSite,
+  generateMultiServiceNginxConfig,
+  generateNginxConfig,
+  reloadNginx,
+  writeNginxConfig,
+} from '../utils/nginx'
+
+interface DownOptions {
+  file: string
+  all: boolean
+  serviceName?: string
+}
+
+export async function downCommand(options: DownOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🛑 Bringing Down 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}`))
+
+    // Determine which services to bring down
+    let servicesToDown: ServiceConfig[] = []
+
+    if (options.all) {
+      servicesToDown = config.services
+      console.log(
+        chalk.cyan(
+          `📋 Bringing down all services: ${servicesToDown.map((s) => s.name).join(', ')}\n`
+        )
+      )
+    } else if (options.serviceName) {
+      const service = config.services.find((s) => s.name === options.serviceName)
+      if (!service) {
+        throw new Error(
+          `Service "${
+            options.serviceName
+          }" not found in configuration. Available services: ${config.services
+            .map((s) => s.name)
+            .join(', ')}`
+        )
+      }
+      servicesToDown = [service]
+      console.log(chalk.cyan(`📋 Bringing down service: ${options.serviceName}\n`))
+    } else {
+      throw new Error('Either specify a service name or use --all flag')
+    }
+
+    // Group services by domain for nginx config management
+    const domainToServices = new Map<string, ServiceConfig[]>()
+    const allDomains = new Set<string>()
+
+    for (const service of servicesToDown) {
+      for (const domain of service.domains) {
+        allDomains.add(domain)
+        if (!domainToServices.has(domain)) {
+          domainToServices.set(domain, [])
+        }
+        domainToServices.get(domain)!.push(service)
+      }
+    }
+
+    // Stop and remove Docker containers
+    for (const service of servicesToDown) {
+      if (service.docker) {
+        console.log(chalk.cyan(`\n🐳 Stopping Docker container for service: ${service.name}`))
+        try {
+          const containerName = service.docker.container
+
+          // Stop container
+          try {
+            await stopDockerContainer(containerName)
+            console.log(chalk.green(`  ✅ Stopped container: ${containerName}`))
+          } catch (error: any) {
+            const errorMessage = error?.message || String(error) || 'Unknown error'
+            if (
+              errorMessage.toLowerCase().includes('no such container') ||
+              errorMessage.toLowerCase().includes('container not found')
+            ) {
+              console.log(
+                chalk.yellow(`  ⚠️  Container ${containerName} not found (already stopped)`)
+              )
+            } else {
+              throw error
+            }
+          }
+
+          // Remove container
+          try {
+            await removeDockerContainer(containerName)
+            console.log(chalk.green(`  ✅ Removed container: ${containerName}`))
+          } catch (error: any) {
+            const errorMessage = error?.message || String(error) || 'Unknown error'
+            if (
+              errorMessage.toLowerCase().includes('no such container') ||
+              errorMessage.toLowerCase().includes('container not found')
+            ) {
+              console.log(
+                chalk.yellow(`  ⚠️  Container ${containerName} not found (already removed)`)
+              )
+            } else {
+              throw error
+            }
+          }
+        } catch (error) {
+          console.error(
+            chalk.red(`  ❌ Failed to stop/remove container for service ${service.name}:`),
+            error instanceof Error ? error.message : error
+          )
+          throw error
+        }
+      }
+    }
+
+    // Handle Nginx configs by domain
+    // Check which services remain active for each domain
+    if (allDomains.size > 0) {
+      console.log(chalk.cyan(`\n⚙️  Updating Nginx configurations...`))
+
+      // Create a set of service names being brought down for quick lookup
+      const servicesBeingDowned = new Set(servicesToDown.map((s) => s.name))
+
+      // For each domain, find all services that use it (from all config services)
+      // and determine which ones remain active
+      for (const domain of allDomains) {
+        const configName = domain.replace(/\./g, '_')
+
+        // Find all services that use this domain (from entire config)
+        const allServicesForDomain = config.services.filter((s) => s.domains.includes(domain))
+
+        // Filter out services being brought down
+        const remainingServices = allServicesForDomain.filter(
+          (s) => !servicesBeingDowned.has(s.name)
+        )
+
+        // Check if remaining services are actually running (have active containers)
+        const activeServices: ServiceConfig[] = []
+        for (const service of remainingServices) {
+          if (service.docker) {
+            const isRunning = await isContainerRunning(service.docker.container)
+            if (isRunning) {
+              activeServices.push(service)
+            }
+          } else {
+            // Service without docker - assume it's running if not being brought down
+            activeServices.push(service)
+          }
+        }
+
+        try {
+          if (activeServices.length === 0) {
+            // No active services on this domain, disable the config
+            console.log(
+              chalk.cyan(`  📋 No active services on ${domain}, disabling Nginx config...`)
+            )
+            await disableSite(configName, config.nginx.configPath)
+            console.log(chalk.green(`  ✅ Disabled Nginx config for ${domain}`))
+          } else {
+            // Regenerate config with remaining active services
+            console.log(
+              chalk.cyan(
+                `  📋 Regenerating Nginx config for ${domain} with ${
+                  activeServices.length
+                } active service(s): ${activeServices.map((s) => s.name).join(', ')}`
+              )
+            )
+
+            // Generate config for remaining services
+            let nginxConfigContent: string
+            if (activeServices.length === 1) {
+              nginxConfigContent = generateNginxConfig(activeServices[0], false)
+            } else {
+              nginxConfigContent = generateMultiServiceNginxConfig(activeServices, domain, false)
+            }
+
+            // Check if HTTPS is enabled (check if certificate exists)
+            const { certificateExists } = await import('../utils/certbot')
+            const hasHttps = await certificateExists(domain)
+            if (hasHttps) {
+              // Regenerate with HTTPS
+              if (activeServices.length === 1) {
+                nginxConfigContent = generateNginxConfig(activeServices[0], true)
+              } else {
+                nginxConfigContent = generateMultiServiceNginxConfig(activeServices, domain, true)
+              }
+            }
+
+            await writeNginxConfig(configName, config.nginx.configPath, nginxConfigContent)
+            await enableSite(configName, config.nginx.configPath)
+            console.log(
+              chalk.green(
+                `  ✅ Updated Nginx config for ${domain} (${activeServices.length} service(s) active)`
+              )
+            )
+          }
+        } catch (error) {
+          console.error(
+            chalk.red(`  ❌ Failed to update Nginx config for ${domain}:`),
+            error instanceof Error ? error.message : error
+          )
+          throw error
+        }
+      }
+
+      // Reload Nginx to apply changes
+      console.log(chalk.cyan(`\n🔄 Reloading Nginx...`))
+      try {
+        await reloadNginx(config.nginx.reloadCommand)
+        console.log(chalk.green(`  ✅ Nginx reloaded`))
+      } catch (error) {
+        console.error(
+          chalk.red(`  ❌ Failed to reload Nginx:`),
+          error instanceof Error ? error.message : error
+        )
+        throw error
+      }
+    }
+
+    console.log(chalk.green.bold('\n✅ Services brought down successfully!\n'))
+  } catch (error) {
+    console.error(
+      chalk.red('\n❌ Failed to bring down services:'),
+      error instanceof Error ? error.message : error
+    )
+    process.exit(1)
+  }
+}

package/src/commands/redeploy.ts

@@ -0,0 +1,78 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import type { ServiceConfig } from '../types/config'
+import { loadConfig } from '../utils/config-loader'
+import { deployCommand } from './deploy'
+import { downCommand } from './down'
+
+interface RedeployOptions {
+  file: string
+  all: boolean
+  serviceName?: string
+  https: boolean
+  nginx: boolean
+}
+
+export async function redeployCommand(options: RedeployOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🔄 Redeploying Services\n'))
+
+  try {
+    // Load configuration to validate service names
+    if (!(await fs.pathExists(options.file))) {
+      throw new Error(`Configuration file not found: ${options.file}`)
+    }
+
+    const config = await loadConfig(options.file)
+
+    // Determine which services to redeploy
+    let servicesToRedeploy: ServiceConfig[] = []
+
+    if (options.all) {
+      servicesToRedeploy = config.services
+      console.log(
+        chalk.cyan(
+          `📋 Redeploying all services: ${servicesToRedeploy.map((s) => s.name).join(', ')}\n`
+        )
+      )
+    } else if (options.serviceName) {
+      const service = config.services.find((s) => s.name === options.serviceName)
+      if (!service) {
+        throw new Error(
+          `Service "${
+            options.serviceName
+          }" not found in configuration. Available services: ${config.services
+            .map((s) => s.name)
+            .join(', ')}`
+        )
+      }
+      servicesToRedeploy = [service]
+      console.log(chalk.cyan(`📋 Redeploying service: ${options.serviceName}\n`))
+    } else {
+      throw new Error('Either specify a service name or use --all flag')
+    }
+
+    // Step 1: Bring down the services
+    console.log(chalk.yellow('Step 1: Bringing down services...\n'))
+    await downCommand({
+      file: options.file,
+      all: options.all,
+      serviceName: options.serviceName,
+    })
+
+    // Step 2: Deploy the services (which will bring them back up)
+    console.log(chalk.yellow('\nStep 2: Deploying services...\n'))
+    await deployCommand({
+      file: options.file,
+      https: options.https,
+      nginx: options.nginx,
+    })
+
+    console.log(chalk.green.bold('\n✅ Services redeployed successfully!\n'))
+  } catch (error) {
+    console.error(
+      chalk.red('\n❌ Failed to redeploy services:'),
+      error instanceof Error ? error.message : error
+    )
+    process.exit(1)
+  }
+}

package/src/commands/up.ts

@@ -0,0 +1,271 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import type { ServiceConfig } from '../types/config'
+import { loadConfig } from '../utils/config-loader'
+import { waitForService } from '../utils/deployment'
+import { isContainerRunning, startDockerContainer } from '../utils/docker'
+import {
+  enableSite,
+  generateMultiServiceNginxConfig,
+  generateNginxConfig,
+  reloadNginx,
+  writeNginxConfig,
+} from '../utils/nginx'
+
+interface UpOptions {
+  file: string
+  all: boolean
+  serviceName?: string
+  https: boolean
+  nginx: boolean
+}
+
+export async function upCommand(options: UpOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🚀 Bringing Up 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}`))
+
+    // Determine which services to bring up
+    let servicesToUp: ServiceConfig[] = []
+
+    if (options.all) {
+      servicesToUp = config.services
+      console.log(
+        chalk.cyan(`📋 Bringing up all services: ${servicesToUp.map((s) => s.name).join(', ')}\n`)
+      )
+    } else if (options.serviceName) {
+      const service = config.services.find((s) => s.name === options.serviceName)
+      if (!service) {
+        throw new Error(
+          `Service "${
+            options.serviceName
+          }" not found in configuration. Available services: ${config.services
+            .map((s) => s.name)
+            .join(', ')}`
+        )
+      }
+      servicesToUp = [service]
+      console.log(chalk.cyan(`📋 Bringing up service: ${options.serviceName}\n`))
+    } else {
+      throw new Error('Either specify a service name or use --all flag')
+    }
+
+    // Group services by domain for nginx config management
+    const domainToServices = new Map<string, ServiceConfig[]>()
+    const allDomains = new Set<string>()
+
+    for (const service of servicesToUp) {
+      for (const domain of service.domains) {
+        allDomains.add(domain)
+        if (!domainToServices.has(domain)) {
+          domainToServices.set(domain, [])
+        }
+        domainToServices.get(domain)!.push(service)
+      }
+    }
+
+    // Start Docker containers
+    for (const service of servicesToUp) {
+      if (service.docker) {
+        console.log(chalk.cyan(`\n🐳 Starting Docker container for service: ${service.name}`))
+        try {
+          await startDockerContainer(service)
+          console.log(chalk.green(`  ✅ Container started for service: ${service.name}`))
+        } catch (error) {
+          console.error(
+            chalk.red(`  ❌ Failed to start container for service ${service.name}:`),
+            error instanceof Error ? error.message : error
+          )
+          throw error
+        }
+      }
+    }
+
+    // Wait for services to be healthy
+    for (const service of servicesToUp) {
+      if (service.healthCheck) {
+        console.log(chalk.cyan(`\n🏥 Waiting for service ${service.name} to be healthy...`))
+        const isHealthy = await waitForService(service, config.deployment.healthCheckTimeout)
+        if (isHealthy) {
+          console.log(chalk.green(`  ✅ Service ${service.name} is healthy`))
+        } else {
+          console.log(
+            chalk.yellow(`  ⚠️  Service ${service.name} health check timeout, continuing anyway...`)
+          )
+        }
+      }
+    }
+
+    // Configure Nginx
+    if (options.nginx && allDomains.size > 0) {
+      console.log(chalk.cyan(`\n⚙️  Configuring Nginx reverse proxy...`))
+
+      // Create a set of service names being brought up for quick lookup
+      const servicesBeingUpped = new Set(servicesToUp.map((s) => s.name))
+
+      // For each domain, find all services that use it (from all config services)
+      // and include all active services (both newly brought up and already running)
+      for (const domain of allDomains) {
+        const configName = domain.replace(/\./g, '_')
+
+        // Find all services that use this domain (from entire config)
+        const allServicesForDomain = config.services.filter((s) => s.domains.includes(domain))
+
+        // Check which services are actually running (have active containers)
+        const activeServices: ServiceConfig[] = []
+        for (const service of allServicesForDomain) {
+          if (service.docker) {
+            const isRunning = await isContainerRunning(service.docker.container)
+            if (isRunning) {
+              activeServices.push(service)
+            }
+          } else {
+            // Service without docker - include if it's being brought up or assume it's running
+            if (servicesBeingUpped.has(service.name)) {
+              activeServices.push(service)
+            } else {
+              // For non-docker services, assume they're running if not explicitly being brought up
+              // This is a best-effort approach
+              activeServices.push(service)
+            }
+          }
+        }
+
+        if (activeServices.length === 0) {
+          console.log(
+            chalk.yellow(`  ⚠️  No active services found for ${domain}, skipping Nginx config`)
+          )
+          continue
+        }
+
+        try {
+          // Log domain and services configuration
+          if (activeServices.length > 1) {
+            console.log(
+              chalk.cyan(
+                `  📋 Configuring ${domain} with ${
+                  activeServices.length
+                } active service(s): ${activeServices.map((s) => s.name).join(', ')}`
+              )
+            )
+          } else {
+            console.log(
+              chalk.cyan(`  📋 Configuring ${domain} for service: ${activeServices[0].name}`)
+            )
+          }
+
+          // Generate Nginx config for all active services on this domain
+          let nginxConfigContent: string
+          if (activeServices.length === 1) {
+            nginxConfigContent = generateNginxConfig(activeServices[0], false)
+          } else {
+            nginxConfigContent = generateMultiServiceNginxConfig(activeServices, domain, false)
+          }
+
+          // Write config file
+          await writeNginxConfig(configName, config.nginx.configPath, nginxConfigContent)
+          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
+        }
+      }
+
+      // Update with HTTPS if enabled
+      if (options.https) {
+        console.log(chalk.cyan(`\n🔄 Updating Nginx configs with HTTPS...`))
+        for (const domain of allDomains) {
+          const configName = domain.replace(/\./g, '_')
+
+          // Find all active services for this domain again
+          const allServicesForDomain = config.services.filter((s) => s.domains.includes(domain))
+          const activeServices: ServiceConfig[] = []
+          for (const service of allServicesForDomain) {
+            if (service.docker) {
+              const isRunning = await isContainerRunning(service.docker.container)
+              if (isRunning) {
+                activeServices.push(service)
+              }
+            } else {
+              if (servicesBeingUpped.has(service.name)) {
+                activeServices.push(service)
+              } else {
+                activeServices.push(service)
+              }
+            }
+          }
+
+          if (activeServices.length === 0) {
+            continue
+          }
+
+          try {
+            let nginxConfigContent: string
+            if (activeServices.length === 1) {
+              nginxConfigContent = generateNginxConfig(activeServices[0], true)
+            } else {
+              nginxConfigContent = generateMultiServiceNginxConfig(activeServices, domain, true)
+            }
+            await writeNginxConfig(configName, config.nginx.configPath, nginxConfigContent)
+            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
+          }
+        }
+      }
+
+      // Reload Nginx
+      console.log(chalk.cyan(`\n🔄 Reloading Nginx...`))
+      try {
+        await reloadNginx(config.nginx.reloadCommand)
+        console.log(chalk.green(`  ✅ Nginx reloaded`))
+      } catch (error) {
+        console.error(
+          chalk.red(`  ❌ Failed to reload Nginx:`),
+          error instanceof Error ? error.message : error
+        )
+        throw error
+      }
+    }
+
+    console.log(chalk.green.bold('\n✅ Services brought up successfully!\n'))
+
+    // Print service URLs
+    if (allDomains.size > 0) {
+      console.log(chalk.cyan('📋 Service URLs:'))
+      for (const service of servicesToUp) {
+        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❌ Failed to bring up services:'),
+      error instanceof Error ? error.message : error
+    )
+    process.exit(1)
+  }
+}

package/src/index.ts

@@ -1,14 +1,25 @@
 import { Command } from 'commander'
+import { readFileSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
 import { deployCommand } from './commands/deploy'
+import { downCommand } from './commands/down'
 import { initCommand } from './commands/init'
+import { redeployCommand } from './commands/redeploy'
 import { setupCommand } from './commands/setup'
+import { upCommand } from './commands/up'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const packageJsonPath = join(__dirname, '..', 'package.json')
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
 
 const program = new Command()
 
 program
   .name('suthep')
   .description('CLI tool for deploying projects with automatic Nginx reverse proxy and HTTPS setup')
-  .version('0.1.0')
+  .version(packageJson.version)
 
 program
   .command('init')
@@ -31,4 +42,54 @@ program
   .option('--no-nginx', 'Skip Nginx configuration')
   .action(deployCommand)
 
+program
+  .command('down')
+  .description('Bring down services (stop containers and disable Nginx configs)')
+  .option('-f, --file <path>', 'Configuration file path', 'suthep.yml')
+  .option('--all', 'Bring down all services', false)
+  .argument('[service-name]', 'Name of the service to bring down')
+  .action((serviceName, options) => {
+    downCommand({
+      file: options.file || 'suthep.yml',
+      all: options.all || false,
+      serviceName: serviceName,
+    })
+  })
+
+program
+  .command('up')
+  .description('Bring up services (start containers and enable Nginx configs)')
+  .option('-f, --file <path>', 'Configuration file path', 'suthep.yml')
+  .option('--all', 'Bring up all services', false)
+  .option('--no-https', 'Skip HTTPS setup')
+  .option('--no-nginx', 'Skip Nginx configuration')
+  .argument('[service-name]', 'Name of the service to bring up')
+  .action((serviceName, options) => {
+    upCommand({
+      file: options.file || 'suthep.yml',
+      all: options.all || false,
+      serviceName: serviceName,
+      https: options.https !== false,
+      nginx: options.nginx !== false,
+    })
+  })
+
+program
+  .command('redeploy')
+  .description('Redeploy services (bring down and deploy again)')
+  .option('-f, --file <path>', 'Configuration file path', 'suthep.yml')
+  .option('--all', 'Redeploy all services', false)
+  .option('--no-https', 'Skip HTTPS setup')
+  .option('--no-nginx', 'Skip Nginx configuration')
+  .argument('[service-name]', 'Name of the service to redeploy')
+  .action((serviceName, options) => {
+    redeployCommand({
+      file: options.file || 'suthep.yml',
+      all: options.all || false,
+      serviceName: serviceName,
+      https: options.https !== false,
+      nginx: options.nginx !== false,
+    })
+  })
+
 program.parse()