codecrypto-cli 1.0.8 → 1.0.10

package/dist/commands/deploy.js

@@ -45,8 +45,8 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 exports.deployCommand = new commander_1.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')
@@ -55,6 +55,8 @@ exports.deployCommand = new commander_1.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, destFolder, options) => {
     console.log(chalk_1.default.blue('\n🐳 CodeCrypto Docker Deployment\n'));
     try {
@@ -70,9 +72,85 @@ exports.deployCommand = new commander_1.Command('deploy')
             console.error(chalk_1.default.red(`❌ Error: No se encontró package.json en el proyecto`));
             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 = (0, ora_1.default)('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 {
+                    (0, child_process_1.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 = (0, child_process_1.execSync)('git status --porcelain', {
+                            cwd: resolvedProjectPath,
+                            encoding: 'utf-8',
+                            stdio: 'pipe',
+                        }).trim();
+                        if (gitStatus) {
+                            gitCheckSpinner.fail('Uncommitted changes detected');
+                            console.error(chalk_1.default.red('\n❌ Error: Hay archivos pendientes de commit en el repositorio'));
+                            console.error(chalk_1.default.yellow('\n📋 Archivos modificados/sin commitear:'));
+                            console.log(chalk_1.default.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_1.default.yellow;
+                                if (status.includes('A'))
+                                    statusColor = chalk_1.default.green;
+                                else if (status.includes('D'))
+                                    statusColor = chalk_1.default.red;
+                                else if (status.includes('M'))
+                                    statusColor = chalk_1.default.yellow;
+                                console.log(chalk_1.default.gray(`  ${statusColor(status)} ${chalk_1.default.white(fileName)}`));
+                            });
+                            console.log(chalk_1.default.gray('─'.repeat(60)));
+                            console.error(chalk_1.default.yellow('\n💡 Por favor, haz commit de tus cambios antes de desplegar:'));
+                            console.error(chalk_1.default.cyan('   git add .'));
+                            console.error(chalk_1.default.cyan('   git commit -m "your message"'));
+                            console.error(chalk_1.default.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) {
+                        // 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_1.default.yellow(`   Warning: ${error.message}`));
+                        }
+                    }
+                }
+                else {
+                    gitCheckSpinner.succeed('Not a Git repository (skipping check)');
+                }
+            }
+            catch (error) {
+                gitCheckSpinner.warn('Git check failed, continuing...');
+            }
+        }
+        else {
+            console.log(chalk_1.default.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}`;
@@ -82,114 +160,145 @@ exports.deployCommand = new commander_1.Command('deploy')
         // - Por defecto (sin flags): options.push = true (hace push)
         // - 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 = null;
+        if (allDependencies.next || allDependencies['nextjs']) {
+            projectType = 'nextjs';
+        }
+        else if (allDependencies.express) {
+            projectType = 'express';
+        }
+        if (!projectType) {
+            console.error(chalk_1.default.red(`❌ Error: No se pudo detectar el tipo de proyecto`));
+            console.error(chalk_1.default.yellow('   El proyecto debe tener "next" o "express" en las dependencias del package.json'));
+            console.error(chalk_1.default.yellow('   Dependencias encontradas:'));
+            const depKeys = Object.keys(allDependencies).slice(0, 10);
+            depKeys.forEach(dep => {
+                console.error(chalk_1.default.gray(`     - ${dep}`));
+            });
+            if (Object.keys(allDependencies).length > 10) {
+                console.error(chalk_1.default.gray(`     ... y ${Object.keys(allDependencies).length - 10} más`));
+            }
+            process.exit(1);
+        }
         console.log(chalk_1.default.gray('Deployment Configuration:'));
         console.log(chalk_1.default.white(`  Project: ${chalk_1.default.green(projectName)}`));
+        console.log(chalk_1.default.white(`  Type: ${chalk_1.default.green(projectType)}`));
         console.log(chalk_1.default.white(`  Version: ${chalk_1.default.green(version)}`));
         console.log(chalk_1.default.white(`  Image: ${chalk_1.default.green(imageName)}`));
         console.log(chalk_1.default.white(`  Latest: ${chalk_1.default.green(imageLatest)}`));
         console.log(chalk_1.default.white(`  Push to Registry: ${shouldPush ? chalk_1.default.green('Yes') : chalk_1.default.yellow('No')}\n`));
-        // Paso 1: Build del proyecto si es necesario
-        if (!options.skipBuild) {
-            const buildSpinner = (0, ora_1.default)('Building Next.js application...').start();
-            try {
-                (0, child_process_1.execSync)('npm run build', {
-                    cwd: resolvedProjectPath,
-                    stdio: 'pipe'
-                });
-                buildSpinner.succeed('Build completed successfully');
-            }
-            catch (error) {
-                buildSpinner.fail('Build failed');
-                console.error(chalk_1.default.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_1.default.red(`❌ Error: No se encontró .next/standalone`));
-            console.error(chalk_1.default.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 = (0, ora_1.default)('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);
-        }
-        // 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 = [];
+        fs.mkdirSync(resolvedDestFolder, { recursive: true });
         let runtimeEnvVars = [];
+        let nextPublicEnvVars = [];
+        let dockerfileContent;
+        // 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');
-            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}`);
+        if (projectType === 'nextjs') {
+            // ========== LÓGICA PARA NEXT.JS ==========
+            // Paso 1: Build del proyecto si es necesario
+            if (!options.skipBuild) {
+                const buildSpinner = (0, ora_1.default)('Building Next.js application...').start();
+                try {
+                    (0, child_process_1.execSync)('npm run build', {
+                        cwd: resolvedProjectPath,
+                        stdio: 'pipe'
+                    });
+                    buildSpinner.succeed('Build completed successfully');
                 }
-                else {
-                    runtimeEnvVars.push(`${key}=${value}`);
+                catch (error) {
+                    buildSpinner.fail('Build failed');
+                    console.error(chalk_1.default.red('Error during build. Make sure you have "output: standalone" in next.config.ts'));
+                    process.exit(1);
                 }
             }
-        }
-        // 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
+            // Verificar que existe .next/standalone
+            const standalonePath = path.join(resolvedProjectPath, '.next', 'standalone');
+            if (!fs.existsSync(standalonePath)) {
+                console.error(chalk_1.default.red(`❌ Error: No se encontró .next/standalone`));
+                console.error(chalk_1.default.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 = (0, ora_1.default)('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');
+                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}`);
+                    }
+                }
+            }
+            // 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
@@ -208,23 +317,243 @@ 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 = (0, ora_1.default)('Installing production dependencies...').start();
+                try {
+                    // Verificar si node_modules existe
+                    const nodeModulesPath = path.join(resolvedProjectPath, 'node_modules');
+                    if (!fs.existsSync(nodeModulesPath)) {
+                        (0, child_process_1.execSync)('npm install --production', {
+                            cwd: resolvedProjectPath,
+                            stdio: 'pipe'
+                        });
+                    }
+                    installSpinner.succeed('Dependencies ready');
+                }
+                catch (error) {
+                    installSpinner.fail('Failed to install dependencies');
+                    console.error(chalk_1.default.red('Error installing dependencies'));
+                    process.exit(1);
+                }
+            }
+            // Paso 2: Copiar archivos del proyecto (sin node_modules, Docker lo instalará)
+            const copySpinner = (0, ora_1.default)('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, basePath) {
+                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, dest) {
+                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) {
+                        // 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_1.default.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_1.default.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;
+            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 = (0, ora_1.default)('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_1.default.gray('\n📄 Dockerfile content:'));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.white(dockerfileContent));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.gray(`\n  NEXT_PUBLIC_* variables: ${chalk_1.default.cyan(nextPublicEnvVars.length)}`));
+            nextPublicEnvVars.forEach(env => {
+                const [key] = env.split('=');
+                console.log(chalk_1.default.gray(`    - ${chalk_1.default.cyan(key)}`));
+            });
+        }
+        else {
+            console.log(chalk_1.default.gray(`\n📄 Dockerfile created for ${projectType} application`));
+        }
         // Paso 4: Verificar/crear builder multi-plataforma
         const builderSpinner = (0, ora_1.default)('Setting up multi-platform builder...').start();
         try {
-            const builders = (0, child_process_1.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 = (0, child_process_1.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_1.default.yellow('⚠️  Warning: Some builders have connection issues, continuing...'));
+            }
             const builderName = 'multiarch-builder';
-            if (!builders.includes(builderName)) {
-                (0, child_process_1.execSync)(`docker buildx create --name ${builderName} --use --bootstrap`, { stdio: 'pipe' });
+            if (!buildersOutput.includes(builderName)) {
+                builderSpinner.text = 'Creating multi-platform builder...';
+                (0, child_process_1.execSync)(`docker buildx create --name ${builderName} --use --bootstrap`, {
+                    stdio: 'pipe',
+                    // No heredar stderr para evitar errores de otros builders
+                });
             }
             else {
-                (0, child_process_1.execSync)(`docker buildx use ${builderName}`, { stdio: 'pipe' });
+                builderSpinner.text = 'Using existing multi-platform builder...';
+                try {
+                    (0, child_process_1.execSync)(`docker buildx use ${builderName}`, { stdio: 'pipe' });
+                }
+                catch (error) {
+                    // Si falla, intentar crearlo de nuevo
+                    builderSpinner.text = 'Recreating multi-platform builder...';
+                    try {
+                        (0, child_process_1.execSync)(`docker buildx rm ${builderName}`, { stdio: 'pipe' });
+                    }
+                    catch {
+                        // Ignorar si no existe
+                    }
+                    (0, child_process_1.execSync)(`docker buildx create --name ${builderName} --use --bootstrap`, { stdio: 'pipe' });
+                }
             }
             builderSpinner.succeed('Builder ready');
         }
         catch (error) {
             builderSpinner.fail('Failed to setup builder');
             console.error(chalk_1.default.red('Error setting up Docker buildx builder'));
+            console.error(chalk_1.default.yellow('💡 Tip: If you have problematic builders configured, you can remove them with:'));
+            console.error(chalk_1.default.cyan('   docker buildx rm <builder-name>'));
+            console.error(chalk_1.default.yellow('   Or inspect them with: docker buildx inspect <builder-name>'));
             process.exit(1);
         }
         // Verificar autenticación de Docker si se va a hacer push
@@ -261,13 +590,21 @@ CMD ["node", "server.js"]
           ${tags.join(' \\\n          ')} \
           --progress=plain \
           .`;
+            console.log(chalk_1.default.gray('\n🔨 Build command:'));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.cyan(buildCommand));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.gray(`\n  Working directory: ${chalk_1.default.cyan(resolvedDestFolder)}`));
+            console.log(chalk_1.default.gray(`  Platforms: ${chalk_1.default.cyan('linux/amd64, linux/arm64')}`));
+            console.log(chalk_1.default.gray(`  Push to registry: ${shouldPush ? chalk_1.default.green('Yes') : chalk_1.default.yellow('No')}\n`));
             (0, child_process_1.execSync)(buildCommand, {
                 cwd: resolvedDestFolder,
                 stdio: 'inherit'
             });
             buildDockerSpinner.succeed('Docker image built successfully');
