suthep 0.1.0

package/src/utils/config-loader.ts

@@ -0,0 +1,81 @@
+import fs from 'fs-extra'
+import yaml from 'js-yaml'
+import type { DeployConfig } from '../types/config'
+
+/**
+ * Load and parse a YAML configuration file
+ */
+export async function loadConfig(filePath: string): Promise<DeployConfig> {
+  try {
+    const fileContent = await fs.readFile(filePath, 'utf8')
+    const config = yaml.load(fileContent) as DeployConfig
+
+    validateConfig(config)
+
+    return config
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to load configuration from ${filePath}: ${error.message}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * Validate the configuration object
+ */
+function validateConfig(config: any): asserts config is DeployConfig {
+  if (!config.project || !config.project.name) {
+    throw new Error('Configuration must include project.name')
+  }
+
+  if (!config.services || !Array.isArray(config.services) || config.services.length === 0) {
+    throw new Error('Configuration must include at least one service')
+  }
+
+  for (const service of config.services) {
+    if (!service.name) {
+      throw new Error('Each service must have a name')
+    }
+    if (!service.port) {
+      throw new Error(`Service ${service.name} must have a port`)
+    }
+    if (!service.domains || !Array.isArray(service.domains) || service.domains.length === 0) {
+      throw new Error(`Service ${service.name} must have at least one domain`)
+    }
+  }
+
+  if (!config.nginx) {
+    config.nginx = {
+      configPath: '/etc/nginx/sites-available',
+      reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+    }
+  }
+
+  if (!config.certbot) {
+    config.certbot = {
+      email: '',
+      staging: false,
+    }
+  }
+
+  if (!config.deployment) {
+    config.deployment = {
+      strategy: 'rolling',
+      healthCheckTimeout: 30000,
+    }
+  }
+}
+
+/**
+ * Save configuration to a YAML file
+ */
+export async function saveConfig(filePath: string, config: DeployConfig): Promise<void> {
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+  })
+
+  await fs.writeFile(filePath, yamlContent, 'utf8')
+}

package/src/utils/deployment.ts

@@ -0,0 +1,132 @@
+import type { DeploymentConfig, ServiceConfig } from '../types/config'
+
+/**
+ * Perform a health check on a service endpoint
+ */
+export async function performHealthCheck(url: string, timeout: number = 30000): Promise<boolean> {
+  const startTime = Date.now()
+  const interval = 2000 // Check every 2 seconds
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000), // 5 second timeout per request
+      })
+
+      if (response.ok) {
+        return true
+      }
+    } catch (error) {
+      // Endpoint not ready yet, continue waiting
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, interval))
+  }
+
+  return false
+}
+
+/**
+ * Deploy a service with zero-downtime strategy
+ */
+export async function deployService(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig
+): Promise<void> {
+  if (deploymentConfig.strategy === 'rolling') {
+    await rollingDeploy(service, deploymentConfig)
+  } else if (deploymentConfig.strategy === 'blue-green') {
+    await blueGreenDeploy(service, deploymentConfig)
+  } else {
+    throw new Error(`Unknown deployment strategy: ${deploymentConfig.strategy}`)
+  }
+}
+
+/**
+ * Rolling deployment strategy
+ * Gradually replaces old instances with new ones
+ */
+async function rollingDeploy(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig
+): Promise<void> {
+  // For rolling deployment:
+  // 1. Start new service instance
+  // 2. Wait for health check
+  // 3. Switch traffic to new instance
+  // 4. Stop old instance (if applicable)
+
+  // In this implementation, we assume the service is already running
+  // and we're just verifying it's healthy before proceeding
+
+  if (service.healthCheck) {
+    const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+    const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+    if (!isHealthy) {
+      throw new Error(`Service ${service.name} failed health check during rolling deployment`)
+    }
+  }
+
+  // Add a small delay to ensure service is fully ready
+  await new Promise((resolve) => setTimeout(resolve, 2000))
+}
+
+/**
+ * Blue-green deployment strategy
+ * Maintains two identical environments and switches between them
+ */
+async function blueGreenDeploy(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig
+): Promise<void> {
+  // For blue-green deployment:
+  // 1. Deploy to "green" environment
+  // 2. Run health checks on green
+  // 3. Switch router/load balancer to green
+  // 4. Keep blue as backup
+
+  // This is a simplified implementation
+  // In production, you'd manage multiple service instances
+
+  if (service.healthCheck) {
+    const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+    const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+    if (!isHealthy) {
+      throw new Error(`Service ${service.name} failed health check during blue-green deployment`)
+    }
+  }
+}
+
+/**
+ * Wait for a service to become healthy
+ */
+export async function waitForService(
+  service: ServiceConfig,
+  timeout: number = 60000
+): Promise<boolean> {
+  if (!service.healthCheck) {
+    // No health check configured, assume service is ready after a short delay
+    await new Promise((resolve) => setTimeout(resolve, 5000))
+    return true
+  }
+
+  const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+  return await performHealthCheck(healthUrl, timeout)
+}
+
+/**
+ * Gracefully shutdown a service
+ */
+export async function gracefulShutdown(
+  _service: ServiceConfig,
+  timeout: number = 30000
+): Promise<void> {
+  // Send shutdown signal and wait for graceful termination
+  // This is a placeholder - actual implementation would depend on how services are managed
+
+  await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 5000)))
+}

