codecrypto-cli 1.0.7 → 1.0.9

package/dist/commands/deploy.js

@@ -43,12 +43,20 @@ const ora_1 = __importDefault(require("ora"));
 const child_process_1 = require("child_process");
 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')
     .argument('[dest-folder]', 'Destination folder for Docker build context', './docker-build')
     .option('--skip-build', 'Skip npm run build (assume already built)', false)
-    .option('--no-push', 'Build image but do not push to registry', false)
+    .option('--no-push', 'Build image but do not push to registry')
+    .option('--deploy', 'Deploy to remote server after building', false)
+    .option('--service-name <name>', 'Service name for remote deployment')
+    .option('--env-file <path>', 'Path to .env file with environment variables')
+    .option('--port <port>', 'Application port', '3000')
+    .option('--domain-base <domain>', 'Domain base for deployment', 'proyectos.codecrypto.academy')
+    .option('--image-version <version>', 'Image version/tag to deploy (overrides package.json version)')
+    .option('--skip-git-check', 'Skip Git repository status check', false)
     .action(async (projectPath, destFolder, options) => {
     console.log(chalk_1.default.blue('\n🐳 CodeCrypto Docker Deployment\n'));
     try {
@@ -64,19 +72,100 @@ 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}`;
         const imageLatest = `${imageBase}:latest`;
+        // Determinar si hacer push
+        // En Commander.js, cuando defines .option('--no-push', ...) sin tercer parámetro:
+        // - Por defecto (sin flags): options.push = true (hace push)
+        // - Con --no-push: options.push = false (no hace push)
+        const shouldPush = options.push !== false;
         console.log(chalk_1.default.gray('Deployment Configuration:'));
         console.log(chalk_1.default.white(`  Project: ${chalk_1.default.green(projectName)}`));
         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: ${options.push ? chalk_1.default.green('Yes') : chalk_1.default.yellow('No')}\n`));
+        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();
@@ -138,14 +227,57 @@ exports.deployCommand = new commander_1.Command('deploy')
             process.exit(1);
         }
         copySpinner.succeed('Files copied successfully');
-        // Paso 3: Crear Dockerfile
+        // Leer y procesar archivo .env si existe
+        let nextPublicEnvVars = [];
+        let runtimeEnvVars = [];
+        const envFilePath = options.envFile
+            ? path.resolve(options.envFile)
+            : path.join(resolvedProjectPath, '.env');
+        if (fs.existsSync(envFilePath)) {
+            const envContent = fs.readFileSync(envFilePath, 'utf-8');
+            const envLines = envContent.split('\n');
+            for (const line of envLines) {
+                const trimmed = line.trim();
+                // Ignorar comentarios y líneas vacías
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const equalIndex = trimmed.indexOf('=');
+                if (equalIndex === -1)
+                    continue;
+                const key = trimmed.substring(0, equalIndex).trim();
+                const value = trimmed.substring(equalIndex + 1).trim();
+                if (key.startsWith('NEXT_PUBLIC_')) {
+                    nextPublicEnvVars.push(`${key}=${value}`);
+                }
+                else {
+                    runtimeEnvVars.push(`${key}=${value}`);
+                }
+            }
+        }
+        // Paso 3: Crear Dockerfile con variables NEXT_PUBLIC_*
+        const dockerfileSpinner = (0, ora_1.default)('Creating Dockerfile...').start();
         const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
+        // Construir ARG y ENV para NEXT_PUBLIC_*
+        const buildArgs = nextPublicEnvVars.map(env => {
+            const [key, ...valueParts] = env.split('=');
+            const value = valueParts.join('=');
+            return `ARG ${key}=${value}`;
+        }).join('\n');
+        const buildEnvs = nextPublicEnvVars.map(env => {
+            const [key, ...valueParts] = env.split('=');
+            const value = valueParts.join('=');
+            return `ENV ${key}=${value}`;
+        }).join('\n');
         const dockerfileContent = `FROM node:20-alpine
 WORKDIR /app
 
 ENV NODE_ENV=production
 ENV PORT=3000
 
+${buildArgs}
+
+${buildEnvs}
+
 # Copiamos el contenido de standalone
 COPY standalone/ .
 
@@ -156,28 +288,102 @@ EXPOSE 3000
 CMD ["node", "server.js"]
 `;
         fs.writeFileSync(dockerfilePath, dockerfileContent);
