suthep 0.1.0

package/src/commands/deploy.ts

@@ -0,0 +1,133 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import { requestCertificate } from '../utils/certbot'
+import { loadConfig } from '../utils/config-loader'
+import { deployService, performHealthCheck } from '../utils/deployment'
+import { startDockerContainer } from '../utils/docker'
+import { enableSite, generateNginxConfig, reloadNginx } 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`))
+
+    // Deploy each service
+    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...'))
+          await startDockerContainer(service)
+        }
+
+        // Deploy the service
+        await deployService(service, config.deployment)
+
+        // Generate and configure Nginx
+        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(', ')}`))
+        }
+
+        // Setup HTTPS with Certbot
+        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) {
+              console.log(
+                chalk.yellow(
+                  `  ⚠️  Failed to obtain SSL for ${domain}: ${
+                    error instanceof Error ? error.message : error
+                  }`
+                )
+              )
+            }
+          }
+
+          // Update Nginx config with HTTPS
+          if (options.nginx) {
+            const nginxConfigContent = generateNginxConfig(service, true)
+            const nginxConfigPath = path.join(config.nginx.configPath, `${service.name}.conf`)
+            await fs.writeFile(nginxConfigPath, nginxConfigContent)
+          }
+        }
+
+        // Reload Nginx after all configurations
+        if (options.nginx) {
+          console.log(chalk.dim('  🔄 Reloading Nginx...'))
+          await reloadNginx(config.nginx.reloadCommand)
+        }
+
+        // Perform health check
+        if (service.healthCheck) {
+          console.log(chalk.dim(`  🏥 Performing health check...`))
+          const isHealthy = await performHealthCheck(
+            `http://localhost:${service.port}${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(`\n✨ 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
+      }
+    }
+
+    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'
+        console.log(chalk.dim(`   ${service.name}: ${protocol}://${domain}`))
+      }
+    }
+    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'))
+}

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);
+  }
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+import { Command } from 'commander'
+import { deployCommand } from './commands/deploy'
+import { initCommand } from './commands/init'
+import { setupCommand } from './commands/setup'
+
+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')
+
+program
+  .command('init')
+  .description('Initialize a new deployment configuration file')
+  .option('-f, --file <path>', 'Configuration file path', 'suthep.yml')
+  .action(initCommand)
+
+program
+  .command('setup')
+  .description('Setup Nginx and Certbot on the system')
+  .option('--nginx-only', 'Only setup Nginx')
+  .option('--certbot-only', 'Only setup Certbot')
+  .action(setupCommand)
+
+program
+  .command('deploy')
+  .description('Deploy a project using the configuration file')
+  .option('-f, --file <path>', 'Configuration file path', 'suthep.yml')
+  .option('--no-https', 'Skip HTTPS setup')
+  .option('--no-nginx', 'Skip Nginx configuration')
+  .action(deployCommand)
+
+program.parse()

package/src/types/config.ts

@@ -0,0 +1,51 @@
+/**
+ * Configuration type definitions for the Suthep deployment tool
+ */
+
+export interface ProjectConfig {
+  name: string;
+  version: string;
+}
+
+export interface HealthCheckConfig {
+  path: string;
+  interval: number;
+}
+
+export interface DockerConfig {
+  image?: string;
+  container: string;
+  port: number;
+}
+
+export interface ServiceConfig {
+  name: string;
+  port: number;
+  domains: string[];
+  docker?: DockerConfig;
+  healthCheck?: HealthCheckConfig;
+  environment?: Record<string, string>;
+}
+
+export interface NginxConfig {
+  configPath: string;
+  reloadCommand: string;
+}
+
+export interface CertbotConfig {
+  email: string;
+  staging: boolean;
+}
+
+export interface DeploymentConfig {
+  strategy: 'rolling' | 'blue-green';
+  healthCheckTimeout: number;
+}
+
+export interface DeployConfig {
+  project: ProjectConfig;
+  services: ServiceConfig[];
+  nginx: NginxConfig;
+  certbot: CertbotConfig;
+  deployment: DeploymentConfig;
+}

package/src/utils/certbot.ts

@@ -0,0 +1,82 @@
+import { execa } from 'execa'
+
+/**
+ * Request an SSL certificate from Let's Encrypt using Certbot
+ */
+export async function requestCertificate(
+  domain: string,
+  email: string,
+  staging: boolean = false
+): Promise<void> {
+  const args = [
+    'certonly',
+    '--nginx',
+    '-d',
+    domain,
+    '--non-interactive',
+    '--agree-tos',
+    '--email',
+    email,
+  ]
+
+  if (staging) {
+    args.push('--staging')
+  }
+
+  try {
+    await execa('sudo', ['certbot', ...args])
+  } catch (error) {
+    throw new Error(
+      `Failed to obtain SSL certificate for ${domain}: ${
+        error instanceof Error ? error.message : error
+      }`
+    )
+  }
+}
+
+/**
+ * Renew all SSL certificates
+ */
+export async function renewCertificates(): Promise<void> {
+  try {
+    await execa('sudo', ['certbot', 'renew', '--quiet'])
+  } catch (error) {
+    throw new Error(
+      `Failed to renew SSL certificates: ${error instanceof Error ? error.message : error}`
+    )
+  }
+}
+
+/**
+ * Check certificate expiration for a domain
+ */
+export async function checkCertificateExpiration(domain: string): Promise<Date | null> {
+  try {
+    const { stdout } = await execa('sudo', ['certbot', 'certificates', '-d', domain])
+
+    // Parse expiration date from output
+    const expiryMatch = stdout.match(/Expiry Date: ([^\n]+)/)
+    if (expiryMatch) {
+      return new Date(expiryMatch[1])
+    }
+
+    return null
+  } catch (error) {
+    return null
+  }
+}
+
+/**
+ * Revoke a certificate for a domain
+ */
+export async function revokeCertificate(domain: string): Promise<void> {
+  try {
+    await execa('sudo', ['certbot', 'revoke', '-d', domain, '--non-interactive'])
+  } catch (error) {
+    throw new Error(
+      `Failed to revoke certificate for ${domain}: ${
+        error instanceof Error ? error.message : error
+      }`
+    )
+  }
+}