package/src/utils/docker.ts

@@ -0,0 +1,151 @@
+import { execa } from 'execa'
+import type { ServiceConfig } from '../types/config'
+
+/**
+ * Start or connect to a Docker container for a service
+ */
+export async function startDockerContainer(service: ServiceConfig): Promise<void> {
+  if (!service.docker) {
+    return
+  }
+
+  const { image, container, port } = service.docker
+
+  try {
+    // Check if container exists
+    const { stdout: existingContainers } = await execa('docker', [
+      'ps',
+      '-a',
+      '--filter',
+      `name=${container}`,
+      '--format',
+      '{{.Names}}',
+    ])
+
+    if (existingContainers.includes(container)) {
+      // Container exists, check if it's running
+      const { stdout: runningContainers } = await execa('docker', [
+        'ps',
+        '--filter',
+        `name=${container}`,
+        '--format',
+        '{{.Names}}',
+      ])
+
+      if (!runningContainers.includes(container)) {
+        // Container exists but not running, start it
+        await execa('docker', ['start', container])
+      }
+    } else if (image) {
+      // Container doesn't exist and image is provided, create and run it
+      const args = [
+        'run',
+        '-d',
+        '--name',
+        container,
+        '-p',
+        `${service.port}:${port}`,
+        '--restart',
+        'unless-stopped',
+      ]
+
+      // Add environment variables if configured
+      if (service.environment) {
+        for (const [key, value] of Object.entries(service.environment)) {
+          args.push('-e', `${key}=${value}`)
+        }
+      }
+
+      args.push(image)
+
+      await execa('docker', args)
+    } else {
+      throw new Error(`Container ${container} not found and no image specified`)
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to start Docker container: ${error instanceof Error ? error.message : error}`
+    )
+  }
+}
+
+/**
+ * Stop a Docker container
+ */
+export async function stopDockerContainer(containerName: string): Promise<void> {
+  try {
+    await execa('docker', ['stop', containerName])
+  } catch (error) {
+    throw new Error(
+      `Failed to stop container ${containerName}: ${error instanceof Error ? error.message : error}`
+    )
+  }
+}
+
+/**
+ * Remove a Docker container
+ */
+export async function removeDockerContainer(containerName: string): Promise<void> {
+  try {
+    await execa('docker', ['rm', '-f', containerName])
+  } catch (error) {
+    throw new Error(
+      `Failed to remove container ${containerName}: ${
+        error instanceof Error ? error.message : error
+      }`
+    )
+  }
+}
+
+/**
+ * Check if a Docker container is running
+ */
+export async function isContainerRunning(containerName: string): Promise<boolean> {
+  try {
+    const { stdout } = await execa('docker', [
+      'ps',
+      '--filter',
+      `name=${containerName}`,
+      '--format',
+      '{{.Names}}',
+    ])
+    return stdout.includes(containerName)
+  } catch (error) {
+    return false
+  }
+}
+
+/**
+ * Get container logs
+ */
+export async function getContainerLogs(
+  containerName: string,
+  lines: number = 100
+): Promise<string> {
+  try {
+    const { stdout } = await execa('docker', ['logs', '--tail', lines.toString(), containerName])
+    return stdout
+  } catch (error) {
+    throw new Error(
+      `Failed to get logs for container ${containerName}: ${
+        error instanceof Error ? error.message : error
+      }`
+    )
+  }
+}
+
+/**
+ * Inspect a Docker container
+ */
+export async function inspectContainer(containerName: string): Promise<any> {
+  try {
+    const { stdout } = await execa('docker', ['inspect', containerName])
+    return JSON.parse(stdout)[0]
+  } catch (error) {
+    throw new Error(
+      `Failed to inspect container ${containerName}: ${
+        error instanceof Error ? error.message : error
+      }`
+    )
+  }
+}

package/src/utils/nginx.ts

@@ -0,0 +1,143 @@
+import { execa } from 'execa'
+import fs from 'fs-extra'
+import path from 'path'
+import type { ServiceConfig } from '../types/config'
+
+/**
+ * Generate Nginx server block configuration for a service
+ */
+export function generateNginxConfig(service: ServiceConfig, withHttps: boolean): string {
+  const serverNames = service.domains.join(' ')
+  const upstreamName = `${service.name}_backend`
+
+  let config = `# Nginx configuration for ${service.name}\n\n`
+
+  // Upstream configuration
+  config += `upstream ${upstreamName} {\n`
+  config += `    server localhost:${service.port} max_fails=3 fail_timeout=30s;\n`
+  config += `    keepalive 32;\n`
+  config += `}\n\n`
+
+  if (withHttps) {
+    // HTTP server - redirect to HTTPS
+    config += `server {\n`
+    config += `    listen 80;\n`
+    config += `    listen [::]:80;\n`
+    config += `    server_name ${serverNames};\n\n`
+    config += `    # Redirect all HTTP to HTTPS\n`
+    config += `    return 301 https://$server_name$request_uri;\n`
+    config += `}\n\n`
+
+    // HTTPS server
+    config += `server {\n`
+    config += `    listen 443 ssl http2;\n`
+    config += `    listen [::]:443 ssl http2;\n`
+    config += `    server_name ${serverNames};\n\n`
+
+    // SSL configuration
+    const primaryDomain = service.domains[0]
+    config += `    # SSL Configuration\n`
+    config += `    ssl_certificate /etc/letsencrypt/live/${primaryDomain}/fullchain.pem;\n`
+    config += `    ssl_certificate_key /etc/letsencrypt/live/${primaryDomain}/privkey.pem;\n`
+    config += `    ssl_protocols TLSv1.2 TLSv1.3;\n`
+    config += `    ssl_ciphers HIGH:!aNULL:!MD5;\n`
+    config += `    ssl_prefer_server_ciphers on;\n\n`
+  } else {
+    // HTTP only server
+    config += `server {\n`
+    config += `    listen 80;\n`
+    config += `    listen [::]:80;\n`
+    config += `    server_name ${serverNames};\n\n`
+  }
+
+  // Logging
+  config += `    # Logging\n`
+  config += `    access_log /var/log/nginx/${service.name}_access.log;\n`
+  config += `    error_log /var/log/nginx/${service.name}_error.log;\n\n`
+
+  // Client settings
+  config += `    # Client settings\n`
+  config += `    client_max_body_size 100M;\n\n`
+
+  // Proxy settings
+  config += `    # Proxy settings\n`
+  config += `    location / {\n`
+  config += `        proxy_pass http://${upstreamName};\n`
+  config += `        proxy_http_version 1.1;\n`
+  config += `        proxy_set_header Upgrade $http_upgrade;\n`
+  config += `        proxy_set_header Connection 'upgrade';\n`
+  config += `        proxy_set_header Host $host;\n`
+  config += `        proxy_set_header X-Real-IP $remote_addr;\n`
+  config += `        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n`
+  config += `        proxy_set_header X-Forwarded-Proto $scheme;\n`
+  config += `        proxy_cache_bypass $http_upgrade;\n`
+  config += `        proxy_connect_timeout 60s;\n`
+  config += `        proxy_send_timeout 60s;\n`
+  config += `        proxy_read_timeout 60s;\n`
+  config += `    }\n`
+
+  // Health check endpoint (if configured)
+  if (service.healthCheck) {
+    config += `\n    # Health check endpoint\n`
+    config += `    location ${service.healthCheck.path} {\n`
+    config += `        proxy_pass http://${upstreamName};\n`
+    config += `        access_log off;\n`
+    config += `    }\n`
+  }
+
+  config += `}\n`
+
+  return config
+}
+
+/**
+ * Enable an Nginx site by creating a symbolic link
+ */
+export async function enableSite(siteName: string, configPath: string): Promise<void> {
+  const availablePath = path.join(configPath, `${siteName}.conf`)
+  const enabledPath = availablePath.replace('sites-available', 'sites-enabled')
+
+  // Create sites-enabled directory if it doesn't exist
+  await fs.ensureDir(path.dirname(enabledPath))
+
+  // Remove existing symlink if present
+  if (await fs.pathExists(enabledPath)) {
+    await fs.remove(enabledPath)
+  }
+
+  // Create symlink
+  await execa('sudo', ['ln', '-sf', availablePath, enabledPath])
+}
+
+/**
+ * Test and reload Nginx configuration
+ */
+export async function reloadNginx(reloadCommand: string): Promise<void> {
+  try {
+    // Test configuration first
+    await execa('sudo', ['nginx', '-t'])
+
+    // Reload Nginx
+    const parts = reloadCommand.split(' ')
+    if (parts.length > 0) {
+      // Simple execution of provided command
+      await execa(parts[0], parts.slice(1), { shell: true })
+    }
+  } catch (error) {
+    throw new Error(`Failed to reload Nginx: ${error instanceof Error ? error.message : error}`)
+  }
+}
+
+/**
+ * Disable an Nginx site
+ */
+export async function disableSite(siteName: string, configPath: string): Promise<void> {
+  const enabledPath = path.join(
+    configPath.replace('sites-available', 'sites-enabled'),
+    `${siteName}.conf`
+  )
+
+  if (await fs.pathExists(enabledPath)) {
+    await fs.remove(enabledPath)
+  }
+}

package/suthep.example.yml

@@ -0,0 +1,69 @@
+project:
+  name: my-app
+  version: 1.0.0
+
+services:
+  # Example 1: Simple Node.js service
+  - name: api
+    port: 3000
+    domains:
+      - api.example.com
+      - www.api.example.com
+    healthCheck:
+      path: /health
+      interval: 30
+    environment:
+      NODE_ENV: production
+      PORT: 3000
+
+  # Example 2: Docker container service
+  - name: webapp
+    port: 8080
+    docker:
+      image: nginx:latest
+      container: webapp-container
+      port: 80
+    domains:
+      - example.com
+      - www.example.com
+    healthCheck:
+      path: /
+      interval: 30
+
+  # Example 3: Multiple subdomains with Docker
+  - name: dashboard
+    port: 5000
+    docker:
+      image: myapp/dashboard:latest
+      container: dashboard-container
+      port: 5000
+    domains:
+      - dashboard.example.com
+      - admin.example.com
+    healthCheck:
+      path: /api/health
+      interval: 60
+    environment:
+      DATABASE_URL: postgresql://localhost:5432/dashboard
+      REDIS_URL: redis://localhost:6379
+
+  # Example 4: Service connecting to existing Docker container
+  - name: database-proxy
+    port: 5432
+    docker:
+      container: postgres-container
+      port: 5432
+    domains:
+      - db.example.com
+
+nginx:
+  configPath: /etc/nginx/sites-available
+  reloadCommand: sudo nginx -t && sudo systemctl reload nginx
+
+certbot:
+  email: admin@example.com
+  staging: false  # Set to true for testing
+
+deployment:
+  strategy: rolling  # Options: rolling, blue-green
+  healthCheckTimeout: 30000  # milliseconds

package/todo.md

@@ -0,0 +1,6 @@
+build tool deploy and run project in yml service config service port to nginx multiple domain name or sub domain and can connect docker port
+✔ Automatic Nginx reverse proxy setup 
+✔ Automatic HTTPS with Certbot 
+✔ Zero-downtime deploy 
+make it in cli https://www.npmjs.com/package/commander typescript to build create project and setup by yml nginx
+in save cost in run vm

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,46 @@
+import { resolve } from 'path'
+import type { Plugin } from 'vite'
+import { defineConfig } from 'vite'
+
+const addShebangPlugin = (): Plugin => ({
+  name: 'add-shebang',
+  generateBundle(_options, bundle) {
+    if (bundle['index.js']) {
+      const chunk = bundle['index.js']
+      if (chunk.type === 'chunk') {
+        chunk.code = '#!/usr/bin/env node\n' + chunk.code
+      }
+    }
+  },
+})
+
+export default defineConfig({
+  plugins: [addShebangPlugin()],
+  build: {
+    outDir: 'dist',
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      formats: ['es'],
+      fileName: 'index',
+    },
+    rollupOptions: {
+      external: (id) => {
+        // Externalize all node_modules and Node.js built-ins
+        return (
+          !id.startsWith('.') &&
+          !id.startsWith('/') &&
+          !resolve(__dirname, id).startsWith(__dirname + '/src')
+        )
+      },
+      output: {
+        format: 'es',
+        entryFileNames: '[name].js',
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+    },
+    target: 'node18',
+    minify: false,
+    sourcemap: true,
+  },
+})