+        dockerfileSpinner.succeed('Dockerfile created');
+        // Mostrar contenido del Dockerfile si hay variables NEXT_PUBLIC_*
+        if (nextPublicEnvVars.length > 0) {
+            console.log(chalk_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 (no NEXT_PUBLIC_* variables found)'));
+        }
         // 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
+        if (shouldPush) {
+            const authSpinner = (0, ora_1.default)('Verifying Docker authentication...').start();
+            try {
+                // Verificar si hay credenciales de Docker configuradas
+                (0, child_process_1.execSync)('docker info', { stdio: 'pipe' });
+                // Intentar verificar login en Docker Hub
+                try {
+                    (0, child_process_1.execSync)('docker pull hello-world:latest', { stdio: 'pipe' });
+                    authSpinner.succeed('Docker authentication verified');
+                }
+                catch {
+                    // Si no puede hacer pull, verificar al menos que docker está funcionando
+                    authSpinner.warn('Could not verify Docker Hub authentication. Make sure you are logged in with: docker login');
+                }
+            }
+            catch (error) {
+                authSpinner.fail('Docker authentication failed');
+                console.error(chalk_1.default.yellow('\n⚠️  Warning: Docker authentication may be required for push'));
+                console.error(chalk_1.default.yellow('   Run: docker login'));
+                console.error(chalk_1.default.yellow('   Or use --no-push to skip pushing to registry\n'));
+            }
+        }
         // Paso 5: Construir y hacer push
         const buildDockerSpinner = (0, ora_1.default)('Building Docker image for multiple platforms...').start();
         try {
-            const tags = options.push
+            const tags = shouldPush
                 ? [`--tag ${imageName}`, `--tag ${imageLatest}`, '--push']
                 : [`--tag ${imageName}`, `--tag ${imageLatest}`, '--load'];
             const buildCommand = `docker buildx build \
@@ -185,37 +391,344 @@ 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:`));
             console.log(chalk_1.default.white(`    - ${chalk_1.default.cyan(imageName)}`));
             console.log(chalk_1.default.white(`    - ${chalk_1.default.cyan(imageLatest)}`));
