suthep 1.0.0

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/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'))
+}

package/src/commands/setup.ts

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import { execa } from 'execa';
+
+interface SetupOptions {
+  nginxOnly?: boolean;
+  certbotOnly?: boolean;
+}
+
+export async function setupCommand(options: SetupOptions): Promise<void> {
+  console.log(chalk.blue.bold('\n🔧 Setting up prerequisites\n'));
+
+  const setupNginx = !options.certbotOnly;
+  const setupCertbot = !options.nginxOnly;
+
+  try {
+    // Setup Nginx
+    if (setupNginx) {
+      console.log(chalk.cyan('📦 Installing Nginx...'));
+
+      // Check if Nginx is already installed
+      try {
+        await execa('nginx', ['-v']);
+        console.log(chalk.green('✅ Nginx is already installed'));
+      } catch {
+        // Install Nginx based on OS
+        const platform = process.platform;
+
+        if (platform === 'linux') {
+          // Detect Linux distribution
+          try {
+            await execa('apt-get', ['--version']);
+            console.log(chalk.dim('Using apt-get...'));
+            await execa('sudo', ['apt-get', 'update'], { stdio: 'inherit' });
+            await execa('sudo', ['apt-get', 'install', '-y', 'nginx'], { stdio: 'inherit' });
+          } catch {
+            try {
+              await execa('yum', ['--version']);
+              console.log(chalk.dim('Using yum...'));
+              await execa('sudo', ['yum', 'install', '-y', 'nginx'], { stdio: 'inherit' });
+            } catch {
+              throw new Error('Unsupported Linux distribution. Please install Nginx manually.');
+            }
+          }
+        } else if (platform === 'darwin') {
+          console.log(chalk.dim('Using Homebrew...'));
+          await execa('brew', ['install', 'nginx'], { stdio: 'inherit' });
+        } else {
+          throw new Error(`Unsupported platform: ${platform}. Please install Nginx manually.`);
+        }
+
+        console.log(chalk.green('✅ Nginx installed successfully'));
+      }
+
+      // Start Nginx service
+      console.log(chalk.cyan('🚀 Starting Nginx service...'));
+      try {
+        await execa('sudo', ['systemctl', 'start', 'nginx']);
+        await execa('sudo', ['systemctl', 'enable', 'nginx']);
+        console.log(chalk.green('✅ Nginx service started'));
+      } catch (error) {
+        console.log(chalk.yellow('⚠️  Could not start Nginx via systemctl (might not be available)'));
+      }
+    }
+
+    // Setup Certbot
+    if (setupCertbot) {
+      console.log(chalk.cyan('\n🔐 Installing Certbot...'));
+
+      // Check if Certbot is already installed
+      try {
+        await execa('certbot', ['--version']);
+        console.log(chalk.green('✅ Certbot is already installed'));
+      } catch {
+        const platform = process.platform;
+
+        if (platform === 'linux') {
+          // Install Certbot based on package manager
+          try {
+            await execa('apt-get', ['--version']);
+            console.log(chalk.dim('Using apt-get...'));
+            await execa('sudo', ['apt-get', 'update'], { stdio: 'inherit' });
+            await execa('sudo', ['apt-get', 'install', '-y', 'certbot', 'python3-certbot-nginx'], { stdio: 'inherit' });
+          } catch {
+            try {
+              await execa('yum', ['--version']);
+              console.log(chalk.dim('Using yum...'));
+              await execa('sudo', ['yum', 'install', '-y', 'certbot', 'python3-certbot-nginx'], { stdio: 'inherit' });
+            } catch {
+              throw new Error('Unsupported Linux distribution. Please install Certbot manually.');
+            }
+          }
+        } else if (platform === 'darwin') {
+          console.log(chalk.dim('Using Homebrew...'));
+          await execa('brew', ['install', 'certbot'], { stdio: 'inherit' });
+        } else {
+          throw new Error(`Unsupported platform: ${platform}. Please install Certbot manually.`);
+        }
+
+        console.log(chalk.green('✅ Certbot installed successfully'));
+      }
+    }
+
+    console.log(chalk.green.bold('\n✨ Setup completed successfully!\n'));
+    console.log(chalk.dim('Next steps:'));
+    console.log(chalk.dim('  1. Create a configuration file: suthep init'));
+    console.log(chalk.dim('  2. Deploy your services: suthep deploy\n'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Setup failed:'), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}