codecrypto-cli 1.0.8 → 1.0.10

package/src/commands/deploy.ts

@@ -7,8 +7,8 @@ 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')
+  .description('Build and deploy Docker image for Next.js or Express application')
+  .argument('<project-path>', 'Path to the 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')
@@ -17,6 +17,8 @@ export const deployCommand = new Command('deploy')
   .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'));
 
@@ -35,9 +37,81 @@ 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}`;
@@ -49,128 +123,164 @@ export const deployCommand = new Command('deploy')
       // - Con --no-push: options.push = false (no hace push)
       const shouldPush = options.push !== false;
 
+      // Detectar automáticamente el tipo de proyecto analizando package.json
+      const allDependencies = {
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+      };
+      
+      let projectType: 'nextjs' | 'express' | null = null;
+      
+      if (allDependencies.next || allDependencies['nextjs']) {
+        projectType = 'nextjs';
+      } else if (allDependencies.express) {
+        projectType = 'express';
+      }
+      
+      if (!projectType) {
+        console.error(chalk.red(`❌ Error: No se pudo detectar el tipo de proyecto`));
+        console.error(chalk.yellow('   El proyecto debe tener "next" o "express" en las dependencias del package.json'));
+        console.error(chalk.yellow('   Dependencias encontradas:'));
+        const depKeys = Object.keys(allDependencies).slice(0, 10);
+        depKeys.forEach(dep => {
+          console.error(chalk.gray(`     - ${dep}`));
+        });
+        if (Object.keys(allDependencies).length > 10) {
+          console.error(chalk.gray(`     ... y ${Object.keys(allDependencies).length - 10} más`));
+        }
+        process.exit(1);
+      }
+
       console.log(chalk.gray('Deployment Configuration:'));
       console.log(chalk.white(`  Project: ${chalk.green(projectName)}`));
+      console.log(chalk.white(`  Type: ${chalk.green(projectType)}`));
       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: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}\n`));
 
-      // Paso 1: Build del proyecto si es necesario
-      if (!options.skipBuild) {
-        const buildSpinner = ora('Building Next.js application...').start();
-        try {
-          execSync('npm run build', { 
-            cwd: resolvedProjectPath, 
-            stdio: 'pipe' 
-          });
-          buildSpinner.succeed('Build completed successfully');
-        } catch (error) {
-          buildSpinner.fail('Build failed');
-          console.error(chalk.red('Error during build. Make sure you have "output: standalone" in next.config.ts'));
-          process.exit(1);
-        }
-      }
-
-      // Verificar que existe .next/standalone
-      const standalonePath = path.join(resolvedProjectPath, '.next', 'standalone');
-      if (!fs.existsSync(standalonePath)) {
-        console.error(chalk.red(`❌ Error: No se encontró .next/standalone`));
-        console.error(chalk.yellow('Asegúrate de tener "output: standalone" en next.config.ts y ejecutar "npm run build"'));
-        process.exit(1);
-      }
-
-      // Paso 2: Preparar directorio destino
+      // Preparar directorio destino
       const resolvedDestFolder = path.resolve(destFolder);
-      const standaloneDest = path.join(resolvedDestFolder, 'standalone');
-      
-      const copySpinner = ora('Copying standalone files...').start();
       if (fs.existsSync(resolvedDestFolder)) {
         fs.rmSync(resolvedDestFolder, { recursive: true, force: true });
       }
-      fs.mkdirSync(standaloneDest, { recursive: true });
-
-      // Copiar contenido de standalone
-      const nextDir = findDirectory(standalonePath, '.next');
-      if (nextDir) {
-        const parentDir = path.dirname(nextDir);
-        copyDirectory(parentDir, standaloneDest);
-      } else {
-        copyDirectory(standalonePath, standaloneDest);
-      }
-
-      // Copiar .next/static
-      const staticPath = path.join(resolvedProjectPath, '.next', 'static');
-      if (fs.existsSync(staticPath)) {
-        const staticDest = path.join(standaloneDest, '.next', 'static');
-        fs.mkdirSync(staticDest, { recursive: true });
-        copyDirectory(staticPath, staticDest);
-      }
-
-      // Copiar public
-      const publicPath = path.join(resolvedProjectPath, 'public');
-      if (fs.existsSync(publicPath)) {
-        const publicDest = path.join(standaloneDest, 'public');
-        fs.mkdirSync(publicDest, { recursive: true });
-        copyDirectory(publicPath, publicDest);
-      }
+      fs.mkdirSync(resolvedDestFolder, { recursive: true });
 