-            if (options.push) {
+            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) {
             buildDockerSpinner.fail('Docker build failed');
             console.error(chalk_1.default.red('\n❌ Error building Docker image'));
-            if (options.push) {
+            if (shouldPush) {
                 console.error(chalk_1.default.yellow('Make sure you are authenticated: docker login'));
             }
             process.exit(1);
         }
+        // Paso 6: Desplegar en servidor remoto si se solicita
+        if (options.deploy) {
+            // Para despliegue, usar la versión especificada o la del package.json
+            const deployImageName = options.imageVersion
+                ? `${imageBase}:${options.imageVersion}`
+                : (shouldPush ? imageName : imageLatest);
+            await deployToRemoteServer({
+                imageName: deployImageName,
+                serviceName: options.serviceName || projectName,
+                domainBase: options.domainBase,
+                port: options.port,
+                envVars: runtimeEnvVars,
+                envFilePath: runtimeEnvVars.length > 0 ? envFilePath : undefined,
+            });
+        }
     }
     catch (error) {
         console.error(chalk_1.default.red(`\n❌ Error: ${error.message}`));
         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 {
+        // 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
+        const requiredCerts = ['ca.pem', 'cert.pem', 'key.pem'];
+        for (const cert of requiredCerts) {
+            const certPath = path.join(dockerCertPath, cert);
+            if (!fs.existsSync(certPath)) {
+                deploySpinner.fail(`Certificate ${cert} not found`);
+                console.error(chalk_1.default.red(`❌ Error: Certificate ${cert} not found at ${certPath}`));
+                process.exit(1);
+            }
+        }
+        // Construir prefijo de comando Docker con parámetros TLS
+        const dockerHost = 'tcp://server.codecrypto.academy:2376';
+        const dockerTlsPrefix = `docker -H ${dockerHost} \\
+  --tlsverify \\
+  --tlscacert="${path.join(dockerCertPath, 'ca.pem')}" \\
+  --tlscert="${path.join(dockerCertPath, 'cert.pem')}" \\
+  --tlskey="${path.join(dockerCertPath, 'key.pem')}"`;
+        console.log(chalk_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 and removing existing container...').start();
+        try {
+            // 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',
+                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);
+                }
+            }
+            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 {
+                const forceRmCmd = `${dockerTlsPrefix} rm -f ${fullDomain}`;
+                (0, child_process_1.execSync)(forceRmCmd, { stdio: 'pipe', shell: '/bin/sh' });
+                stopSpinner.succeed('Existing container removed (forced)');
+            }
+            catch {
+                // Si falla, asumir que no existe y continuar
+                stopSpinner.succeed('No existing container found');
+            }
+        }
+        // Preparar opciones de entorno
+        // Para despliegue remoto, pasamos las variables directamente con -e
+        // ya que --env-file requiere que el archivo esté en el servidor remoto
+        const envOpts = [];
+        if (config.envVars.length > 0) {
+            config.envVars.forEach(env => {
+                // Escapar comillas y caracteres especiales en el valor
+                const [key, ...valueParts] = env.split('=');
+                const value = valueParts.join('=');
+                // Escapar comillas dobles en el valor
+                const escapedValue = value.replace(/"/g, '\\"');
+                envOpts.push(`-e "${key}=${escapedValue}"`);
+            });
+        }
+        // Construir comando docker run con parámetros TLS
+        const dockerRunCmd = `${dockerTlsPrefix} run -d \\
+  --name ${fullDomain} \\
+  --network academy-network \\
+  --restart unless-stopped \\
+  ${envOpts.length > 0 ? envOpts.join(' \\\n  ') + ' \\' : ''}
+  -l traefik.enable=true \\
+  -l "traefik.http.routers.${serviceName}-router.rule=Host(\\\`${fullDomain}\\\`)" \\
+  -l traefik.http.routers.${serviceName}-router.entrypoints=websecure \\
+  -l traefik.http.routers.${serviceName}-router.tls=true \\
+  -l traefik.http.services.${serviceName}-service.loadbalancer.server.port=${config.port} \\
+  ${config.imageName}`;
+        console.log(chalk_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, {
+                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('─'.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');
+            console.error(chalk_1.default.red('\n❌ Error deploying container to remote server'));
+            console.error(chalk_1.default.yellow('   Make sure:'));
+            console.error(chalk_1.default.yellow('   - The image is available on the remote server'));
+            console.error(chalk_1.default.yellow('   - You have push the image to Docker Hub (or use --no-push and ensure image exists)'));
+            console.error(chalk_1.default.yellow('   - The network "academy-network" exists on the remote server'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        deploySpinner.fail('Failed to configure remote deployment');
+        console.error(chalk_1.default.red(`\n❌ Error: ${error.message}`));
+        process.exit(1);
+    }
+}
 // Helper functions
 function findDirectory(root, name) {
     try {
@@ -245,11 +758,36 @@ function copyDirectory(src, dest) {
     for (const entry of entries) {
         const srcPath = path.join(src, entry.name);
         const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            copyDirectory(srcPath, destPath);
+        try {
+            // Obtener información detallada del archivo para detectar tipos especiales
+            const stats = fs.lstatSync(srcPath);
+            if (stats.isDirectory()) {
+                copyDirectory(srcPath, destPath);
+            }
+            else if (stats.isFile()) {
+                // Solo copiar archivos regulares
+                fs.copyFileSync(srcPath, destPath);
+            }
+            else if (stats.isSymbolicLink()) {
+                // Copiar symlinks preservando el target
+                const linkTarget = fs.readlinkSync(srcPath);
+                fs.symlinkSync(linkTarget, destPath);
+            }
+            else {
+                // Saltar sockets, FIFOs, y otros tipos especiales
+                // Estos no son necesarios para el build de Docker
+                continue;
+            }
         }
-        else {
-            fs.copyFileSync(srcPath, destPath);
+        catch (error) {
+            // Si hay un error al copiar (por ejemplo, socket), simplemente saltarlo
+            // Los sockets y otros archivos especiales no son necesarios para el build
+            if (error.code === 'ENOTSUP' || error.code === 'EINVAL' || error.code === 'EOPNOTSUPP') {
+                // Saltar silenciosamente sockets y otros archivos especiales
+                continue;
+            }
+            // Para otros errores, lanzar el error
+            throw error;
         }
     }
 }