codecrypto-cli 1.0.17 → 1.0.18

package/dist/commands/deploy-mcp.js

@@ -0,0 +1,858 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployMcpCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+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.deployMcpCommand = new commander_1.Command('deploy-mcp')
+    .description('Build and deploy Docker image for Next.js or Express application using a container')
+    .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')
+    .option('--deploy', 'Deploy to remote server after building (automatic when pushing)')
+    .option('--no-deploy', 'Skip deployment to remote server')
+    .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', '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)
+    .option('--container-image <image>', 'Docker image to use for the build container', 'node:20-alpine')
+    .action(async (projectPath, destFolder, options) => {
+    console.log(chalk_1.default.blue('\n🐳 CodeCrypto Docker Deployment (Container Mode)\n'));
+    try {
+        // Validar que el proyecto existe
+        const resolvedProjectPath = path.resolve(projectPath);
+        if (!fs.existsSync(resolvedProjectPath)) {
+            console.error(chalk_1.default.red(`❌ Error: El directorio del proyecto no existe: ${resolvedProjectPath}`));
+            process.exit(1);
+        }
+        // Verificar que es un proyecto válido
+        const packageJsonPath = path.join(resolvedProjectPath, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            console.error(chalk_1.default.red(`❌ Error: No se encontró package.json en el proyecto`));
+            process.exit(1);
+        }
+        // Leer versión del package.json o usar la versión especificada
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const version = options.imageVersion || packageJson.version || 'latest';
+        // Obtener el nombre del proyecto desde package.json.name
+        let projectName = packageJson.name || path.basename(resolvedProjectPath);
+        // Sanitizar el nombre para que sea válido para Docker
+        projectName = projectName.toLowerCase()
+            .replace(/^@[^/]+\//, '')
+            .replace(/[^a-z0-9._-]/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .replace(/-+/g, '-')
+            .replace(/\.+/g, '.')
+            .substring(0, 128);
+        if (!projectName) {
+            projectName = path.basename(resolvedProjectPath).toLowerCase().replace(/[^a-z0-9._-]/g, '-');
+        }
+        const imageBase = `jviejo/${projectName}`;
+        const imageName = `${imageBase}:${version}`;
+        const imageLatest = `${imageBase}:latest`;
+        // Determinar si hacer push
+        const shouldPush = options.push !== false;
+        // Detectar automáticamente el tipo de proyecto
+        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'));
+            process.exit(1);
+        }
+        // Determinar ruta del archivo .env
+        const envFilePath = options.envFile
+            ? path.resolve(options.envFile)
+            : path.join(resolvedProjectPath, '.env');
+        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')}`));
+        console.log(chalk_1.default.white(`  Container Mode: ${chalk_1.default.green('Enabled')}`));
+        console.log(chalk_1.default.white(`  Container Image: ${chalk_1.default.green(options.containerImage)}`));
+        if (fs.existsSync(envFilePath)) {
+            console.log(chalk_1.default.white(`  Env file: ${chalk_1.default.green(envFilePath)}`));
+        }
+        else {
+            console.log(chalk_1.default.white(`  Env file: ${chalk_1.default.yellow('Not found')} (${envFilePath})`));
+        }
+        console.log();
+        // Preparar directorio destino
+        const resolvedDestFolder = path.resolve(destFolder);
+        if (fs.existsSync(resolvedDestFolder)) {
+            fs.rmSync(resolvedDestFolder, { recursive: true, force: true });
+        }
+        fs.mkdirSync(resolvedDestFolder, { recursive: true });
+        // Crear script de deploy que se ejecutará dentro del contenedor
+        const deployScriptPath = path.join(resolvedDestFolder, 'deploy-script.sh');
+        const deployScript = `#!/bin/sh
+set -e
+
+echo "🚀 Starting deployment inside container..."
+
+# Variables del entorno
+PROJECT_PATH="/workspace/project"
+DEST_FOLDER="/workspace/dest"
+PROJECT_TYPE="${projectType}"
+SKIP_BUILD="${options.skipBuild ? 'true' : 'false'}"
+SHOULD_PUSH="${shouldPush ? 'true' : 'false'}"
+IMAGE_NAME="${imageName}"
+IMAGE_LATEST="${imageLatest}"
+PORT="${options.port}"
+
+cd "$PROJECT_PATH"
+
+# Validar Git si es necesario
+if [ "${options.skipGitCheck ? 'false' : 'true'}" = "true" ]; then
+  if git rev-parse --git-dir > /dev/null 2>&1; then
+    if [ -n "$(git status --porcelain)" ]; then
+      echo "❌ Error: Hay archivos pendientes de commit"
+      exit 1
+    fi
+  fi
+fi
+
+# Build del proyecto si es necesario
+if [ "$SKIP_BUILD" = "false" ]; then
+  if [ "$PROJECT_TYPE" = "nextjs" ]; then
+    echo "📦 Building Next.js application..."
+    npm run build
+    
+    # Verificar que existe .next/standalone
+    if [ ! -d ".next/standalone" ]; then
+      echo "❌ Error: No se encontró .next/standalone"
+      echo "Asegúrate de tener 'output: standalone' en next.config.ts"
+      exit 1
+    fi
+  else
+    echo "📦 Installing production dependencies..."
+    npm install --production
+  fi
+fi
+
+# Preparar directorio destino
+mkdir -p "$DEST_FOLDER"
+
+if [ "$PROJECT_TYPE" = "nextjs" ]; then
+  # Copiar standalone
+  mkdir -p "$DEST_FOLDER/standalone"
+  
+  # Buscar directorio .next en standalone
+  if [ -d ".next/standalone/.next" ]; then
+    cp -r .next/standalone/* "$DEST_FOLDER/standalone/"
+  else
+    # Si standalone contiene el .next directamente
+    NEXT_DIR=$(find .next/standalone -name ".next" -type d | head -1)
+    if [ -n "$NEXT_DIR" ]; then
+      PARENT_DIR=$(dirname "$NEXT_DIR")
+      cp -r "$PARENT_DIR"/* "$DEST_FOLDER/standalone/"
+    else
+      cp -r .next/standalone/* "$DEST_FOLDER/standalone/"
+    fi
+  fi
+  
+  # Copiar .next/static
+  if [ -d ".next/static" ]; then
+    mkdir -p "$DEST_FOLDER/standalone/.next/static"
+    cp -r .next/static/* "$DEST_FOLDER/standalone/.next/static/"
+  fi
+  
+  # Copiar public
+  if [ -d "public" ]; then
+    mkdir -p "$DEST_FOLDER/standalone/public"
+    cp -r public/* "$DEST_FOLDER/standalone/public/"
+  fi
+  
+  # Verificar server.js
+  if [ ! -f "$DEST_FOLDER/standalone/server.js" ]; then
+    echo "❌ Error: server.js not found in standalone"
+    exit 1
+  fi
+  
+  # Leer y procesar .env si existe
+  RUNTIME_ENV_VARS=""
+  NEXT_PUBLIC_ENV_VARS=""
+  
+  if [ -f ".env" ]; then
+    while IFS= read -r line || [ -n "$line" ]; do
+      trimmed=$(echo "$line" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+      if [ -z "$trimmed" ] || [ "$(echo "$trimmed" | cut -c1)" = "#" ]; then
+        continue
+      fi
+      
+      if echo "$trimmed" | grep -q "="; then
+        key=$(echo "$trimmed" | cut -d'=' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+        value=$(echo "$trimmed" | cut -d'=' -f2- | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+        
+        if echo "$key" | grep -q "^NEXT_PUBLIC_"; then
+          NEXT_PUBLIC_ENV_VARS="$NEXT_PUBLIC_ENV_VARS
+ARG $key=$value
+ENV $key=$value"
+        else
+          RUNTIME_ENV_VARS="$RUNTIME_ENV_VARS
+ENV $key=$value"
+        fi
+      fi
+    done < .env
+  fi
+  
+  # Crear Dockerfile
+  {
+    echo "FROM node:20-alpine"
+    echo "WORKDIR /app"
+    echo ""
+    echo "ENV NODE_ENV=production"
+    echo "ENV PORT=3000"
+    echo "$NEXT_PUBLIC_ENV_VARS"
+    echo ""
+    echo "# Copiamos el contenido de standalone"
+    echo "COPY standalone/ ."
+    echo ""
+    echo "# Exponemos el puerto para Traefik"
+    echo "EXPOSE 3000"
+    echo ""
+    echo "# Arrancamos directamente con Node"
+    echo 'CMD ["node", "server.js"]'
+  } > "$DEST_FOLDER/Dockerfile"
+
+else
+  # Express: copiar archivos del proyecto
+  echo "📋 Copying Express project files..."
+  
+  # Función para copiar archivos excluyendo ciertos patrones
+  copy_excluding() {
+    local src="$1"
+    local dest="$2"
+    
+    # Crear directorio destino
+    mkdir -p "$dest"
+    
+    # Copiar archivos y directorios, excluyendo los especificados
+    find "$src" -mindepth 1 -maxdepth 1 ! -name 'node_modules' ! -name '.git' ! -name '.next' \\
+      ! -name 'dist' ! -name 'build' ! -name '.env*' ! -name 'npm-debug.log*' \\
+      ! -name 'yarn-debug.log*' ! -name 'yarn-error.log*' ! -name '.DS_Store' \\
+      ! -name 'coverage' ! -name '.nyc_output' -exec cp -r {} "$dest/" \\;
+  }
+  
+  copy_excluding "$PROJECT_PATH" "$DEST_FOLDER"
+  
+  # Leer package.json para determinar comando de inicio
+  MAIN_FILE=\$(node -e "console.log(require('./package.json').main || 'index.js')")
+  START_SCRIPT=\$(node -e "const pkg=require('./package.json'); console.log(pkg.scripts?.start || '')")
+  
+  # Leer .env si existe
+  RUNTIME_ENV_VARS=""
+  if [ -f ".env" ]; then
+    while IFS= read -r line || [ -n "$line" ]; do
+      trimmed=$(echo "$line" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+      if [ -z "$trimmed" ] || [ "$(echo "$trimmed" | cut -c1)" = "#" ]; then
+        continue
+      fi
+      
+      if echo "$trimmed" | grep -q "="; then
+        key=$(echo "$trimmed" | cut -d'=' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+        value=$(echo "$trimmed" | cut -d'=' -f2- | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+        RUNTIME_ENV_VARS="$RUNTIME_ENV_VARS
+ENV $key=$value"
+      fi
+    done < .env
+  fi
+  
+  # Determinar comando de inicio
+  if [ -n "$START_SCRIPT" ]; then
+    START_CMD="npm start"
+  else
+    START_CMD="node $MAIN_FILE"
+  fi
+  
+  # Crear Dockerfile
+  {
+    echo "FROM node:20-alpine"
+    echo ""
+    echo "WORKDIR /app"
+    echo ""
+    echo "ENV NODE_ENV=production"
+    echo "ENV PORT=3000"
+    echo "$RUNTIME_ENV_VARS"
+    echo ""
+    echo "# Copiar package files primero para aprovechar cache de Docker"
+    echo "COPY package*.json ./"
+    echo ""
+    echo "# Instalar solo dependencias de producción"
+    echo "RUN npm ci --only=production && npm cache clean --force"
+    echo ""
+    echo "# Copiar código fuente"
+    echo "COPY . ."
+    echo ""
+    echo "# Exponemos el puerto"
+    echo "EXPOSE 3000"
+    echo ""
+    echo "# Comando de inicio"
+    echo "CMD $START_CMD"
+  } > "$DEST_FOLDER/Dockerfile"
+fi
+
+echo "✅ Deployment preparation completed inside container"
+`;
+        fs.writeFileSync(deployScriptPath, deployScript);
+        fs.chmodSync(deployScriptPath, 0o755);
+        // Ejecutar el script dentro del contenedor
+        const containerSpinner = (0, ora_1.default)('Running deployment inside container...').start();
+        try {
+            // Verificar que Docker está disponible
+            (0, child_process_1.execSync)('docker --version', { stdio: 'pipe' });
+        }
+        catch {
+            containerSpinner.fail('Docker is not available');
+            console.error(chalk_1.default.red('❌ Error: Docker is required for container mode'));
+            process.exit(1);
+        }
+        // Montar volúmenes necesarios
+        // - El proyecto como /workspace/project
+        // - El directorio destino como /workspace/dest
+        // - Docker socket para que el contenedor pueda construir imágenes
+        // - El script de deploy
+        const dockerRunArgs = [
+            'run', '--rm',
+            '-v', `${resolvedProjectPath}:/workspace/project:ro`,
+            '-v', `${resolvedDestFolder}:/workspace/dest`,
+            '-v', '/var/run/docker.sock:/var/run/docker.sock',
+            '-v', `${deployScriptPath}:/workspace/deploy-script.sh:ro`,
+            '--workdir', '/workspace',
+            options.containerImage,
+            'sh', '/workspace/deploy-script.sh'
+        ];
+        // Si hay archivo .env, montarlo también
+        if (fs.existsSync(envFilePath)) {
+            dockerRunArgs.splice(6, 0, '-v', `${envFilePath}:/workspace/project/.env:ro`);
+        }
+        console.log(chalk_1.default.gray('\n🐳 Container execution:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.cyan(`docker ${dockerRunArgs.join(' ')}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log();
+        const dockerProcess = (0, child_process_1.spawn)('docker', dockerRunArgs, {
+            stdio: 'inherit',
+        });
+        await new Promise((resolve, reject) => {
+            dockerProcess.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Container exited with code ${code}`));
+                }
+            });
+            dockerProcess.on('error', (error) => {
+                reject(error);
+            });
+        });
+        containerSpinner.succeed('Container execution completed');
+        // Verificar que se creó el Dockerfile
+        const dockerfilePath = path.join(resolvedDestFolder, 'Dockerfile');
+        if (!fs.existsSync(dockerfilePath)) {
+            console.error(chalk_1.default.red('❌ Error: Dockerfile was not created inside container'));
+            process.exit(1);
+        }
+        // Paso 4: Verificar/crear builder multi-plataforma
+        const builderSpinner = (0, ora_1.default)('Setting up multi-platform builder...').start();
+        try {
+            let buildersOutput = '';
+            try {
+                buildersOutput = (0, child_process_1.execSync)('docker buildx ls 2>/dev/null', {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                    shell: '/bin/sh',
+                });
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow('⚠️  Warning: Some builders have connection issues, continuing...'));
+            }
+            const builderName = 'multiarch-builder';
+            if (!buildersOutput.includes(builderName)) {
+                builderSpinner.text = 'Creating multi-platform builder...';
+                (0, child_process_1.execSync)(`docker buildx create --name ${builderName} --use --bootstrap`, {
+                    stdio: 'pipe',
+                });
+            }
+            else {
+                builderSpinner.text = 'Using existing multi-platform builder...';
+                try {
+                    (0, child_process_1.execSync)(`docker buildx use ${builderName}`, { stdio: 'pipe' });
+                }
+                catch (error) {
+                    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'));
+            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 {
+                (0, child_process_1.execSync)('docker info', { stdio: 'pipe' });
+                try {
+                    (0, child_process_1.execSync)('docker pull hello-world:latest', { stdio: 'pipe' });
+                    authSpinner.succeed('Docker authentication verified');
+                }
+                catch {
+                    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'));
+            }
+        }
+        // Paso 5: Construir y hacer push
+        const buildDockerSpinner = (0, ora_1.default)('Building Docker image for multiple platforms...').start();
+        try {
+            const tags = shouldPush
+                ? [`--tag ${imageName}`, `--tag ${imageLatest}`, '--push']
+                : [`--tag ${imageName}`, `--tag ${imageLatest}`, '--load'];
+            const buildCommand = `docker buildx build \
+          --platform linux/amd64,linux/arm64 \
+          ${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✅ 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 (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 (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
+        const shouldDeploy = options.deploy !== false && (options.deploy === true || (shouldPush && options.deploy !== false));
+        if (shouldDeploy) {
+            console.log(chalk_1.default.blue('\n🚀 Starting remote deployment...\n'));
+            // Leer variables de entorno del .env
+            let runtimeEnvVars = [];
+            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();
+                    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 (projectType === 'nextjs' && !key.startsWith('NEXT_PUBLIC_')) {
+                        runtimeEnvVars.push(`${key}=${value}`);
+                    }
+                    else if (projectType === 'express') {
+                        runtimeEnvVars.push(`${key}=${value}`);
+                    }
+                }
+            }
+            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,
+            });
+        }
+        else if (shouldPush && options.deploy === false) {
+            console.log(chalk_1.default.yellow('\n💡 Deployment skipped (--no-deploy flag was used)'));
+            console.log(chalk_1.default.gray('   Use --deploy to deploy to remote server after push'));
+        }
+    }
+    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.');
+    }
+    const certKeys = {
+        ca: 'docker-client/ca-pem',
+        cert: 'docker-client/cert.pem',
+        key: 'docker-client/key.pem'
+    };
+    const certificates = {};
+    const foundKeys = [];
+    for (const global of tokenData.adminGlobals) {
+        if (global && global.key) {
+            foundKeys.push(global.key);
+            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;
+            }
+        }
+    }
+    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.`);
+    }
+    const dockerCertPath = path.join(os.homedir(), '.codecrypto', 'docker-client');
+    if (!fs.existsSync(dockerCertPath)) {
+        fs.mkdirSync(dockerCertPath, { recursive: true });
+    }
+    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');
+    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 {
+        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);
+        }
+        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);
+            }
+        }
+        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'));
+        const fullDomain = `${config.serviceName}.${config.domainBase}`;
+        const serviceName = config.serviceName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+        const stopSpinner = (0, ora_1.default)('Checking and removing existing container...').start();
+        try {
+            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) {
+                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) {
+                    console.log(chalk_1.default.gray(`  ℹ Container ${fullDomain} was not running`));
+                }
+                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) {
+            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 {
+                stopSpinner.succeed('No existing container found');
+            }
+        }
+        const envOpts = [];
+        const envOptsForDisplay = [];
+        if (config.envVars.length > 0) {
+            config.envVars.forEach(env => {
+                const [key, ...valueParts] = env.split('=');
+                const value = valueParts.join('=');
+                envOpts.push('-e', `${key}=${value}`);
+                const escapedValue = value.replace(/"/g, '\\"');
+                envOptsForDisplay.push(`-e "${key}=${escapedValue}"`);
+            });
+        }
+        const dockerArgs = [
+            '-H', dockerHost,
+            '--tlsverify',
+            '--tlscacert', path.join(dockerCertPath, 'ca.pem'),
+            '--tlscert', path.join(dockerCertPath, 'cert.pem'),
+            '--tlskey', path.join(dockerCertPath, 'key.pem'),
+            'run', '-d',
+            '--name', fullDomain,
+            '--network', 'academy-network',
+            '--restart', 'unless-stopped',
+            ...envOpts,
+            '-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}`,
+            '-l', `traefik.http.services.${serviceName}-service.loadbalancer.passHostHeader=true`,
+            config.imageName
+        ];
+        const dockerRunCmdDisplay = `docker -H ${dockerHost} \\
+  --tlsverify \\
+  --tlscacert="${path.join(dockerCertPath, 'ca.pem')}" \\
+  --tlscert="${path.join(dockerCertPath, 'cert.pem')}" \\
+  --tlskey="${path.join(dockerCertPath, 'key.pem')}" \\
+  run -d \\
+  --name ${fullDomain} \\
+  --network academy-network \\
+  --restart unless-stopped \\
+  ${envOptsForDisplay.length > 0 ? envOptsForDisplay.join(' \\\n  ') + ' \\\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} \\
+  -l traefik.http.services.${serviceName}-service.loadbalancer.passHostHeader=true \\
+  ${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(dockerRunCmdDisplay));
+        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 {
+            const dockerProcess = (0, child_process_1.spawn)('docker', dockerArgs, {
+                stdio: 'inherit',
+            });
+            await new Promise((resolve, reject) => {
+                dockerProcess.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Docker command exited with code ${code}`));
+                    }
+                });
+                dockerProcess.on('error', (error) => {
+                    reject(error);
+                });
+            });
+            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);
+    }
+}
+//# sourceMappingURL=deploy-mcp.js.map