codecrypto-cli 1.0.7 → 1.0.8

package/src/commands/deploy.ts

@@ -4,13 +4,19 @@ import ora from 'ora';
 import { execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 export const deployCommand = new Command('deploy')
   .description('Build and deploy Docker image for Next.js standalone application')
   .argument('<project-path>', 'Path to the Next.js project directory')
   .argument('[dest-folder]', 'Destination folder for Docker build context', './docker-build')
   .option('--skip-build', 'Skip npm run build (assume already built)', false)
-  .option('--no-push', 'Build image but do not push to registry', false)
+  .option('--no-push', 'Build image but do not push to registry')
+  .option('--deploy', 'Deploy to remote server after building', false)
+  .option('--service-name <name>', 'Service name for remote deployment')
+  .option('--env-file <path>', 'Path to .env file with environment variables')
+  .option('--port <port>', 'Application port', '3000')
+  .option('--domain-base <domain>', 'Domain base for deployment', 'proyectos.codecrypto.academy')
   .action(async (projectPath: string, destFolder: string, options) => {
     console.log(chalk.blue('\n🐳 CodeCrypto Docker Deployment\n'));
 
@@ -37,12 +43,18 @@ export const deployCommand = new Command('deploy')
       const imageName = `${imageBase}:${version}`;
       const imageLatest = `${imageBase}:latest`;
 
-    console.log(chalk.gray('Deployment Configuration:'));
+      // Determinar si hacer push
+      // En Commander.js, cuando defines .option('--no-push', ...) sin tercer parámetro:
+      // - Por defecto (sin flags): options.push = true (hace push)
+      // - Con --no-push: options.push = false (no hace push)
+      const shouldPush = options.push !== false;
+
+      console.log(chalk.gray('Deployment Configuration:'));
       console.log(chalk.white(`  Project: ${chalk.green(projectName)}`));
       console.log(chalk.white(`  Version: ${chalk.green(version)}`));
       console.log(chalk.white(`  Image: ${chalk.green(imageName)}`));
       console.log(chalk.white(`  Latest: ${chalk.green(imageLatest)}`));
-      console.log(chalk.white(`  Push to Registry: ${options.push ? chalk.green('Yes') : chalk.yellow('No')}\n`));
+      console.log(chalk.white(`  Push to Registry: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}\n`));
 
       // Paso 1: Build del proyecto si es necesario
       if (!options.skipBuild) {
@@ -112,14 +124,62 @@ export const deployCommand = new Command('deploy')
 
       copySpinner.succeed('Files copied successfully');
 
-      // Paso 3: Crear Dockerfile
+      // Leer y procesar archivo .env si existe
+      let nextPublicEnvVars: string[] = [];
+      let runtimeEnvVars: string[] = [];
+      const envFilePath = options.envFile 
+        ? path.resolve(options.envFile)
+        : path.join(resolvedProjectPath, '.env');
+      
+      if (fs.existsSync(envFilePath)) {
+        const envContent = fs.readFileSync(envFilePath, 'utf-8');
+        const envLines = envContent.split('\n');
+        
+        for (const line of envLines) {
+          const trimmed = line.trim();
+          // Ignorar comentarios y líneas vacías
+          if (!trimmed || trimmed.startsWith('#')) continue;
+          
+          const equalIndex = trimmed.indexOf('=');
+          if (equalIndex === -1) continue;
+          
+          const key = trimmed.substring(0, equalIndex).trim();
+          const value = trimmed.substring(equalIndex + 1).trim();
+          
+          if (key.startsWith('NEXT_PUBLIC_')) {
+            nextPublicEnvVars.push(`${key}=${value}`);
+          } else {
+            runtimeEnvVars.push(`${key}=${value}`);
+          }
+        }
+      }
+
+      // Paso 3: Crear Dockerfile con variables NEXT_PUBLIC_*
       const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
+      
+      // Construir ARG y ENV para NEXT_PUBLIC_*
+      const buildArgs = nextPublicEnvVars.map(env => {
+        const [key, ...valueParts] = env.split('=');
+        const value = valueParts.join('=');
+        return `ARG ${key}=${value}`;
+      }).join('\n');
+      
+      const buildEnvs = nextPublicEnvVars.map(env => {
+        const [key, ...valueParts] = env.split('=');
+        const value = valueParts.join('=');
+        return `ENV ${key}=${value}`;
+      }).join('\n');
+      
       const dockerfileContent = `FROM node:20-alpine
 WORKDIR /app
 
 ENV NODE_ENV=production
 ENV PORT=3000
 
+${buildArgs}
+
+${buildEnvs}
+
 # Copiamos el contenido de standalone
 COPY standalone/ .
 
@@ -148,10 +208,32 @@ CMD ["node", "server.js"]
         process.exit(1);
       }
 
+      // Verificar autenticación de Docker si se va a hacer push
+      if (shouldPush) {
+        const authSpinner = ora('Verifying Docker authentication...').start();
+        try {
+          // Verificar si hay credenciales de Docker configuradas
+          execSync('docker info', { stdio: 'pipe' });
+          // Intentar verificar login en Docker Hub
+          try {
+            execSync('docker pull hello-world:latest', { stdio: 'pipe' });
+            authSpinner.succeed('Docker authentication verified');
+          } catch {
+            // Si no puede hacer pull, verificar al menos que docker está funcionando
+            authSpinner.warn('Could not verify Docker Hub authentication. Make sure you are logged in with: docker login');
+          }
+        } catch (error) {
+          authSpinner.fail('Docker authentication failed');
+          console.error(chalk.yellow('\n⚠️  Warning: Docker authentication may be required for push'));
+          console.error(chalk.yellow('   Run: docker login'));
+          console.error(chalk.yellow('   Or use --no-push to skip pushing to registry\n'));
+        }
+      }
+
       // Paso 5: Construir y hacer push
       const buildDockerSpinner = ora('Building Docker image for multiple platforms...').start();
       try {
-        const tags = options.push 
+        const tags = shouldPush 
           ? [`--tag ${imageName}`, `--tag ${imageLatest}`, '--push']
           : [`--tag ${imageName}`, `--tag ${imageLatest}`, '--load'];
         
@@ -175,25 +257,173 @@ CMD ["node", "server.js"]
         console.log(chalk.white(`  Tags:`));
         console.log(chalk.white(`    - ${chalk.cyan(imageName)}`));
         console.log(chalk.white(`    - ${chalk.cyan(imageLatest)}`));
-        if (options.push) {
+        if (shouldPush) {
           console.log(chalk.white(`  Registry: ${chalk.cyan('Docker Hub')}`));
           console.log(chalk.white(`  URL: ${chalk.cyan(`https://hub.docker.com/r/${imageBase}`)}`));
         }
       } catch (error) {
         buildDockerSpinner.fail('Docker build failed');
         console.error(chalk.red('\n❌ Error building Docker image'));
-        if (options.push) {
+        if (shouldPush) {
           console.error(chalk.yellow('Make sure you are authenticated: docker login'));
         }
         process.exit(1);
       }
 
+      // Paso 6: Desplegar en servidor remoto si se solicita
+      if (options.deploy) {
+        await deployToRemoteServer({
+          imageName: shouldPush ? imageName : imageLatest,
+          serviceName: options.serviceName || projectName,
+          domainBase: options.domainBase,
+          port: options.port,
+          envVars: runtimeEnvVars,
+          envFilePath: runtimeEnvVars.length > 0 ? envFilePath : undefined,
+        });
+      }
+
     } catch (error: any) {
       console.error(chalk.red(`\n❌ Error: ${error.message}`));
       process.exit(1);
     }
   });
 
+// Función para desplegar en servidor remoto
+async function deployToRemoteServer(config: {
+  imageName: string;
+  serviceName: string;
+  domainBase: string;
+  port: string;
+  envVars: string[];
+  envFilePath?: string;
+}) {
+  const deploySpinner = ora('Configuring remote Docker connection...').start();
+  
+  try {
+    // Configurar variables de entorno para Docker remoto
+    const dockerCertPath = path.join(os.homedir(), '.codecrypto', 'docker-client');
+    
+    if (!fs.existsSync(dockerCertPath)) {
+      deploySpinner.fail('Docker certificates not found');
+      console.error(chalk.red(`❌ Error: Docker certificates not found at ${dockerCertPath}`));
+      console.error(chalk.yellow('   Make sure you have the certificates in ~/.codecrypto/docker-client'));
+      process.exit(1);
+    }
+
+    // Verificar que existen los certificados necesarios
+    const requiredCerts = ['ca.pem', 'cert.pem', 'key.pem'];
+    for (const cert of requiredCerts) {
+      const certPath = path.join(dockerCertPath, cert);
+      if (!fs.existsSync(certPath)) {
+        deploySpinner.fail(`Certificate ${cert} not found`);
+        console.error(chalk.red(`❌ Error: Certificate ${cert} not found at ${certPath}`));
+        process.exit(1);
+      }
+    }
+
+    // Configurar variables de entorno para Docker
+    const dockerEnv: Record<string, string> = {
+      ...process.env,
+      DOCKER_HOST: 'https://server.codecrypto.academy:2376',
+      DOCKER_TLS_VERIFY: '1',
+      DOCKER_CERT_PATH: dockerCertPath,
+    };
+
+    deploySpinner.succeed('Docker connection configured');
+
+    // Construir nombre completo del dominio
+    const fullDomain = `${config.serviceName}.${config.domainBase}`;
+    const serviceName = config.serviceName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+
+    // Detener y eliminar contenedor existente si existe
+    const stopSpinner = ora('Checking for existing container...').start();
+    try {
+      execSync(`docker ps -a --filter name=^${fullDomain}$ --format "{{.Names}}"`, {
+        env: dockerEnv,
+        stdio: 'pipe',
+        encoding: 'utf-8',
+      });
+      
+      // Si existe, detenerlo y eliminarlo
+      try {
+        execSync(`docker stop ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
+      } catch {
+        // Container might not be running
+      }
+      
+      try {
+        execSync(`docker rm ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
+        stopSpinner.succeed('Existing container removed');
+      } catch {
+        stopSpinner.warn('No existing container found');
+      }
+    } catch (error) {
+      stopSpinner.warn('Could not check for existing container');
+    }
+
+    // Preparar opciones de entorno
+    // Para despliegue remoto, pasamos las variables directamente con -e
+    // ya que --env-file requiere que el archivo esté en el servidor remoto
+    const envOpts: string[] = [];
+    if (config.envVars.length > 0) {
+      config.envVars.forEach(env => {
+        // Escapar comillas y caracteres especiales en el valor
+        const [key, ...valueParts] = env.split('=');
+        const value = valueParts.join('=');
+        // Escapar comillas dobles en el valor
+        const escapedValue = value.replace(/"/g, '\\"');
+        envOpts.push(`-e "${key}=${escapedValue}"`);
+      });
+    }
+
+    // Construir comando docker run
+    const dockerRunCmd = `docker run -d \\
+  --name ${fullDomain} \\
+  --network academy-network \\
+  --restart unless-stopped \\
+  ${envOpts.join(' \\\n  ')} \\
+  -l traefik.enable=true \\
+  -l "traefik.http.routers.${serviceName}-router.rule=Host(\\\`${fullDomain}\\\`)" \\
+  -l traefik.http.routers.${serviceName}-router.entrypoints=websecure \\
+  -l traefik.http.routers.${serviceName}-router.tls=true \\
+  -l traefik.http.services.${serviceName}-service.loadbalancer.server.port=${config.port} \\
+  ${config.imageName}`;
+
+    const runSpinner = ora('Deploying container to remote server...').start();
+    
+    try {
+      execSync(dockerRunCmd, {
+        env: dockerEnv,
+        stdio: 'inherit',
+        shell: '/bin/sh',
+      });
+
+      runSpinner.succeed('Container deployed successfully');
+
+      console.log(chalk.green('\n✅ Remote deployment completed successfully!'));
+      console.log(chalk.gray('Deployment details:'));
+      console.log(chalk.white(`  Service: ${chalk.cyan(config.serviceName)}`));
+      console.log(chalk.white(`  Domain: ${chalk.cyan(fullDomain)}`));
+      console.log(chalk.white(`  URL: ${chalk.cyan(`https://${fullDomain}`)}`));
+      console.log(chalk.white(`  Image: ${chalk.cyan(config.imageName)}`));
+      console.log(chalk.white(`  Port: ${chalk.cyan(config.port)}`));
+    } catch (error) {
+      runSpinner.fail('Failed to deploy container');
+      console.error(chalk.red('\n❌ Error deploying container to remote server'));
+      console.error(chalk.yellow('   Make sure:'));
+      console.error(chalk.yellow('   - The image is available on the remote server'));
+      console.error(chalk.yellow('   - You have push the image to Docker Hub (or use --no-push and ensure image exists)'));
+      console.error(chalk.yellow('   - The network "academy-network" exists on the remote server'));
+      process.exit(1);
+    }
+
+  } catch (error: any) {
+    deploySpinner.fail('Failed to configure remote deployment');
+    console.error(chalk.red(`\n❌ Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
 // Helper functions
 function findDirectory(root: string, name: string): string | null {
   try {
@@ -224,10 +454,33 @@ function copyDirectory(src: string, dest: string): void {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
     
-    if (entry.isDirectory()) {
-      copyDirectory(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
+    try {
+      // Obtener información detallada del archivo para detectar tipos especiales
+      const stats = fs.lstatSync(srcPath);
+      
+      if (stats.isDirectory()) {
+        copyDirectory(srcPath, destPath);
+      } else if (stats.isFile()) {
+        // Solo copiar archivos regulares
+        fs.copyFileSync(srcPath, destPath);
+      } else if (stats.isSymbolicLink()) {
+        // Copiar symlinks preservando el target
+        const linkTarget = fs.readlinkSync(srcPath);
+        fs.symlinkSync(linkTarget, destPath);
+      } else {
+        // Saltar sockets, FIFOs, y otros tipos especiales
+        // Estos no son necesarios para el build de Docker
+        continue;
+      }
+    } catch (error: any) {
+      // Si hay un error al copiar (por ejemplo, socket), simplemente saltarlo
+      // Los sockets y otros archivos especiales no son necesarios para el build
+      if (error.code === 'ENOTSUP' || error.code === 'EINVAL' || error.code === 'EOPNOTSUPP') {
+        // Saltar silenciosamente sockets y otros archivos especiales
+        continue;
+      }
+      // Para otros errores, lanzar el error
+      throw error;
     }
   }
 }