-            console.log(chalk_1.default.green('\n✅ Deployment completed successfully!'));
-            console.log(chalk_1.default.gray('Image details:'));
+            console.log(chalk_1.default.green('\n✅ Image build and push completed successfully!'));
+            console.log(chalk_1.default.gray('📦 Image details:'));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
             console.log(chalk_1.default.white(`  Platforms: ${chalk_1.default.cyan('linux/amd64, linux/arm64')}`));
             console.log(chalk_1.default.white(`  Version: ${chalk_1.default.cyan(version)}`));
             console.log(chalk_1.default.white(`  Tags:`));
@@ -276,6 +613,12 @@ CMD ["node", "server.js"]
             if (shouldPush) {
                 console.log(chalk_1.default.white(`  Registry: ${chalk_1.default.cyan('Docker Hub')}`));
                 console.log(chalk_1.default.white(`  URL: ${chalk_1.default.cyan(`https://hub.docker.com/r/${imageBase}`)}`));
+                console.log(chalk_1.default.gray('─'.repeat(60)));
+                console.log(chalk_1.default.green(`\n✅ Image pushed to Docker Hub successfully!`));
+            }
+            else {
+                console.log(chalk_1.default.gray('─'.repeat(60)));
+                console.log(chalk_1.default.yellow(`\n⚠️  Image built locally (not pushed to registry)`));
             }
         }
         catch (error) {
@@ -288,8 +631,12 @@ 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,
@@ -303,16 +650,117 @@ CMD ["node", "server.js"]
         process.exit(1);
     }
 });
