codecrypto-cli 1.0.7 → 1.0.9

package/src/commands/deploy.ts

@@ -4,13 +4,21 @@ 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')
+  .option('--image-version <version>', 'Image version/tag to deploy (overrides package.json version)')
+  .option('--skip-git-check', 'Skip Git repository status check', false)
   .action(async (projectPath: string, destFolder: string, options) => {
     console.log(chalk.blue('\n🐳 CodeCrypto Docker Deployment\n'));
 
@@ -29,20 +37,98 @@ export const deployCommand = new Command('deploy')
         process.exit(1);
       }
 
-      // Leer versión del package.json
+      // Validar que no hay archivos pendientes de commit (a menos que se omita)
+      if (!options.skipGitCheck) {
+        const gitCheckSpinner = ora('Checking Git status...').start();
+        try {
+          // Verificar si es un repositorio git usando git rev-parse
+          // Esto es más robusto que solo verificar .git ya que funciona con submodules y worktrees
+          let isGitRepo = false;
+          try {
+            execSync('git rev-parse --git-dir', {
+              cwd: resolvedProjectPath,
+              encoding: 'utf-8',
+              stdio: 'pipe',
+            });
+            isGitRepo = true;
+          } catch {
+            // No es un repositorio git o git no está disponible
+            isGitRepo = false;
+          }
+
+          if (isGitRepo) {
+            // Verificar si hay cambios sin commitear
+            try {
+              const gitStatus = execSync('git status --porcelain', {
+                cwd: resolvedProjectPath,
+                encoding: 'utf-8',
+                stdio: 'pipe',
+              }).trim();
+
+              if (gitStatus) {
+                gitCheckSpinner.fail('Uncommitted changes detected');
+                console.error(chalk.red('\n❌ Error: Hay archivos pendientes de commit en el repositorio'));
+                console.error(chalk.yellow('\n📋 Archivos modificados/sin commitear:'));
+                console.log(chalk.gray('─'.repeat(60)));
+                
+                // Mostrar los archivos pendientes
+                const files = gitStatus.split('\n').filter(line => line.trim());
+                files.forEach(file => {
+                  const status = file.substring(0, 2);
+                  const fileName = file.substring(3);
+                  let statusColor = chalk.yellow;
+                  if (status.includes('A')) statusColor = chalk.green;
+                  else if (status.includes('D')) statusColor = chalk.red;
+                  else if (status.includes('M')) statusColor = chalk.yellow;
+                  console.log(chalk.gray(`  ${statusColor(status)} ${chalk.white(fileName)}`));
+                });
+                
+                console.log(chalk.gray('─'.repeat(60)));
+                console.error(chalk.yellow('\n💡 Por favor, haz commit de tus cambios antes de desplegar:'));
+                console.error(chalk.cyan('   git add .'));
+                console.error(chalk.cyan('   git commit -m "your message"'));
+                console.error(chalk.yellow('\n   O usa --skip-git-check para omitir esta validación (no recomendado)'));
+                process.exit(1);
+              } else {
+                gitCheckSpinner.succeed('Git repository is clean');
+              }
+            } catch (error: any) {
+              // Si git status falla, puede ser que haya algún problema
+              gitCheckSpinner.warn('Could not check Git status, continuing...');
+              if (error.message) {
+                console.log(chalk.yellow(`   Warning: ${error.message}`));
+              }
+            }
+          } else {
+            gitCheckSpinner.succeed('Not a Git repository (skipping check)');
+          }
+        } catch (error: any) {
+          gitCheckSpinner.warn('Git check failed, continuing...');
+        }
+      } else {
+        console.log(chalk.yellow('⚠️  Git status check skipped (--skip-git-check)'));
+      }
+
+      // Leer versión del package.json o usar la versión especificada
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      const version = packageJson.version || 'latest';
+      const version = options.imageVersion || packageJson.version || 'latest';
       const projectName = path.basename(resolvedProjectPath);
       const imageBase = `jviejo/${projectName}`;
       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 +198,63 @@ 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 dockerfileSpinner = ora('Creating Dockerfile...').start();
       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/ .
 
@@ -130,28 +265,100 @@ EXPOSE 3000
 CMD ["node", "server.js"]
 `;
       fs.writeFileSync(dockerfilePath, dockerfileContent);
+      
+      dockerfileSpinner.succeed('Dockerfile created');
+      
+      // Mostrar contenido del Dockerfile si hay variables NEXT_PUBLIC_*
+      if (nextPublicEnvVars.length > 0) {
+        console.log(chalk.gray('\n📄 Dockerfile content:'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.white(dockerfileContent));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.gray(`\n  NEXT_PUBLIC_* variables: ${chalk.cyan(nextPublicEnvVars.length)}`));
+        nextPublicEnvVars.forEach(env => {
+          const [key] = env.split('=');
+          console.log(chalk.gray(`    - ${chalk.cyan(key)}`));
+        });
+      } else {
+        console.log(chalk.gray('\n📄 Dockerfile created (no NEXT_PUBLIC_* variables found)'));
+      }
 
       // Paso 4: Verificar/crear builder multi-plataforma
       const builderSpinner = ora('Setting up multi-platform builder...').start();
       try {
-        const builders = execSync('docker buildx ls', { encoding: 'utf-8' });
+        // Listar builders disponibles, ignorando errores de builders con problemas
+        let buildersOutput = '';
+        try {
+          // Redirigir stderr a /dev/null para ignorar errores de builders problemáticos
+          buildersOutput = execSync('docker buildx ls 2>/dev/null', { 
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            shell: '/bin/sh',
+          });
+        } catch (error) {
+          // Si hay errores al listar builders (por ejemplo, builder "cc" con problemas SSH),
+          // intentar continuar de todas formas
+          console.log(chalk.yellow('⚠️  Warning: Some builders have connection issues, continuing...'));
+        }
+        
         const builderName = 'multiarch-builder';
-        if (!builders.includes(builderName)) {
-          execSync(`docker buildx create --name ${builderName} --use --bootstrap`, { stdio: 'pipe' });
+        if (!buildersOutput.includes(builderName)) {
+          builderSpinner.text = 'Creating multi-platform builder...';
+          execSync(`docker buildx create --name ${builderName} --use --bootstrap`, { 
+            stdio: 'pipe',
+            // No heredar stderr para evitar errores de otros builders
+          });
         } else {
-          execSync(`docker buildx use ${builderName}`, { stdio: 'pipe' });
-    }
+          builderSpinner.text = 'Using existing multi-platform builder...';
+          try {
+            execSync(`docker buildx use ${builderName}`, { stdio: 'pipe' });
+          } catch (error) {
+            // Si falla, intentar crearlo de nuevo
+            builderSpinner.text = 'Recreating multi-platform builder...';
+            try {
+              execSync(`docker buildx rm ${builderName}`, { stdio: 'pipe' });
+            } catch {
+              // Ignorar si no existe
+            }
+            execSync(`docker buildx create --name ${builderName} --use --bootstrap`, { stdio: 'pipe' });
+          }
+        }
         builderSpinner.succeed('Builder ready');
-      } catch (error) {
+      } catch (error: any) {
         builderSpinner.fail('Failed to setup builder');
         console.error(chalk.red('Error setting up Docker buildx builder'));
+        console.error(chalk.yellow('💡 Tip: If you have problematic builders configured, you can remove them with:'));
+        console.error(chalk.cyan('   docker buildx rm <builder-name>'));
+        console.error(chalk.yellow('   Or inspect them with: docker buildx inspect <builder-name>'));
         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'];
         
@@ -161,6 +368,14 @@ CMD ["node", "server.js"]
           --progress=plain \
           .`;
 
+        console.log(chalk.gray('\n🔨 Build command:'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.cyan(buildCommand));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.gray(`\n  Working directory: ${chalk.cyan(resolvedDestFolder)}`));
+        console.log(chalk.gray(`  Platforms: ${chalk.cyan('linux/amd64, linux/arm64')}`));
+        console.log(chalk.gray(`  Push to registry: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}\n`));
+
         execSync(buildCommand, { 
           cwd: resolvedDestFolder,
           stdio: 'inherit'
@@ -168,32 +383,365 @@ CMD ["node", "server.js"]
 
         buildDockerSpinner.succeed('Docker image built successfully');
 
-        console.log(chalk.green('\n✅ Deployment completed successfully!'));
-        console.log(chalk.gray('Image details:'));
+        console.log(chalk.green('\n✅ Image build and push completed successfully!'));
+        console.log(chalk.gray('📦 Image details:'));
+        console.log(chalk.gray('─'.repeat(60)));
         console.log(chalk.white(`  Platforms: ${chalk.cyan('linux/amd64, linux/arm64')}`));
         console.log(chalk.white(`  Version: ${chalk.cyan(version)}`));
         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}`)}`));