-      // Verificar server.js
-      const serverJsPath = path.join(standaloneDest, 'server.js');
-      if (!fs.existsSync(serverJsPath)) {
-        copySpinner.fail('server.js not found in standalone');
-        process.exit(1);
-      }
-
-      copySpinner.succeed('Files copied successfully');
-
-      // Leer y procesar archivo .env si existe
-      let nextPublicEnvVars: string[] = [];
       let runtimeEnvVars: string[] = [];
+      let nextPublicEnvVars: string[] = [];
+      let dockerfileContent: string;
+      
+      // Determinar ruta del archivo .env (común para ambos tipos de proyecto)
       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');
+
+      if (projectType === 'nextjs') {
+        // ========== LÓGICA PARA NEXT.JS ==========
         
-        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();
+        // Paso 1: Build del proyecto si es necesario
+        if (!options.skipBuild) {
+          const buildSpinner = ora('Building Next.js application...').start();
+          try {
+            execSync('npm run build', { 
+              cwd: resolvedProjectPath, 
+              stdio: 'pipe' 
+            });
+            buildSpinner.succeed('Build completed successfully');
+          } catch (error) {
+            buildSpinner.fail('Build failed');
+            console.error(chalk.red('Error during build. Make sure you have "output: standalone" in next.config.ts'));
+            process.exit(1);
+          }
+        }
+
+        // Verificar que existe .next/standalone
+        const standalonePath = path.join(resolvedProjectPath, '.next', 'standalone');
+        if (!fs.existsSync(standalonePath)) {
+          console.error(chalk.red(`❌ Error: No se encontró .next/standalone`));
+          console.error(chalk.yellow('Asegúrate de tener "output: standalone" en next.config.ts y ejecutar "npm run build"'));
+          process.exit(1);
+        }
+
+        // Paso 2: Preparar directorio destino
+        const standaloneDest = path.join(resolvedDestFolder, 'standalone');
+        
+        const copySpinner = ora('Copying standalone files...').start();
+        fs.mkdirSync(standaloneDest, { recursive: true });
+
+        // Copiar contenido de standalone
+        const nextDir = findDirectory(standalonePath, '.next');
+        if (nextDir) {
+          const parentDir = path.dirname(nextDir);
+          copyDirectory(parentDir, standaloneDest);
+        } else {
+          copyDirectory(standalonePath, standaloneDest);
+        }
+
+        // Copiar .next/static
+        const staticPath = path.join(resolvedProjectPath, '.next', 'static');
+        if (fs.existsSync(staticPath)) {
+          const staticDest = path.join(standaloneDest, '.next', 'static');
+          fs.mkdirSync(staticDest, { recursive: true });
+          copyDirectory(staticPath, staticDest);
+        }
+
+        // Copiar public
+        const publicPath = path.join(resolvedProjectPath, 'public');
+        if (fs.existsSync(publicPath)) {
+          const publicDest = path.join(standaloneDest, 'public');
+          fs.mkdirSync(publicDest, { recursive: true });
+          copyDirectory(publicPath, publicDest);
+        }
+
+        // Verificar server.js
+        const serverJsPath = path.join(standaloneDest, 'server.js');
+        if (!fs.existsSync(serverJsPath)) {
+          copySpinner.fail('server.js not found in standalone');
+          process.exit(1);
+        }
+
+        copySpinner.succeed('Files copied successfully');
+
+        // Leer y procesar archivo .env si existe
+        // (envFilePath ya está definido arriba)
+        if (fs.existsSync(envFilePath)) {
+          const envContent = fs.readFileSync(envFilePath, 'utf-8');
+          const envLines = envContent.split('\n');
           
-          if (key.startsWith('NEXT_PUBLIC_')) {
-            nextPublicEnvVars.push(`${key}=${value}`);
-          } else {
-            runtimeEnvVars.push(`${key}=${value}`);
+          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
+        // 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');
+        
+        dockerfileContent = `FROM node:20-alpine
 WORKDIR /app
 
 ENV NODE_ENV=production
@@ -189,22 +299,257 @@ EXPOSE 3000
 # Arrancamos directamente con Node
 CMD ["node", "server.js"]
 `;
+
+      } else {
+        // ========== LÓGICA PARA EXPRESS ==========
+        
+        // Paso 1: Instalar dependencias de producción si es necesario
+        if (!options.skipBuild) {
+          const installSpinner = ora('Installing production dependencies...').start();
+          try {
+            // Verificar si node_modules existe
+            const nodeModulesPath = path.join(resolvedProjectPath, 'node_modules');
+            if (!fs.existsSync(nodeModulesPath)) {
+              execSync('npm install --production', { 
+                cwd: resolvedProjectPath, 
+                stdio: 'pipe' 
+              });
+            }
+            installSpinner.succeed('Dependencies ready');
+          } catch (error) {
+            installSpinner.fail('Failed to install dependencies');
+            console.error(chalk.red('Error installing dependencies'));
+            process.exit(1);
+          }
+        }
+
+        // Paso 2: Copiar archivos del proyecto (sin node_modules, Docker lo instalará)
+        const copySpinner = ora('Copying project files...').start();
+        
+        // Copiar todos los archivos excepto los que están en .dockerignore
+        const ignorePatterns = [
+          'node_modules',
+          '.git',
+          '.next',
+          'dist',
+          'build',
+          '.env',
+          '.env.local',
+          '.env.*.local',
+          'npm-debug.log*',
+          'yarn-debug.log*',
+          'yarn-error.log*',
+          '.DS_Store',
+          'coverage',
+          '.nyc_output',
+        ];
+
+        function shouldIgnore(filePath: string, basePath: string): boolean {
+          const relativePath = path.relative(basePath, filePath);
+          return ignorePatterns.some(pattern => {
+            if (relativePath.includes(pattern)) return true;
+            // Verificar si es un archivo que empieza con el patrón
+            const parts = relativePath.split(path.sep);
+            return parts.some(part => part === pattern || part.startsWith(pattern));
+          });
+        }
+
+        function copyProjectFiles(src: string, dest: string): void {
+          if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+          }
+          
+          const entries = fs.readdirSync(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            
+            // Ignorar archivos y directorios según los patrones
+            if (shouldIgnore(srcPath, resolvedProjectPath)) {
+              continue;
+            }
+            
+            try {
+              const stats = fs.lstatSync(srcPath);
+              
+              if (stats.isDirectory()) {
+                copyProjectFiles(srcPath, destPath);
+              } else if (stats.isFile()) {
+                fs.copyFileSync(srcPath, destPath);
+              }
+            } catch (error: any) {
+              // Ignorar errores al copiar archivos especiales
+              if (error.code === 'ENOTSUP' || error.code === 'EINVAL' || error.code === 'EOPNOTSUPP') {
+                continue;
+              }
+              throw error;
+            }
+          }
+        }
+
+        // Copiar archivos del proyecto
+        copyProjectFiles(resolvedProjectPath, resolvedDestFolder);
+
+        // Verificar que existe package.json en el destino
+        const destPackageJson = path.join(resolvedDestFolder, 'package.json');
+        if (!fs.existsSync(destPackageJson)) {
+          copySpinner.fail('package.json not found');
+          console.error(chalk.red('❌ Error: package.json is required for Express application'));
+          process.exit(1);
+        }
+
+        // Verificar que existe un archivo principal
+        const packageJson = JSON.parse(fs.readFileSync(destPackageJson, 'utf-8'));
+        const mainFile = packageJson.main || 'index.js';
+        const mainFilePath = path.join(resolvedDestFolder, mainFile);
+        
+        if (!fs.existsSync(mainFilePath)) {
+          // Buscar otros archivos comunes
+          const commonFiles = ['index.js', 'server.js', 'app.js', 'main.js'];
+          let found = false;
+          for (const file of commonFiles) {
+            if (fs.existsSync(path.join(resolvedDestFolder, file))) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            copySpinner.fail(`Main entry file not found: ${mainFile}`);
+            console.error(chalk.red(`❌ Error: Could not find main entry file (${mainFile}) for Express application`));
+            process.exit(1);
+          }
+        }
+
+        copySpinner.succeed('Files copied successfully');
+
+        // Leer y procesar archivo .env si existe
+        // (envFilePath ya está definido arriba)
+        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();
+            
+            runtimeEnvVars.push(`${key}=${value}`);
+          }
+        }
+
+        // Crear Dockerfile optimizado para Express
+        // (destPackageJson, packageJson y mainFile ya están declaradas arriba)
+        const startScript = packageJson.scripts?.start;
+        
+        // Determinar el comando de inicio
+        let startCmd: string[];
+        if (startScript) {
+          // Si hay un script start, usarlo
+          startCmd = startScript.split(' ');
+        } else {
+          // Si no, usar node con el archivo principal
+          startCmd = ['node', mainFile];
+        }
+        
+        dockerfileContent = `FROM node:20-alpine
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV PORT=3000
+
+# Copiar package files primero para aprovechar cache de Docker
+COPY package*.json ./
+
+# Instalar solo dependencias de producción
+RUN npm ci --only=production && npm cache clean --force
+
+# Copiar código fuente
+COPY . .
+
+# Exponemos el puerto
+EXPOSE 3000
+
+# Comando de inicio
+CMD ${JSON.stringify(startCmd)}
+`;
+      }
+
+      // Paso 3: Crear Dockerfile
+      const dockerfileSpinner = ora('Creating Dockerfile...').start();
+      const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
       fs.writeFileSync(dockerfilePath, dockerfileContent);