+// Función para leer certificados Docker desde token.json
+function loadDockerCertificatesFromToken() {
+    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;
+    try {
+        tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf-8'));
+    }
+    catch (error) {
+        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 = {};
+    // Lista de keys encontradas para debugging
+    const foundKeys = [];
+    // 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) {
     const deploySpinner = (0, ora_1.default)('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_1.default.red(`❌ Error: Docker certificates not found at ${dockerCertPath}`));
-            console.error(chalk_1.default.yellow('   Make sure you have the certificates in ~/.codecrypto/docker-client'));
+        // Cargar certificados desde token.json
+        let dockerCertPath;
+        try {
+            const certs = loadDockerCertificatesFromToken();
+            dockerCertPath = certs.certPath;
+            deploySpinner.succeed('Docker certificates loaded from token.json');
+        }
+        catch (error) {
+            deploySpinner.fail('Failed to load Docker certificates');
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            console.error(chalk_1.default.yellow('\n💡 To fix this issue:'));
+            console.error(chalk_1.default.yellow('   1. Run: codecrypto auth --force'));
+            console.error(chalk_1.default.yellow('   2. This will refresh your token with the latest adminGlobals'));
+            console.error(chalk_1.default.yellow('   3. Then try the deploy command again\n'));
             process.exit(1);
         }
         // Verificar que existen los certificados necesarios
@@ -325,43 +773,80 @@ async function deployToRemoteServer(config) {
                 process.exit(1);
             }
         }
-        // Configurar variables de entorno para Docker
-        const dockerEnv = {
-            ...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_1.default.gray('\n🔌 Remote Docker configuration:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.white(`  Docker Host: ${chalk_1.default.cyan(dockerHost)}`));
+        console.log(chalk_1.default.white(`  TLS Verify: ${chalk_1.default.cyan('enabled')}`));
+        console.log(chalk_1.default.white(`  Certificates Source: ${chalk_1.default.cyan('token.json (adminGlobals)')}`));
+        console.log(chalk_1.default.white(`  Certificates Path: ${chalk_1.default.cyan(dockerCertPath)}`));
+        console.log(chalk_1.default.gray('  Certificates loaded:'));
+        requiredCerts.forEach(cert => {
+            const certPath = path.join(dockerCertPath, cert);
+            const exists = fs.existsSync(certPath);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${chalk_1.default.cyan(cert)}`));
+        });
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.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 = (0, ora_1.default)('Checking for existing container...').start();
+        const stopSpinner = (0, ora_1.default)('Checking and removing existing container...').start();
         try {
-            (0, child_process_1.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 = (0, child_process_1.execSync)(checkCmd, {
                 stdio: 'pipe',
                 encoding: 'utf-8',
-            });
-            // Si existe, detenerlo y eliminarlo
-            try {
-                (0, child_process_1.execSync)(`docker stop ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
+                shell: '/bin/sh',
+            }).trim();
+            if (existingContainer === fullDomain) {
+                // Contenedor existe, detenerlo primero (si está corriendo)
+                try {
+                    const stopCmd = `${dockerTlsPrefix} stop ${fullDomain}`;
+                    (0, child_process_1.execSync)(stopCmd, { stdio: 'pipe', shell: '/bin/sh' });
+                    console.log(chalk_1.default.gray(`  ✓ Container ${fullDomain} stopped`));
+                }
+                catch (error) {
+                    // Container might not be running, that's okay
+                    console.log(chalk_1.default.gray(`  ℹ Container ${fullDomain} was not running`));
+                }
+                // Eliminar el contenedor
+                try {
+                    const rmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+                    (0, child_process_1.execSync)(rmCmd, { stdio: 'pipe', shell: '/bin/sh' });
+                    stopSpinner.succeed(`Existing container ${fullDomain} removed`);
+                }
+                catch (error) {
+                    stopSpinner.fail(`Failed to remove container ${fullDomain}`);
+                    console.error(chalk_1.default.red(`   Error: ${error.message}`));
+                    process.exit(1);
+                }
             }
-            catch {
-                // Container might not be running
+            else {
+                stopSpinner.succeed('No existing container found');
             }
+        }
+        catch (error) {
+            // Si el comando falla, puede ser que el contenedor no exista
+            // Intentar eliminarlo de todas formas con -f para forzar
             try {
-                (0, child_process_1.execSync)(`docker rm ${fullDomain}`, { env: dockerEnv, stdio: 'pipe' });
-                stopSpinner.succeed('Existing container removed');
+                const forceRmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+                (0, child_process_1.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
         // Para despliegue remoto, pasamos las variables directamente con -e
         // ya que --env-file requiere que el archivo esté en el servidor remoto
@@ -376,33 +861,56 @@ async function deployToRemoteServer(config) {
                 envOpts.push(`-e "${key}=${escapedValue}"`);
             });
         }
-        // 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 \\
   -l traefik.http.routers.${serviceName}-router.tls=true \\
   -l traefik.http.services.${serviceName}-service.loadbalancer.server.port=${config.port} \\
   ${config.imageName}`;
+        console.log(chalk_1.default.gray('\n🚀 Deployment command (executing on remote Docker):'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.cyan(dockerRunCmd));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.gray(`\n  Remote Docker: ${chalk_1.default.cyan(dockerHost)}`));
+        console.log(chalk_1.default.gray(`  TLS Certificates: ${chalk_1.default.cyan(dockerCertPath)}`));
+        console.log(chalk_1.default.gray(`  Service name: ${chalk_1.default.cyan(config.serviceName)}`));
+        console.log(chalk_1.default.gray(`  Full domain: ${chalk_1.default.cyan(fullDomain)}`));
+        console.log(chalk_1.default.gray(`  Image: ${chalk_1.default.cyan(config.imageName)}`));
+        console.log(chalk_1.default.gray(`  Port: ${chalk_1.default.cyan(config.port)}`));
+        console.log(chalk_1.default.gray(`  Environment variables: ${chalk_1.default.cyan(config.envVars.length)}`));
+        if (config.envVars.length > 0) {
+            config.envVars.forEach(env => {
+                const [key] = env.split('=');
+                console.log(chalk_1.default.gray(`    - ${chalk_1.default.cyan(key)}`));
+            });
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
         const runSpinner = (0, ora_1.default)('Deploying container to remote server...').start();
         try {
+            // Ejecutar comando docker con parámetros TLS directamente
             (0, child_process_1.execSync)(dockerRunCmd, {
-                env: dockerEnv,
                 stdio: 'inherit',
                 shell: '/bin/sh',
             });
             runSpinner.succeed('Container deployed successfully');
             console.log(chalk_1.default.green('\n✅ Remote deployment completed successfully!'));
-            console.log(chalk_1.default.gray('Deployment details:'));
+            console.log(chalk_1.default.gray('📋 Deployment details:'));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
             console.log(chalk_1.default.white(`  Service: ${chalk_1.default.cyan(config.serviceName)}`));
             console.log(chalk_1.default.white(`  Domain: ${chalk_1.default.cyan(fullDomain)}`));
             console.log(chalk_1.default.white(`  URL: ${chalk_1.default.cyan(`https://${fullDomain}`)}`));
             console.log(chalk_1.default.white(`  Image: ${chalk_1.default.cyan(config.imageName)}`));
             console.log(chalk_1.default.white(`  Port: ${chalk_1.default.cyan(config.port)}`));
+            console.log(chalk_1.default.white(`  Network: ${chalk_1.default.cyan('academy-network')}`));
+            console.log(chalk_1.default.white(`  Restart policy: ${chalk_1.default.cyan('unless-stopped')}`));
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.green(`\n🌐 Your application is now available at: ${chalk_1.default.cyan.underline(`https://${fullDomain}`)}`));
         }
         catch (error) {
             runSpinner.fail('Failed to deploy container');