codecrypto-cli 1.0.12 → 1.0.14

package/src/commands/deploy.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -12,7 +12,8 @@ export const deployCommand = new Command('deploy')
   .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', false)
+  .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')
@@ -112,7 +113,27 @@ export const deployCommand = new Command('deploy')
       // 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';
-      const projectName = path.basename(resolvedProjectPath);
+      
+      // Obtener el nombre del proyecto desde package.json.name
+      // Si no existe, usar el nombre del directorio como fallback
+      let projectName = packageJson.name || path.basename(resolvedProjectPath);
+      
+      // Sanitizar el nombre para que sea válido para Docker
+      // Docker permite: letras minúsculas, números, guiones, guiones bajos y puntos
+      // También eliminar el scope si existe (ej: @scope/package -> package)
+      projectName = projectName.toLowerCase()
+        .replace(/^@[^/]+\//, '') // Eliminar scope npm (@scope/package -> package)
+        .replace(/[^a-z0-9._-]/g, '-') // Reemplazar caracteres inválidos con guiones
+        .replace(/^-+|-+$/g, '') // Eliminar guiones al inicio y final
+        .replace(/-+/g, '-') // Reemplazar múltiples guiones con uno solo
+        .replace(/\.+/g, '.') // Reemplazar múltiples puntos con uno solo
+        .substring(0, 128); // Limitar longitud (límite de Docker)
+      
+      // Si después de sanitizar está vacío, usar el nombre del directorio
+      if (!projectName) {
+        projectName = path.basename(resolvedProjectPath).toLowerCase().replace(/[^a-z0-9._-]/g, '-');
+      }
+      
       const imageBase = `jviejo/${projectName}`;
       const imageName = `${imageBase}:${version}`;
       const imageLatest = `${imageBase}:latest`;
@@ -151,13 +172,25 @@ export const deployCommand = new Command('deploy')
         process.exit(1);
       }
 
+      // Determinar ruta del archivo .env (común para ambos tipos de proyecto)
+      // Si no se especifica --env-file, usar .env del proyecto
+      const envFilePath = options.envFile 
+        ? path.resolve(options.envFile)
+        : path.join(resolvedProjectPath, '.env');
+
       console.log(chalk.gray('Deployment Configuration:'));
       console.log(chalk.white(`  Project: ${chalk.green(projectName)}`));
       console.log(chalk.white(`  Type: ${chalk.green(projectType)}`));
       console.log(chalk.white(`  Version: ${chalk.green(version)}`));
       console.log(chalk.white(`  Image: ${chalk.green(imageName)}`));
       console.log(chalk.white(`  Latest: ${chalk.green(imageLatest)}`));
-      console.log(chalk.white(`  Push to Registry: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}\n`));
+      console.log(chalk.white(`  Push to Registry: ${shouldPush ? chalk.green('Yes') : chalk.yellow('No')}`));
+      if (fs.existsSync(envFilePath)) {
+        console.log(chalk.white(`  Env file: ${chalk.green(envFilePath)}`));
+      } else {
+        console.log(chalk.white(`  Env file: ${chalk.yellow('Not found')} (${envFilePath})`));
+      }
+      console.log();
 
       // Preparar directorio destino
       const resolvedDestFolder = path.resolve(destFolder);
@@ -169,11 +202,6 @@ export const deployCommand = new Command('deploy')
       let runtimeEnvVars: string[] = [];
       let nextPublicEnvVars: string[] = [];
       let dockerfileContent: string;
-      
-      // Determinar ruta del archivo .env (común para ambos tipos de proyecto)
-      const envFilePath = options.envFile 
-        ? path.resolve(options.envFile)
-        : path.join(resolvedProjectPath, '.env');
 
       if (projectType === 'nextjs') {
         // ========== LÓGICA PARA NEXT.JS ==========
@@ -630,7 +658,14 @@ CMD ${JSON.stringify(startCmd)}
       }
 
       // Paso 6: Desplegar en servidor remoto si se solicita