+      
+      dockerfileSpinner.succeed('Dockerfile created');
+      
+      // Mostrar contenido del Dockerfile
+      if (projectType === 'nextjs' && 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 for ${projectType} application`));
+      }
 
       // 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);
       }
 
@@ -243,6 +588,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'
@@ -250,8 +603,9 @@ 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:`));
@@ -260,6 +614,11 @@ CMD ["node", "server.js"]
         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');
@@ -272,8 +631,13 @@ CMD ["node", "server.js"]
 
       // 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: shouldPush ? imageName : imageLatest,
+          imageName: deployImageName,
           serviceName: options.serviceName || projectName,
           domainBase: options.domainBase,
           port: options.port,
@@ -288,6 +652,115 @@ CMD ["node", "server.js"]
     }
   });
 
+// 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;
@@ -300,13 +773,19 @@ async function deployToRemoteServer(config: {
   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'));
+    // 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);
     }
 
@@ -321,44 +800,79 @@ async function deployToRemoteServer(config: {
       }
     }
 
-    // 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 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 for existing container...').start();
+    const stopSpinner = ora('Checking and removing existing container...').start();
     try {
-      execSync(`docker ps -a --filter name=^${fullDomain}$ --format "{{.Names}}"`, {
-        env: dockerEnv,
+      // 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();
       
-      // Si existe, detenerlo y eliminarlo
-      try {
-        execSync(`docker stop ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
-      } catch {
-        // Container might not be running
+      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 {
-        execSync(`docker rm ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
-        stopSpinner.succeed('Existing container removed');
+        const forceRmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+        execSync(forceRmCmd, { stdio: 'pipe', shell: '/bin/sh' });
+        stopSpinner.succeed('Existing container removed (forced)');
       } catch {
-        stopSpinner.warn('No existing container found');
+        // Si falla, asumir que no existe y continuar
+        stopSpinner.succeed('No existing container found');
       }
-    } catch (error) {
-      stopSpinner.warn('Could not check for existing container');
     }
 
     // Preparar opciones de entorno
@@ -376,12 +890,12 @@ async function deployToRemoteServer(config: {
       });
     }
 
-    // Construir comando docker run
-    const dockerRunCmd = `docker run -d \\
+    // Construir comando docker run con parámetros TLS
+    const dockerRunCmd = `${dockerTlsPrefix} run -d \\
   --name ${fullDomain} \\
   --network academy-network \\
   --restart unless-stopped \\
-  ${envOpts.join(' \\\n  ')} \\
+  ${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 \\
@@ -389,11 +903,30 @@ async function deployToRemoteServer(config: {
   -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, {
-        env: dockerEnv,
         stdio: 'inherit',
         shell: '/bin/sh',
       });
@@ -401,12 +934,17 @@ async function deployToRemoteServer(config: {
       runSpinner.succeed('Container deployed successfully');
 
       console.log(chalk.green('\n✅ Remote deployment completed successfully!'));
-      console.log(chalk.gray('Deployment details:'));
+      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'));