+          console.log(chalk.gray('─'.repeat(60)));
+          console.log(chalk.green(`\n✅ Image pushed to Docker Hub successfully!`));
+        } else {
+          console.log(chalk.gray('─'.repeat(60)));
+          console.log(chalk.yellow(`\n⚠️  Image built locally (not pushed to registry)`));
         }
       } 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) {
+        // Para despliegue, usar la versión especificada o la del package.json
+        const deployImageName = options.imageVersion 
+          ? `${imageBase}:${options.imageVersion}`
+          : (shouldPush ? imageName : imageLatest);
+        
+        await deployToRemoteServer({
+          imageName: deployImageName,
+          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 leer certificados Docker desde token.json
+function loadDockerCertificatesFromToken(): { caPem: string; certPem: string; keyPem: string; certPath: string } {
+  const tokenFilePath = path.join(os.homedir(), '.codecrypto', 'token.json');
+  
+  if (!fs.existsSync(tokenFilePath)) {
+    throw new Error(`Token file not found at ${tokenFilePath}. Please run 'codecrypto auth' first.`);
+  }
+
+  let tokenData: any;
+  try {
+    tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf-8'));
+  } catch (error: any) {
+    throw new Error(`Failed to read token file: ${error.message}`);
+  }
+
+  if (!tokenData.adminGlobals || !Array.isArray(tokenData.adminGlobals)) {
+    throw new Error('adminGlobals not found in token.json. Please run "codecrypto auth --force" to refresh your token.');
+  }
+
+  // Buscar los certificados Docker en el array adminGlobals
+  // Las keys que buscamos son:
+  // - docker-client/ca-pem
+  // - docker-client/cert.pem
+  // - docker-client/key.pem
+  const certKeys = {
+    ca: 'docker-client/ca-pem',
+    cert: 'docker-client/cert.pem',
+    key: 'docker-client/key.pem'
+  };
+
+  const certificates: { ca?: string; cert?: string; key?: string } = {};
+  
+  // Lista de keys encontradas para debugging
+  const foundKeys: string[] = [];
+
+  // Iterar sobre adminGlobals para encontrar los certificados
+  for (const global of tokenData.adminGlobals) {
+    if (global && global.key) {
+      foundKeys.push(global.key);
+      // Buscar cada certificado por su key exacta
+      if (global.key === certKeys.ca) {
+        certificates.ca = global.value;
+      } else if (global.key === certKeys.cert) {
+        certificates.cert = global.value;
+      } else if (global.key === certKeys.key) {
+        certificates.key = global.value;
+      }
+    }
+  }
+
+  // Verificar que todos los certificados estén presentes
+  if (!certificates.ca) {
+    const availableKeys = foundKeys.filter(k => k.includes('docker-client')).join(', ') || 'none';
+    throw new Error(
+      `Certificate not found: ${certKeys.ca} in adminGlobals.\n` +
+      `  Available docker-client keys: ${availableKeys || 'none'}\n` +
+      `  Total adminGlobals entries: ${tokenData.adminGlobals.length}\n` +
+      `  Please run "codecrypto auth --force" to refresh your token.`
+    );
+  }
+  if (!certificates.cert) {
+    const availableKeys = foundKeys.filter(k => k.includes('docker-client')).join(', ') || 'none';
+    throw new Error(
+      `Certificate not found: ${certKeys.cert} in adminGlobals.\n` +
+      `  Available docker-client keys: ${availableKeys || 'none'}\n` +
+      `  Total adminGlobals entries: ${tokenData.adminGlobals.length}\n` +
+      `  Please run "codecrypto auth --force" to refresh your token.`
+    );
+  }
+  if (!certificates.key) {
+    const availableKeys = foundKeys.filter(k => k.includes('docker-client')).join(', ') || 'none';
+    throw new Error(
+      `Certificate not found: ${certKeys.key} in adminGlobals.\n` +
+      `  Available docker-client keys: ${availableKeys || 'none'}\n` +
+      `  Total adminGlobals entries: ${tokenData.adminGlobals.length}\n` +
+      `  Please run "codecrypto auth --force" to refresh your token.`
+    );
+  }
+
+  // Crear directorio para certificados si no existe
+  const dockerCertPath = path.join(os.homedir(), '.codecrypto', 'docker-client');
+  if (!fs.existsSync(dockerCertPath)) {
+    fs.mkdirSync(dockerCertPath, { recursive: true });
+  }
+
+  // Escribir certificados a archivos
+  const caPemPath = path.join(dockerCertPath, 'ca.pem');
+  const certPemPath = path.join(dockerCertPath, 'cert.pem');
+  const keyPemPath = path.join(dockerCertPath, 'key.pem');
+
+  fs.writeFileSync(caPemPath, certificates.ca, 'utf-8');
+  fs.writeFileSync(certPemPath, certificates.cert, 'utf-8');
+  fs.writeFileSync(keyPemPath, certificates.key, 'utf-8');
+
+  // Establecer permisos correctos para la clave privada (solo lectura para el propietario)
+  try {
+    fs.chmodSync(keyPemPath, 0o600);
+  } catch (error) {
+    // Ignorar errores de chmod en Windows
+  }
+
+  return {
+    caPem: certificates.ca,
+    certPem: certificates.cert,
+    keyPem: certificates.key,
+    certPath: dockerCertPath
+  };
+}
+
+// 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 {
+    // Cargar certificados desde token.json
+    let dockerCertPath: string;
+    try {
+      const certs = loadDockerCertificatesFromToken();
+      dockerCertPath = certs.certPath;
+      deploySpinner.succeed('Docker certificates loaded from token.json');
+    } catch (error: any) {
+      deploySpinner.fail('Failed to load Docker certificates');
+      console.error(chalk.red(`❌ Error: ${error.message}`));
+      console.error(chalk.yellow('\n💡 To fix this issue:'));
+      console.error(chalk.yellow('   1. Run: codecrypto auth --force'));
+      console.error(chalk.yellow('   2. This will refresh your token with the latest adminGlobals'));
+      console.error(chalk.yellow('   3. Then try the deploy command again\n'));
+      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);
+      }
+    }
+
+    // Construir prefijo de comando Docker con parámetros TLS
+    const dockerHost = 'tcp://server.codecrypto.academy:2376';
+    const dockerTlsPrefix = `docker -H ${dockerHost} \\
+  --tlsverify \\
+  --tlscacert="${path.join(dockerCertPath, 'ca.pem')}" \\
+  --tlscert="${path.join(dockerCertPath, 'cert.pem')}" \\
+  --tlskey="${path.join(dockerCertPath, 'key.pem')}"`;
+    
+    console.log(chalk.gray('\n🔌 Remote Docker configuration:'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.white(`  Docker Host: ${chalk.cyan(dockerHost)}`));
+    console.log(chalk.white(`  TLS Verify: ${chalk.cyan('enabled')}`));
+    console.log(chalk.white(`  Certificates Source: ${chalk.cyan('token.json (adminGlobals)')}`));
+    console.log(chalk.white(`  Certificates Path: ${chalk.cyan(dockerCertPath)}`));
+    console.log(chalk.gray('  Certificates loaded:'));
+    requiredCerts.forEach(cert => {
+      const certPath = path.join(dockerCertPath, cert);
+      const exists = fs.existsSync(certPath);
+      console.log(chalk.gray(`    ${exists ? '✓' : '✗'} ${chalk.cyan(cert)}`));
+    });
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.yellow('\n💡 All docker commands will use TLS parameters directly\n'));
+
+    // 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 and removing existing container...').start();
+    try {
+      // Verificar si el contenedor existe
+      const checkCmd = `${dockerTlsPrefix} ps -a --filter name=^${fullDomain}$ --format "{{.Names}}"`;
+      const existingContainer = execSync(checkCmd, {
+        stdio: 'pipe',
+        encoding: 'utf-8',
+        shell: '/bin/sh',
+      }).trim();
+      
+      if (existingContainer === fullDomain) {
+        // Contenedor existe, detenerlo primero (si está corriendo)
+        try {
+          const stopCmd = `${dockerTlsPrefix} stop ${fullDomain}`;
+          execSync(stopCmd, { stdio: 'pipe', shell: '/bin/sh' });
+          console.log(chalk.gray(`  ✓ Container ${fullDomain} stopped`));
+        } catch (error: any) {
+          // Container might not be running, that's okay
+          console.log(chalk.gray(`  ℹ Container ${fullDomain} was not running`));
+        }
+        
+        // Eliminar el contenedor
+        try {
+          const rmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+          execSync(rmCmd, { stdio: 'pipe', shell: '/bin/sh' });
+          stopSpinner.succeed(`Existing container ${fullDomain} removed`);
+        } catch (error: any) {
+          stopSpinner.fail(`Failed to remove container ${fullDomain}`);
+          console.error(chalk.red(`   Error: ${error.message}`));
+          process.exit(1);
+        }
+      } else {
+        stopSpinner.succeed('No existing container found');
+      }
+    } catch (error: any) {
+      // Si el comando falla, puede ser que el contenedor no exista
+      // Intentar eliminarlo de todas formas con -f para forzar
+      try {
+        const forceRmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+        execSync(forceRmCmd, { stdio: 'pipe', shell: '/bin/sh' });
+        stopSpinner.succeed('Existing container removed (forced)');
+      } catch {
+        // Si falla, asumir que no existe y continuar
+        stopSpinner.succeed('No existing container found');
+      }
+    }
+
+    // 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 con parámetros TLS
+    const dockerRunCmd = `${dockerTlsPrefix} run -d \\
+  --name ${fullDomain} \\
+  --network academy-network \\
+  --restart unless-stopped \\
+  ${envOpts.length > 0 ? 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}`;
+
+    console.log(chalk.gray('\n🚀 Deployment command (executing on remote Docker):'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.cyan(dockerRunCmd));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.gray(`\n  Remote Docker: ${chalk.cyan(dockerHost)}`));
+    console.log(chalk.gray(`  TLS Certificates: ${chalk.cyan(dockerCertPath)}`));
+    console.log(chalk.gray(`  Service name: ${chalk.cyan(config.serviceName)}`));
+    console.log(chalk.gray(`  Full domain: ${chalk.cyan(fullDomain)}`));
+    console.log(chalk.gray(`  Image: ${chalk.cyan(config.imageName)}`));
+    console.log(chalk.gray(`  Port: ${chalk.cyan(config.port)}`));
+    console.log(chalk.gray(`  Environment variables: ${chalk.cyan(config.envVars.length)}`));
+    if (config.envVars.length > 0) {
+      config.envVars.forEach(env => {
+        const [key] = env.split('=');
+        console.log(chalk.gray(`    - ${chalk.cyan(key)}`));
+      });
+    }
+    console.log(chalk.gray('─'.repeat(60)));
+
+    const runSpinner = ora('Deploying container to remote server...').start();
+    
+    try {
+      // Ejecutar comando docker con parámetros TLS directamente
+      execSync(dockerRunCmd, {
+        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.gray('─'.repeat(60)));
+      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)}`));
+      console.log(chalk.white(`  Network: ${chalk.cyan('academy-network')}`));
+      console.log(chalk.white(`  Restart policy: ${chalk.cyan('unless-stopped')}`));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.green(`\n🌐 Your application is now available at: ${chalk.cyan.underline(`https://${fullDomain}`)}`));
+    } 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 +772,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;
     }
   }
 }