-      if (options.deploy) {
+      // Lógica: Si se hace push, desplegar automáticamente a menos que se pase --no-deploy
+      // options.deploy: true si --deploy, false si --no-deploy, undefined si no se especifica
+      // Si shouldPush es true y no se pasa --no-deploy, desplegar automáticamente
+      const shouldDeploy = options.deploy !== false && (options.deploy === true || (shouldPush && options.deploy !== false));
+      
+      if (shouldDeploy) {
+        console.log(chalk.blue('\n🚀 Starting remote deployment...\n'));
+        
         // Para despliegue, usar la versión especificada o la del package.json
         const deployImageName = options.imageVersion 
           ? `${imageBase}:${options.imageVersion}`
@@ -644,6 +679,10 @@ CMD ${JSON.stringify(startCmd)}
           envVars: runtimeEnvVars,
           envFilePath: runtimeEnvVars.length > 0 ? envFilePath : undefined,
         });
+      } else if (shouldPush && options.deploy === false) {
+        // Si se hizo push pero se pasó --no-deploy, mostrar mensaje
+        console.log(chalk.yellow('\n💡 Deployment skipped (--no-deploy flag was used)'));
+        console.log(chalk.gray('   Use --deploy to deploy to remote server after push'));
       }
 
     } catch (error: any) {
@@ -879,24 +918,51 @@ async function deployToRemoteServer(config: {
     // Para despliegue remoto, pasamos las variables directamente con -e
     // ya que --env-file requiere que el archivo esté en el servidor remoto
     const envOpts: string[] = [];
+    const envOptsForDisplay: string[] = [];
     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
+        // Para spawn, pasamos como argumentos separados
+        envOpts.push('-e', `${key}=${value}`);
+        // Para display, mantenemos el formato con comillas escapadas
         const escapedValue = value.replace(/"/g, '\\"');
-        envOpts.push(`-e "${key}=${escapedValue}"`);
+        envOptsForDisplay.push(`-e "${key}=${escapedValue}"`);
       });
     }
 
     // Construir comando docker run con parámetros TLS
-    const dockerRunCmd = `${dockerTlsPrefix} run -d \\
+    // Usar spawn con argumentos separados para evitar problemas con shell escaping
+    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}`,
+      config.imageName
+    ];
+
+    // Construir comando para mostrar (formato legible)
+    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 \\
-  ${envOpts.length > 0 ? envOpts.join(' \\\n  ') + ' \\' : ''}
-  -l traefik.enable=true \\
+  ${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 \\
@@ -905,7 +971,7 @@ async function deployToRemoteServer(config: {
 
     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.cyan(dockerRunCmdDisplay));
     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)}`));
@@ -925,10 +991,23 @@ async function deployToRemoteServer(config: {
     const runSpinner = ora('Deploying container to remote server...').start();
     
     try {
-      // Ejecutar comando docker con parámetros TLS directamente
-      execSync(dockerRunCmd, {
+      // Ejecutar comando docker usando spawn para mejor manejo de argumentos
+      const dockerProcess = spawn('docker', dockerArgs, {
         stdio: 'inherit',
-        shell: '/bin/sh',
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        dockerProcess.on('close', (code: number) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`Docker command exited with code ${code}`));
+          }
+        });
+
+        dockerProcess.on('error', (error: Error) => {
+          reject(error);
+        });
       });
 
       runSpinner.succeed('Container deployed successfully');

package/src/commands/doctor.ts

@@ -154,12 +154,79 @@ export const doctorCommand = new Command('doctor')
       try {
         const tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf-8'));
         if (tokenData.token && tokenData.email) {
-          tokenCheck.succeed(`Token found for: ${tokenData.email}`);
-          checks.push({
-            name: 'CodeCrypto Token',
-            status: 'success',
-            message: `Token found for: ${tokenData.email}`
-          });
+          // Validar el token con el servidor
+          const serverUrl = tokenData.serverUrl || process.env.CODECRYPTO_API_URL || process.env.API_URL || 'https://proyectos.codecrypto.academy';
+          const token = String(tokenData.token).trim();
+          
+          try {
+            const verifyUrl = `${serverUrl}/api/tokens/verify`;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 seconds timeout
+            
+            const response = await fetch(verifyUrl, {
+              method: 'GET',
+              headers: {
+                'Authorization': `Bearer ${token}`,
+              },
+              signal: controller.signal,
+            });
+            
+            clearTimeout(timeoutId);
+            
+            if (response.ok) {
+              const responseData = await response.json();
+              tokenCheck.succeed(`Token valid for: ${tokenData.email}`);
+              checks.push({
+                name: 'CodeCrypto Token',
+                status: 'success',
+                message: `Token valid for: ${tokenData.email}`
+              });
+            } else {
+              const errorText = await response.text();
+              let errorMessage = 'Token validation failed';
+              try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage = errorJson.error || errorJson.message || errorMessage;
+              } catch {
+                errorMessage = errorText || errorMessage;
+              }
+              
+              tokenCheck.fail(`Token validation failed: ${errorMessage}`);
+              checks.push({
+                name: 'CodeCrypto Token',
+                status: 'error',
+                message: `Token validation failed: ${errorMessage}`,
+                details: 'Run "codecrypto auth --force" to refresh your token'
+              });
+            }
+          } catch (fetchError: any) {
+            const errorMsg = fetchError.message || String(fetchError);
+            if (fetchError.name === 'AbortError' || errorMsg.includes('timeout')) {
+              tokenCheck.fail('Token validation timeout');
+              checks.push({
+                name: 'CodeCrypto Token',
+                status: 'error',
+                message: 'Token validation timeout',
+                details: 'Cannot reach server to validate token. Check your internet connection.'
+              });
+            } else if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('ENOTFOUND')) {
+              tokenCheck.fail('Cannot reach server to validate token');
+              checks.push({
+                name: 'CodeCrypto Token',
+                status: 'error',
+                message: 'Cannot reach server to validate token',
+                details: `Cannot reach ${serverUrl}. Check your network connection.`
+              });
+            } else {
+              tokenCheck.fail(`Token validation error: ${errorMsg}`);
+              checks.push({
+                name: 'CodeCrypto Token',
+                status: 'error',
+                message: `Token validation error: ${errorMsg}`,
+                details: 'Run "codecrypto auth --force" to refresh your token'
+              });
+            }
+          }
         } else {
           tokenCheck.fail('Token file exists but is invalid');
           checks.push({
@@ -188,7 +255,69 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 8. Check Docker certificates in token.json
+    // 8. Check server access (proyectos.codecrypto.academy)
+    const serverCheck = ora('Checking access to proyectos.codecrypto.academy...').start();
+    try {
+      const serverUrl = 'https://proyectos.codecrypto.academy';
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 seconds timeout
+      
+      const response = await fetch(serverUrl, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: {
+          'User-Agent': 'CodeCrypto-CLI/1.0'
+        }
+      });
+      
+      clearTimeout(timeoutId);
+      
+      if (response.ok || response.status < 500) {
+        serverCheck.succeed(`Server accessible: ${serverUrl}`);
+        checks.push({
+          name: 'Server Access',
+          status: 'success',
+          message: `Server accessible: ${serverUrl} (status: ${response.status})`
+        });
+      } else {
+        serverCheck.fail(`Server returned error: ${response.status}`);
+        checks.push({
+          name: 'Server Access',
+          status: 'error',
+          message: `Server returned error: ${response.status}`,
+          details: `Check if ${serverUrl} is accessible from your network`
+        });
+      }
+    } catch (error: any) {
+      const errorMsg = error.message || String(error);
+      if (error.name === 'AbortError' || errorMsg.includes('timeout')) {
+        serverCheck.fail('Server connection timeout');
+        checks.push({
+          name: 'Server Access',
+          status: 'error',
+          message: 'Server connection timeout',
+          details: `Cannot reach https://proyectos.codecrypto.academy. Check your internet connection.`
+        });
+      } else if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('ENOTFOUND') || errorMsg.includes('getaddrinfo')) {
+        serverCheck.fail('Cannot resolve server address');
+        checks.push({
+          name: 'Server Access',
+          status: 'error',
+          message: 'Cannot resolve server address',
+          details: `Cannot reach https://proyectos.codecrypto.academy. Check DNS resolution and network connectivity.`
+        });
+      } else {
+        serverCheck.fail('Cannot access server');
+        checks.push({
+          name: 'Server Access',
+          status: 'error',
+          message: 'Cannot access server',
+          details: `Error: ${errorMsg}. Check if https://proyectos.codecrypto.academy is accessible.`
+        });
+      }
+    }
+
+    // 9. Check Docker certificates in token.json
     const certCheck = ora('Checking Docker certificates in token.json...').start();
     try {
       if (fs.existsSync(tokenFilePath)) {
@@ -254,7 +383,7 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 9. Check Git (optional but recommended)
+    // 10. Check Git (optional but recommended)
     const gitCheck = ora('Checking Git...').start();
     try {
       const gitVersion = execSync('git --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
@@ -279,7 +408,7 @@ export const doctorCommand = new Command('doctor')
     // ============================================
     console.log(chalk.cyan('\n🔷 Foundry / Smart Contracts Deployment Checks\n'));
 
-    // 10. Check Foundry (forge)
+    // 11. Check Foundry (forge)
     const forgeCheck = ora('Checking Foundry (forge)...').start();
     try {
       const forgeVersion = execSync('forge --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
@@ -299,7 +428,7 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 11. Check cast
+    // 12. Check cast
     const castCheck = ora('Checking cast...').start();
     try {
       const castVersion = execSync('cast --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
@@ -319,7 +448,7 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 12. Check anvil
+    // 13. Check anvil
     const anvilCheck = ora('Checking anvil...').start();
     try {
       const anvilVersion = execSync('anvil --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
@@ -339,11 +468,11 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 13. Check if Anvil is running on correct port and chain-id
-    const anvilRunningCheck = ora('Checking if Anvil is running (port 55556, chain-id 3133731337)...').start();
+    // 14. Check if Anvil is running on correct port and chain-id
+    const anvilRunningCheck = ora('Checking if Anvil is running (port 8545, chain-id 31337)...').start();
     try {
       // Try to get chain id from the RPC
-      const rpcUrl = 'http://localhost:55556';
+      const rpcUrl = 'http://localhost:8545';
       const chainIdResponse = execSync(
         `cast chain-id --rpc-url ${rpcUrl}`,
         { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }
@@ -357,20 +486,20 @@ export const doctorCommand = new Command('doctor')
         chainId = parseInt(chainIdResponse, 10);
       }
       
-      if (chainId === 3133731337) {
-        anvilRunningCheck.succeed(`Anvil running on port 55556 with chain-id ${chainId}`);
+      if (chainId === 31337) {
+        anvilRunningCheck.succeed(`Anvil running on port 8545 with chain-id ${chainId}`);
         checks.push({
           name: 'Anvil Running',
           status: 'success',
-          message: `Anvil running on port 55556 with chain-id ${chainId}`
+          message: `Anvil running on port 8545 with chain-id ${chainId}`
         });
       } else {
-        anvilRunningCheck.fail(`Anvil running but wrong chain-id: ${chainId} (expected 3133731337)`);
+        anvilRunningCheck.fail(`Anvil running but wrong chain-id: ${chainId} (expected 31337)`);
         checks.push({
           name: 'Anvil Running',
           status: 'error',
           message: `Anvil running but wrong chain-id: ${chainId}`,
-          details: 'Start Anvil with: anvil --chain-id 3133731337 --port 55556'
+          details: 'Start Anvil with: anvil --chain-id 31337 --port 8545'
         });
       }
     } catch (error: any) {
@@ -380,8 +509,8 @@ export const doctorCommand = new Command('doctor')
         checks.push({
           name: 'Anvil Running',
           status: 'error',
-          message: 'Anvil is not running on port 55556',
-          details: 'Start Anvil with: anvil --chain-id 3133731337 --port 55556'
+          message: 'Anvil is not running on port 8545',
+          details: 'Start Anvil with: anvil --chain-id 31337 --port 8545'
         });
       } else if (errorMsg.includes('timeout') || errorMsg.includes('ETIMEDOUT')) {
         anvilRunningCheck.fail('Anvil connection timeout');
@@ -389,7 +518,7 @@ export const doctorCommand = new Command('doctor')
           name: 'Anvil Running',
           status: 'error',
           message: 'Anvil connection timeout',
-          details: 'Check if Anvil is running: anvil --chain-id 3133731337 --port 55556'
+          details: 'Check if Anvil is running: anvil --chain-id 31337 --port 8545'
         });
       } else {
         anvilRunningCheck.fail('Cannot connect to Anvil');
@@ -397,15 +526,15 @@ export const doctorCommand = new Command('doctor')
           name: 'Anvil Running',
           status: 'error',
           message: 'Cannot connect to Anvil',
-          details: `Error: ${errorMsg}. Start Anvil with: anvil --chain-id 3133731337 --port 55556`
+          details: `Error: ${errorMsg}. Start Anvil with: anvil --chain-id 31337 --port 8545`
         });
       }
     }
 
-    // 14. Check Anvil account 0
+    // 15. Check Anvil account 0
     const anvilAccountCheck = ora('Checking Anvil account 0...').start();
     try {
-      const rpcUrl = 'http://localhost:55556';
+      const rpcUrl = 'http://localhost:8545';
       const balance = execSync(
         `cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url ${rpcUrl}`,
         { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }
@@ -427,6 +556,108 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
+    // 16. Check Besu1 network access
+    const besu1Check = ora('Checking Besu1 network (https://besu1.proyectos.codecrypto.academy)...').start();
+    try {
+      const rpcUrl = 'https://besu1.proyectos.codecrypto.academy';
+      const chainIdResponse = execSync(
+        `cast chain-id --rpc-url ${rpcUrl}`,
+        { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 }
+      ).trim();
+      
+      let chainId: number;
+      if (chainIdResponse.startsWith('0x') || chainIdResponse.startsWith('0X')) {
+        chainId = parseInt(chainIdResponse, 16);
+      } else {
+        chainId = parseInt(chainIdResponse, 10);
+      }
+      
+      besu1Check.succeed(`Besu1 network accessible (chain-id: ${chainId})`);
+      checks.push({
+        name: 'Besu1 Network',
+        status: 'success',
+        message: `Besu1 network accessible: ${rpcUrl} (chain-id: ${chainId})`
+      });
+    } catch (error: any) {
+      const errorMsg = error.message || String(error);
+      if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('Connection refused')) {
+        besu1Check.fail('Cannot connect to Besu1 network');
+        checks.push({
+          name: 'Besu1 Network',
+          status: 'error',
+          message: 'Cannot connect to Besu1 network',
+          details: 'Check if https://besu1.proyectos.codecrypto.academy is accessible from your network'
+        });
+      } else if (errorMsg.includes('timeout') || errorMsg.includes('ETIMEDOUT')) {
+        besu1Check.fail('Besu1 network connection timeout');
+        checks.push({
+          name: 'Besu1 Network',
+          status: 'error',
+          message: 'Besu1 network connection timeout',
+          details: 'Check your internet connection and network access to https://besu1.proyectos.codecrypto.academy'
+        });
+      } else {
+        besu1Check.fail('Cannot access Besu1 network');
+        checks.push({
+          name: 'Besu1 Network',
+          status: 'error',
+          message: 'Cannot access Besu1 network',
+          details: `Error: ${errorMsg}. Check if https://besu1.proyectos.codecrypto.academy is accessible.`
+        });
+      }
+    }
+
+    // 17. Check Besu2 network access
+    const besu2Check = ora('Checking Besu2 network (https://besu2.proyectos.codecrypto.academy)...').start();
+    try {
+      const rpcUrl = 'https://besu2.proyectos.codecrypto.academy';
+      const chainIdResponse = execSync(
+        `cast chain-id --rpc-url ${rpcUrl}`,
+        { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 }
+      ).trim();
+      
+      let chainId: number;
+      if (chainIdResponse.startsWith('0x') || chainIdResponse.startsWith('0X')) {
+        chainId = parseInt(chainIdResponse, 16);
+      } else {
+        chainId = parseInt(chainIdResponse, 10);
+      }
+      
+      besu2Check.succeed(`Besu2 network accessible (chain-id: ${chainId})`);
+      checks.push({
+        name: 'Besu2 Network',
+        status: 'success',
+        message: `Besu2 network accessible: ${rpcUrl} (chain-id: ${chainId})`
+      });
+    } catch (error: any) {
+      const errorMsg = error.message || String(error);
+      if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('Connection refused')) {
+        besu2Check.fail('Cannot connect to Besu2 network');
+        checks.push({
+          name: 'Besu2 Network',
+          status: 'error',
+          message: 'Cannot connect to Besu2 network',
+          details: 'Check if https://besu2.proyectos.codecrypto.academy is accessible from your network'
+        });
+      } else if (errorMsg.includes('timeout') || errorMsg.includes('ETIMEDOUT')) {
+        besu2Check.fail('Besu2 network connection timeout');
+        checks.push({
+          name: 'Besu2 Network',
+          status: 'error',
+          message: 'Besu2 network connection timeout',
+          details: 'Check your internet connection and network access to https://besu2.proyectos.codecrypto.academy'
+        });
+      } else {
+        besu2Check.fail('Cannot access Besu2 network');
+        checks.push({
+          name: 'Besu2 Network',
+          status: 'error',
+          message: 'Cannot access Besu2 network',
+          details: `Error: ${errorMsg}. Check if https://besu2.proyectos.codecrypto.academy is accessible.`
+        });
+      }
+    }
+
     // ============================================
     // SUMMARY
     // ============================================