codecrypto-cli 1.0.8 → 1.0.9

package/src/commands/deploy.ts

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