codecrypto-cli 1.0.21 → 1.0.23

package/src/commands/doctor.ts

@@ -127,23 +127,210 @@ export const doctorCommand = new Command('doctor')
       });
     }
 
-    // 6. Check Docker Hub authentication (optional)
-    const dockerAuthCheck = ora('Checking Docker Hub authentication...').start();
+    // 6. Check Docker authentication
+    const dockerAuthCheck = ora('Checking Docker authentication...').start();
     try {
-      execSync('docker pull hello-world:latest', { encoding: 'utf-8', stdio: 'pipe' });
-      dockerAuthCheck.succeed('Docker Hub authentication OK');
-      checks.push({
-        name: 'Docker Hub Auth',
-        status: 'success',
-        message: 'Docker Hub authentication verified'
-      });
-    } catch (error) {
-      dockerAuthCheck.warn('Docker Hub authentication may be required');
+      // Obtener email del token.json para comparar
+      const tokenFilePath = path.join(os.homedir(), '.codecrypto', 'token.json');
+      let tokenEmail: string | null = null;
+      if (fs.existsSync(tokenFilePath)) {
+        try {
+          const tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf-8'));
+          tokenEmail = tokenData.email || null;
+        } catch {
+          // Ignorar errores al leer token
+        }
+      }
+
+      // Verificar si hay credenciales guardadas en Docker config
+      const dockerConfigPath = path.join(os.homedir(), '.docker', 'config.json');
+      let dockerUsername: string | null = null;
+      let dockerEmail: string | null = null;
+      let hasDockerAuth = false;
+      let dockerAuthInfo = '';
+      
+      if (fs.existsSync(dockerConfigPath)) {
+        try {
+          const dockerConfig = JSON.parse(fs.readFileSync(dockerConfigPath, 'utf-8'));
+          
+          // Verificar si hay auths configurados
+          if (dockerConfig.auths && Object.keys(dockerConfig.auths).length > 0) {
+            hasDockerAuth = true;
+            const registries = Object.keys(dockerConfig.auths);
+            dockerAuthInfo = `Authenticated to: ${registries.join(', ')}`;
+            
+            // Intentar obtener el username de Docker Hub
+            const dockerHubKey = registries.find(reg => 
+              reg.includes('docker.io') || 
+              reg.includes('hub.docker.com') || 
+              reg === 'https://index.docker.io/v1/'
+            );
+            
+            if (dockerHubKey && dockerConfig.auths[dockerHubKey]) {
+              // El username puede estar en auths[registry].auth (base64) o directamente
+              const authData = dockerConfig.auths[dockerHubKey];
+              if (authData && authData.username) {
+                dockerUsername = authData.username;
+                // Si el username parece un email, usarlo como email
+                if (dockerUsername && dockerUsername.includes('@')) {
+                  dockerEmail = dockerUsername;
+                }
+              }
+            }
+            
+            // Intentar obtener username de docker info como fallback
+            if (!dockerUsername) {
+              try {
+                const dockerInfo = execSync('docker info', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 });
+                const usernameMatch = dockerInfo.match(/Username:\s*(.+)/i);
+                if (usernameMatch) {
+                  dockerUsername = usernameMatch[1].trim();
+                  if (dockerUsername.includes('@')) {
+                    dockerEmail = dockerUsername;
+                  }
+                }
+              } catch {
+                // Ignorar errores
+              }
+            }
+            
+            // Verificar específicamente Docker Hub
+            const hasDockerHub = registries.some(reg => 
+              reg.includes('docker.io') || 
+              reg.includes('hub.docker.com') || 
+              reg === 'https://index.docker.io/v1/'
+            );
+            
+            // Construir mensaje con información de email/usuario
+            let authMessage = `Docker authentication verified: ${dockerAuthInfo}`;
+            if (dockerUsername || dockerEmail) {
+              const dockerIdentity = dockerEmail || dockerUsername;
+              authMessage += ` (User: ${dockerIdentity})`;
+              
+              // Comparar con token.json
+              if (tokenEmail && dockerEmail) {
+                if (dockerEmail.toLowerCase() === tokenEmail.toLowerCase()) {
+                  authMessage += ` ✓ Matches token.json email`;
+                } else {
+                  authMessage += ` ⚠ Different from token.json email (${tokenEmail})`;
+                }
+              } else if (tokenEmail && dockerUsername && !dockerEmail) {
+                // Comparar username con email del token (parte antes del @)
+                const tokenUsername = tokenEmail.split('@')[0].toLowerCase();
+                if (dockerUsername.toLowerCase() === tokenUsername) {
+                  authMessage += ` ✓ Username matches token.json email`;
+                } else {
+                  authMessage += ` ⚠ Username differs from token.json email (${tokenEmail})`;
+                }
+              }
+            }
+            
+            if (hasDockerHub) {
+              dockerAuthCheck.succeed(`Docker authentication OK (Docker Hub configured)`);
+              checks.push({
+                name: 'Docker Auth',
+                status: 'success',
+                message: authMessage
+              });
+            } else {
+              dockerAuthCheck.succeed(`Docker authentication OK (${registries.length} registry/registries configured)`);
+              checks.push({
+                name: 'Docker Auth',
+                status: 'success',
+                message: authMessage
+              });
+            }
+          } else {
+            // No hay auths configurados, intentar verificar con pull
+            try {
+              execSync('docker pull hello-world:latest', { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 });
+              dockerAuthCheck.succeed('Docker authentication OK (public access)');
+              let message = 'Docker can access public images (authentication may not be required)';
+              if (tokenEmail) {
+                message += ` (Token email: ${tokenEmail})`;
+              }
+              checks.push({
+                name: 'Docker Auth',
+                status: 'success',
+                message: message
+              });
+            } catch (pullError) {
+              dockerAuthCheck.warn('Docker authentication not configured');
+              let details = 'Run "docker login" if you need to push images to Docker Hub or private registries';
+              if (tokenEmail) {
+                details += ` (Token email: ${tokenEmail})`;
+              }
+              checks.push({
+                name: 'Docker Auth',
+                status: 'warning',
+                message: 'Docker authentication not configured',
+                details: details
+              });
+            }
+          }
+        } catch (configError) {
+          // Error leyendo config, intentar verificar con pull
+          try {
+            execSync('docker pull hello-world:latest', { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 });
+            dockerAuthCheck.succeed('Docker authentication OK');
+            let message = 'Docker can access public images';
+            if (tokenEmail) {
+              message += ` (Token email: ${tokenEmail})`;
+            }
+            checks.push({
+              name: 'Docker Auth',
+              status: 'success',
+              message: message
+            });
+          } catch (pullError) {
+            dockerAuthCheck.warn('Docker authentication may be required');
+            let details = 'Run "docker login" if you need to push images';
+            if (tokenEmail) {
+              details += ` (Token email: ${tokenEmail})`;
+            }
+            checks.push({
+              name: 'Docker Auth',
+              status: 'warning',
+              message: 'Docker authentication not verified',
+              details: details
+            });
+          }
+        }
+      } else {
+        // No existe config.json, intentar verificar con pull
+        try {
+          execSync('docker pull hello-world:latest', { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 });
+          dockerAuthCheck.succeed('Docker authentication OK (public access)');
+          let message = 'Docker can access public images (authentication may not be required)';
+          if (tokenEmail) {
+            message += ` (Token email: ${tokenEmail})`;
+          }
+          checks.push({
+            name: 'Docker Auth',
+            status: 'success',
+            message: message
+          });
+        } catch (error) {
+          dockerAuthCheck.warn('Docker authentication not configured');
+          let details = 'Run "docker login" if you need to push images to Docker Hub or private registries';
+          if (tokenEmail) {
+            details += ` (Token email: ${tokenEmail})`;
+          }
+          checks.push({
+            name: 'Docker Auth',
+            status: 'warning',
+            message: 'Docker authentication not configured',
+            details: details
+          });
+        }
+      }
+    } catch (error: any) {
+      dockerAuthCheck.fail('Docker authentication check failed');
       checks.push({
-        name: 'Docker Hub Auth',
-        status: 'warning',
-        message: 'Docker Hub authentication not verified',
-        details: 'Run "docker login" if you need to push images'
+        name: 'Docker Auth',
+        status: 'error',
+        message: 'Docker authentication check failed',
+        details: `Error: ${error.message || String(error)}`
       });
     }
 
@@ -499,11 +686,11 @@ export const doctorCommand = new Command('doctor')
         }
         
         besu1Check.succeed(`Besu1 network accessible (chain-id: ${chainId}, block: ${blockNumber})`);
-        checks.push({
-          name: 'Besu1 Network',
-          status: 'success',
+      checks.push({
+        name: 'Besu1 Network',
+        status: 'success',
           message: `Besu1 network accessible: ${rpcUrl} (chain-id: ${chainId}, block: ${blockNumber})`
-        });
+      });
       }
     } catch (error: any) {
       const errorMsg = error.message || String(error);