cdd-cli 3.1.1 → 3.1.3

package/AUDIT_REPORT.md

@@ -0,0 +1,1004 @@
+# Informe de Auditoría de Código - CDD CLI
+
+**Fecha:** 2025-10-17
+**Proyecto:** CDD-CLI (CLI Docker Dashboard)
+**Versión:** 3.1.2
+
+---
+
+## Resumen Ejecutivo
+
+Este informe presenta los resultados de una auditoría completa del código fuente del proyecto CDD-CLI. Se identificaron **11 problemas críticos** y **15 mejoras recomendadas** que afectan la seguridad, rendimiento, mantenibilidad y robustez de la aplicación.
+
+---
+
+## 1. ERRORES CRÍTICOS Y DE SEGURIDAD
+
+### 1.1. ❌ Error de Orden de Declaración en `containerActions.js`
+
+**Ubicación:** `src/helpers/dockerService/serviceComponents/containerActions.js` (líneas 1-16)
+
+**Problema:**
+```javascript
+export async function removeContainer(containerId) {
+  const container = docker.getContainer(containerId);
+  // ...
+}
+import { docker } from "../dockerService";
+```
+
+La función `removeContainer` está declarada **antes** de la importación del módulo `docker`, lo que viola el estándar de ES6 modules y puede causar errores de referencia.
+
+**¿Por qué está mal?**
+- Las importaciones deben ir al principio del archivo en ES6 modules
+- Esto puede causar errores en tiempo de ejecución dependiendo del compilador
+- Viola las convenciones de código JavaScript/ES6
+
+**Consecuencias:**
+- Error potencial de `ReferenceError` si el código se ejecuta sin transpilación
+- Confusión para otros desarrolladores
+- Problemas de mantenibilidad
+
+**Cómo mejorarlo:**
+Mover la importación al inicio del archivo:
+```javascript
+import { docker } from "../dockerService";
+import { imageExists, pullImage } from "./imageUtils.js";
+
+export async function removeContainer(containerId) {
+  const container = docker.getContainer(containerId);
+  // ...
+}
+```
+
+---
+
+### 1.2. ❌ Validación de Puertos Obligatoria Incorrecta
+
+**Ubicación:** `src/hooks/creation/useContainerCreation.js` (líneas 44-48)
+
+**Problema:**
+```javascript
+if (!portInput.trim()) {
+  setMessage("You must specify at least one port to expose (e.g. 8080:80)");
+  setMessageColor("red");
+  return;
+}
+```
+
+El código obliga al usuario a especificar puertos, pero muchos contenedores Docker **no necesitan** exponer puertos (servicios internos, workers, cron jobs, etc.).
+
+**¿Por qué está mal?**
+- No todos los contenedores requieren puertos expuestos
+- Impide crear contenedores válidos sin puertos
+- La lógica contradice el mensaje "Optional" mostrado al usuario
+
+**Consecuencias:**
+- Imposibilidad de crear contenedores sin puertos
+- Mala experiencia de usuario
+- Limitación funcional artificial
+
+**Cómo mejorarlo:**
+Hacer los puertos verdaderamente opcionales:
+```javascript
+if (portInput.trim() && !validatePorts(portInput)) {
+  setMessage("Port format must be host:container and both must be numbers (e.g. 8080:80)");
+  setMessageColor("red");
+  return;
+}
+```
+
+---
+
+### 1.3. ❌ Falta de Manejo de Errores en `getLogsStream`
+
+**Ubicación:** `src/helpers/dockerService/serviceComponents/containerLogs.js` (líneas 11-27)
+
+**Problema:**
+```javascript
+export function getLogsStream(containerId, onData, onEnd, onError) {
+  const container = docker.getContainer(containerId);
+  container.logs({
+    follow: true,
+    stdout: true,
+    stderr: true,
+    tail: 100
+  }, (err, stream) => {
+    if (err) {
+      onError?.(err);
+      return;
+    }
+    stream.on('data', chunk => onData?.(chunk.toString()));
+    stream.on('end', () => onEnd?.());
+    stream.on('error', err => onError?.(err));
+  });
+}
+```
+
+**¿Por qué está mal?**
+- No hay try-catch para manejar excepciones síncronas
+- Si `docker.getContainer()` falla, no se captura el error
+- Puede causar crashes no manejados
+
+**Consecuencias:**
+- Crash de la aplicación si el contenedor no existe
+- Mensajes de error no informativos
+- Mal manejo de condiciones de error
+
+**Cómo mejorarlo:**
+```javascript
+export function getLogsStream(containerId, onData, onEnd, onError) {
+  try {
+    const container = docker.getContainer(containerId);
+    container.logs({
+      follow: true,
+      stdout: true,
+      stderr: true,
+      tail: 100
+    }, (err, stream) => {
+      if (err) {
+        onError?.(err);
+        return;
+      }
+      stream.on('data', chunk => onData?.(chunk.toString()));
+      stream.on('end', () => onEnd?.());
+      stream.on('error', err => onError?.(err));
+    });
+  } catch (err) {
+    onError?.(err);
+  }
+}
+```
+
+---
+
+### 1.4. ❌ Path del Socket Docker Hardcodeado (Problema de Portabilidad)
+
+**Ubicación:** `src/helpers/dockerService/dockerService.js` (línea 2)
+
+**Problema:**
+```javascript
+const docker = new Docker({ socketPath: "/var/run/docker.sock" });
+```
+
+**¿Por qué está mal?**
+- El path `/var/run/docker.sock` solo funciona en Linux/Mac
+- En Windows, Docker usa named pipes o TCP
+- No permite configuración para diferentes entornos
+
+**Consecuencias:**
+- La aplicación **no funciona en Windows**
+- Imposibilidad de usar Docker remoto
+- Falta de flexibilidad para diferentes configuraciones
+
+**Cómo mejorarlo:**
+```javascript
+import Docker from "dockerode";
+
+// Usa la configuración por defecto de dockerode que maneja automáticamente:
+// - /var/run/docker.sock en Linux/Mac
+// - //./pipe/docker_engine en Windows
+// - Variables de entorno DOCKER_HOST, DOCKER_CERT_PATH, etc.
+const docker = new Docker();
+
+export { docker };
+```
+
+---
+
+### 1.5. ❌ Race Condition en Stats Fetching
+
+**Ubicación:** `src/components/ContainerRow.jsx` (líneas 31-46)
+
+**Problema:**
+```javascript
+useEffect(() => {
+  if (state !== "running") return;
+  const fetchStats = async () => {
+    try {
+      const s = await getStats(id);
+      setStats(s);
+      setStatsError("");
+    } catch (err) {
+      setStats({ cpuPercent: 0, memPercent: 0, netIO: { rx: 0, tx: 0 } });
+      setStatsError("Error fetching stats");
+    }
+  };
+  fetchStats();
+  const timer = setInterval(fetchStats, 1500);
+  return () => clearInterval(timer);
+}, [id, state]);
+```
+
+**¿Por qué está mal?**
+- Si el estado del contenedor cambia rápidamente, pueden quedar llamadas pendientes
+- No se cancela la promesa anterior cuando el componente se desmonta
+- Puede causar memory leaks o actualizaciones de estado en componentes desmontados
+
+**Consecuencias:**
+- Warning: "Can't perform a React state update on an unmounted component"
+- Posibles memory leaks
+- Consumo innecesario de recursos
+
+**Cómo mejorarlo:**
+```javascript
+useEffect(() => {
+  if (state !== "running") return;
+  
+  let isMounted = true;
+  
+  const fetchStats = async () => {
+    try {
+      const s = await getStats(id);
+      if (isMounted) {
+        setStats(s);
+        setStatsError("");
+      }
+    } catch (err) {
+      if (isMounted) {
+        setStats({ cpuPercent: 0, memPercent: 0, netIO: { rx: 0, tx: 0 } });
+        setStatsError("Error fetching stats");
+      }
+    }
+  };
+  
+  fetchStats();
+  const timer = setInterval(fetchStats, 1500);
+  
+  return () => {
+    isMounted = false;
+    clearInterval(timer);
+  };
+}, [id, state]);
+```
+
+---
+
+### 1.6. ❌ Falta de Validación de Container Index
+
+**Ubicación:** `src/hooks/useControls.js` (múltiples líneas)
+
+**Problema:**
+```javascript
+if (input === "l" && containers[selected]) {
+  logsViewer.openLogs();
+  getLogsStream(
+    containers[selected].id,
+    // ...
+  );
+}
+```
+
+Aunque hay validación en algunos lugares (`containers[selected]`), no es consistente en todas las operaciones.
+
+**¿Por qué está mal?**
+- Si `containers` está vacío o `selected` es inválido, puede causar errores
+- No hay validación consistente en todas las operaciones
+- Puede causar crashes inesperados
+
+**Consecuencias:**
+- Posibles errores de tipo `Cannot read property 'id' of undefined`
+- Experiencia de usuario inconsistente
+- Crashes potenciales
+
+**Cómo mejorarlo:**
+Agregar validación consistente al inicio de cada operación:
+```javascript
+const container = containers[selected];
+if (!container) {
+  actions.setMessage("No container selected");
+  actions.setMessageColor("red");
+  return;
+}
+```
+
+---
+
+### 1.7. ❌ Memory Leak en Log Streaming
+
+**Ubicación:** `src/hooks/useControls.js` (líneas 199-208)
+
+**Problema:**
+```javascript
+if (input === "l" && containers[selected]) {
+  logsViewer.openLogs();
+  getLogsStream(
+    containers[selected].id,
+    (data) => logsViewer.setLogs((prev) => [...prev, ...data.split("\n").filter(Boolean)]),
+    () => {},
+    (err) => logsViewer.setLogs((prev) => [...prev, `Error: ${err.message}`])
+  );
+  return;
+}
+```
+
+**¿Por qué está mal?**
+- El stream de logs nunca se cierra explícitamente
+- Los logs se acumulan indefinidamente en memoria (`[...prev, ...]`)
+- No hay límite máximo de logs almacenados
+
+**Consecuencias:**
+- Memory leak creciente con el tiempo
+- Posible crash por falta de memoria en streams largos
+- Rendimiento degradado
+
+**Cómo mejorarlo:**
+```javascript
+// Mantener referencia al stream para poder cerrarlo
+let logStream = null;
+
+// Al abrir logs:
+logsViewer.openLogs();
+logStream = getLogsStream(
+  containers[selected].id,
+  (data) => {
+    logsViewer.setLogs((prev) => {
+      const newLogs = [...prev, ...data.split("\n").filter(Boolean)];
+      // Limitar a últimas 1000 líneas
+      return newLogs.slice(-1000);
+    });
+  },
+  () => {},
+  (err) => logsViewer.setLogs((prev) => [...prev, `Error: ${err.message}`])
+);
+
+// Al cerrar logs:
+if (logStream) {
+  logStream.destroy();
+  logStream = null;
+}
+```
+
+---
+
+### 1.8. ❌ Falta de Validación en Variables de Entorno
+
+**Ubicación:** `src/helpers/validationHelpers.js` (líneas 13-16)
+
+**Problema:**
+```javascript
+export function validateEnvVars(envInput) {
+  // Future specific validations
+  return true;
+}
+```
+
+**¿Por qué está mal?**
+- No valida el formato de las variables de entorno
+- Acepta cualquier entrada, incluso inválida
+- El formato esperado `VAR=value` no se valida
+
+**Consecuencias:**
+- Variables de entorno malformadas pasan sin error
+- Fallo silencioso al crear contenedores
+- Mala experiencia de usuario
+
+**Cómo mejorarlo:**
+```javascript
+export function validateEnvVars(envInput) {
+  if (!envInput || !envInput.trim()) return true; // Empty is valid
+  
+  const vars = envInput.split(",").map(v => v.trim()).filter(Boolean);
+  const invalid = vars.find(v => {
+    const parts = v.split("=");
+    // Must have at least VAR=value format
+    if (parts.length < 2) return true;
+    const varName = parts[0].trim();
+    // Variable names should be alphanumeric with underscores
+    if (!/^[A-Z_][A-Z0-9_]*$/i.test(varName)) return true;
+    return false;
+  });
+  
+  return !invalid;
+}
+```
+
+---
+
+### 1.9. ❌ CPU Stats Calculation Puede Dar Valores Incorrectos
+
+**Ubicación:** `src/helpers/dockerService/serviceComponents/containerStats.js` (líneas 13-18)
+
+**Problema:**
+```javascript
+const cpuDelta =
+  stream.cpu_stats.cpu_usage.total_usage -
+  stream.precpu_stats.cpu_usage.total_usage;
+const systemDelta =
+  stream.cpu_stats.system_cpu_usage - stream.precpu_stats.system_cpu_usage;
+const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * 100 : 0;
+```
+
+**¿Por qué está mal?**
+- No se multiplica por el número de CPUs
+- El cálculo puede dar valores > 100% en sistemas multi-core
+- No normaliza correctamente el porcentaje
+
+**Consecuencias:**
+- Estadísticas de CPU incorrectas/confusas
+- Valores que exceden 100% en sistemas multi-core
+- Información engañosa para el usuario
+
+**Cómo mejorarlo:**
+```javascript
+const cpuDelta =
+  stream.cpu_stats.cpu_usage.total_usage -
+  stream.precpu_stats.cpu_usage.total_usage;
+const systemDelta =
+  stream.cpu_stats.system_cpu_usage - stream.precpu_stats.system_cpu_usage;
+
+// Número de CPUs
+const numCpus = stream.cpu_stats.online_cpus || 
+                stream.cpu_stats.cpu_usage.percpu_usage?.length || 1;
+
+// Calcular porcentaje normalizado
+const cpuPercent = systemDelta > 0 
+  ? ((cpuDelta / systemDelta) * numCpus * 100) 
+  : 0;
+```
+
+---
+
+### 1.10. ❌ Falta de Timeout en Container Actions
+
+**Ubicación:** `src/helpers/dockerService/serviceComponents/containerActions.js` (líneas 59-82)
+
+**Problema:**
+```javascript
+export async function startContainer(containerId) {
+  const container = docker.getContainer(containerId);
+  await container.start();
+}
+```
+
+**¿Por qué está mal?**
+- No hay timeout para operaciones que pueden colgarse
+- Un contenedor que no arranca puede dejar la UI bloqueada
+- No hay forma de cancelar operaciones largas
+
+**Consecuencias:**
+- UI congelada en operaciones que fallan
+- Imposibilidad de cancelar operaciones largas
+- Mala experiencia de usuario
+
+**Cómo mejorarlo:**
+```javascript
+// Helper para añadir timeout
+function withTimeout(promise, ms = 30000) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Operation timed out')), ms)
+    )
+  ]);
+}
+
+export async function startContainer(containerId) {
+  const container = docker.getContainer(containerId);
+  await withTimeout(container.start(), 30000);
+}
+```
+
+---
+
+### 1.11. ❌ Mensaje de Error Duplicado en `handleAction`
+
+**Ubicación:** `src/helpers/actionHelpers.js` (líneas 31-42)
+
+**Problema:**
+```javascript
+try {
+  await actionFn(c.id);
+  setMessage(`${actionLabel} container...`);  // ← Mismo mensaje que línea 31
+  setMessageColor("green");
+  setTimeout(() => setMessage(""), 3000);
+} catch (err) {
+  setMessage(`Failed to ${actionLabel.toLowerCase()} container.`);
+  setMessageColor("red");
+  setTimeout(() => setMessage(""), 3000);
+}
+```
+
+**¿Por qué está mal?**
+- El mensaje de éxito es idéntico al mensaje de inicio
+- No informa al usuario que la acción se completó
+- Confunde "iniciando" con "completado"
+
+**Consecuencias:**
+- Usuario no sabe si la acción se completó
+- Feedback confuso
+- Mala experiencia de usuario
+
+**Cómo mejorarlo:**
+```javascript
+try {
+  await actionFn(c.id);
+  setMessage(`${actionLabel} container completed successfully`);
+  setMessageColor("green");
+  setTimeout(() => setMessage(""), 3000);
+}
+```
+
+---
+
+## 2. PROBLEMAS DE CÓDIGO Y MEJORES PRÁCTICAS
+
+### 2.1. ⚠️ Uso Inconsistente de Optional Chaining
+
+**Ubicación:** Múltiples archivos
+
+**Problema:**
+El código usa `?.` en algunos lugares pero no en otros de forma inconsistente.
+
+**Impacto:** Código propenso a errores
+**Severidad:** Media
+
+**Solución:**
+Usar optional chaining consistentemente donde hay posibilidad de valores null/undefined.
+
+---
+
+### 2.2. ⚠️ Hardcoded Timeouts y Magic Numbers
+
+**Ubicación:** Múltiples archivos
+- `useContainers.js`: `3000` ms (línea 18)
+- `ContainerRow.jsx`: `1500` ms (línea 44)
+- `useControls.js`: `500` ms, `2000` ms, `3000` ms
+
+**Problema:**
+Números mágicos dispersos por el código sin constantes nombradas.
+
+**Impacto:** Dificulta mantenimiento y ajuste
+**Severidad:** Baja
+
+**Solución:**
+```javascript
+// constants.js
+export const REFRESH_INTERVALS = {
+  CONTAINER_LIST: 3000,
+  CONTAINER_STATS: 1500,
+  MESSAGE_TIMEOUT: 3000,
+  EXIT_DELAY: 500
+};
+```
+
+---
+
+### 2.3. ⚠️ Falta de PropTypes o TypeScript
+
+**Ubicación:** Todos los componentes React
+
+**Problema:**
+No hay validación de tipos en props de componentes.
+
+**Impacto:** Errores en tiempo de ejecución difíciles de debuggear
+**Severidad:** Media
+
+**Solución:**
+Agregar PropTypes o migrar a TypeScript:
+```javascript
+import PropTypes from 'prop-types';
+
+ContainerRow.propTypes = {
+  container: PropTypes.shape({
+    id: PropTypes.string.isRequired,
+    name: PropTypes.string.isRequired,
+    image: PropTypes.string.isRequired,
+    state: PropTypes.string.isRequired,
+    ports: PropTypes.array
+  }).isRequired
+};
+```
+
+---
+
+### 2.4. ⚠️ Falta de Tests Unitarios
+
+**Ubicación:** General
+
+**Problema:**
+Solo hay 1 archivo de tests (validationHelpers.test.js) con 5 tests.
+
+**Áreas sin cobertura:**
+- Hooks personalizados
+- Componentes React
+- Servicios Docker
+- Helpers de acciones
+
+**Impacto:** Alto riesgo de regresiones
+**Severidad:** Alta
+
+**Solución:**
+Agregar tests para:
+- `useContainerActions`
+- `useContainerCreation`
+- `actionHelpers`
+- Componentes críticos
+
+---
+
+### 2.5. ⚠️ Falta de Manejo de Casos Edge
+
+**Ubicación:** `src/helpers/dockerService/serviceComponents/containerList.js`
+
+**Problema:**
+```javascript
+name: container.Names[0].replace("/", ""),
+```
+
+No valida si `Names` está vacío.
+
+**Impacto:** Crash potencial si Docker devuelve datos inesperados
+**Severidad:** Media
+
+**Solución:**
+```javascript
+name: (container.Names && container.Names[0] || 'Unknown').replace("/", ""),
+```
+
+---
+
+### 2.6. ⚠️ Callback Hell en useControls
+
+**Ubicación:** `src/hooks/useControls.js` (líneas 86-219)
+
+**Problema:**
+La función `useInput` tiene 133 líneas con múltiples niveles de anidación.
+
+**Impacto:** Difícil de mantener y testear
+**Severidad:** Media
+
+**Solución:**
+Extraer handlers a funciones separadas:
+```javascript
+function useControls(containers = []) {
+  // ... state ...
+  
+  const handleEraseConfirmation = useCallback((input, key) => {
+    // lógica de confirmación
+  }, []);
+  
+  const handleLogsInput = useCallback((input, key) => {
+    // lógica de logs
+  }, []);
+  
+  const handleContainerCreation = useCallback((input, key) => {
+    // lógica de creación
+  }, []);
+  
+  useInput((input, key) => {
+    if (confirmErase) return handleEraseConfirmation(input, key);
+    if (logsViewer.showLogs) return handleLogsInput(input, key);
+    if (creatingContainer) return handleContainerCreation(input, key);
+    // ... navigation and commands
+  });
+}
+```
+
+---
+
+### 2.7. ⚠️ Falta de Logging
+
+**Ubicación:** General
+
+**Problema:**
+No hay sistema de logging para debuggear problemas.
+
+**Impacto:** Difícil diagnosticar problemas en producción
+**Severidad:** Media
+
+**Solución:**
+Implementar logger con niveles:
+```javascript
+// logger.js
+export const logger = {
+  debug: (msg, ...args) => {
+    if (process.env.DEBUG) console.log('[DEBUG]', msg, ...args);
+  },
+  info: (msg, ...args) => console.log('[INFO]', msg, ...args),
+  warn: (msg, ...args) => console.warn('[WARN]', msg, ...args),
+  error: (msg, ...args) => console.error('[ERROR]', msg, ...args)
+};
+```
+
+---
+
+### 2.8. ⚠️ No Hay Manejo de Reconexión Docker
+
+**Ubicación:** `src/helpers/dockerService/dockerService.js`
+
+**Problema:**
+Si la conexión a Docker se pierde, no hay reintentos ni manejo.
+
+**Impacto:** La aplicación se rompe si Docker se reinicia
+**Severidad:** Media
+
+**Solución:**
+Implementar lógica de retry con backoff exponencial.
+
+---
+
+### 2.9. ⚠️ Falta de Internacionalización (i18n)
+
+**Ubicación:** Todos los mensajes están hardcodeados en inglés
+
+**Problema:**
+```javascript
+setMessage("Container is already running.");
+```
+
+**Impacto:** No hay soporte multi-idioma
+**Severidad:** Baja
+
+**Solución:**
+Implementar sistema i18n:
+```javascript
+import { t } from './i18n';
+setMessage(t('container.already_running'));
+```
+
+---
+
+### 2.10. ⚠️ Falta de Documentación de API
+
+**Ubicación:** Varios archivos
+
+**Problema:**
+Aunque hay JSDoc en algunos lugares, es inconsistente y falta en muchas funciones importantes.
+
+**Impacto:** Dificulta onboarding y mantenimiento
+**Severidad:** Baja
+
+**Solución:**
+Completar JSDoc en todas las funciones públicas.
+
+---
+
+### 2.11. ⚠️ No Hay Validación de Imagen Name Format
+
+**Ubicación:** `src/hooks/creation/useContainerCreation.js`
+
+**Problema:**
+```javascript
+if (!imageName.trim()) {
+  setMessage("Image name cannot be empty.");
+  setMessageColor("red");
+  return;
+}
+```
+
+Solo valida que no esté vacío, pero no valida el formato.
+
+**Impacto:** Fallos al crear contenedores con nombres inválidos
+**Severidad:** Media
+
+**Solución:**
+```javascript
+// Validar formato de imagen: [registry/]name[:tag]
+const imageRegex = /^([\w\-\.]+\/)?[\w\-\.]+(:[\w\-\.]+)?$/;
+if (!imageRegex.test(imageName.trim())) {
+  setMessage("Invalid image name format. Use: [registry/]name[:tag]");
+  setMessageColor("red");
+  return;
+}
+```
+
+---
+
+### 2.12. ⚠️ Falta de Accessibility (a11y)
+
+**Ubicación:** Componentes de UI
+
+**Problema:**
+No hay consideraciones de accesibilidad en la UI de terminal.
+
+**Impacto:** Usuarios con screen readers o necesidades especiales no pueden usar la app
+**Severidad:** Baja
+
+**Solución:**
+Agregar roles ARIA y mejor soporte de navegación por teclado.
+
+---
+
+### 2.13. ⚠️ Falta de Rate Limiting en Refresh
+
+**Ubicación:** `src/hooks/useContainers.js`
+
+**Problema:**
+```javascript
+const timer = setInterval(fetch, 3000);
+```
+
+Si `fetch` toma más de 3 segundos, se acumulan llamadas.
+
+**Impacto:** Posible sobrecarga del sistema
+**Severidad:** Media
+
+**Solución:**
+Usar setTimeout en lugar de setInterval:
+```javascript
+useEffect(() => {
+  let timeoutId;
+  const fetch = async () => {
+    setContainers(await getContainers());
+    timeoutId = setTimeout(fetch, 3000);
+  };
+  fetch();
+  return () => clearTimeout(timeoutId);
+}, []);
+```
+
+---
+
+### 2.14. ⚠️ Estados Intermedios No Manejados
+
+**Ubicación:** `src/components/ContainerRow.jsx`
+
+**Problema:**
+```javascript
+const stateText = (state) => {
+  if (state === "running") return { text: "🟢 RUNNING", color: "green" };
+  if (state === "exited") return { text: "🔴 EXITED", color: "red" };
+  if (state === "paused") return { text: "🟠 PAUSED", color: "yellow" };
+  return { text: state.toUpperCase(), color: "gray" };
+};
+```
+
+Faltan estados como: `created`, `restarting`, `removing`, `dead`.
+
+**Impacto:** Feedback pobre para estados menos comunes
+**Severidad:** Baja
+
+**Solución:**
+Agregar todos los estados posibles de Docker.
+
+---
+
+### 2.15. ⚠️ Falta de Cleanup en Exit
+
+**Ubicación:** `src/hooks/useControls.js`
+
+**Problema:**
+```javascript
+if (input === "q") {
+  actions.setMessage("Exiting...");
+  actions.setMessageColor("yellow");
+  setTimeout(() => process.exit(0), 500);
+  return;
+}
+```
+
+No cierra streams ni limpia recursos antes de salir.
+
+**Impacto:** Posibles recursos no liberados
+**Severidad:** Baja
+
+**Solución:**
+```javascript
+if (input === "q") {
+  actions.setMessage("Exiting...");
+  actions.setMessageColor("yellow");
+  // Cerrar todos los streams activos
+  logsViewer.closeLogs();
+  // Cleanup adicional
+  setTimeout(() => process.exit(0), 500);
+  return;
+}
+```
+
+---
+
+## 3. PROBLEMAS DE RENDIMIENTO
+
+### 3.1. 🐌 Exceso de Re-renders en ContainerRow
+
+**Problema:** Cada actualización de stats causa re-render completo del row.
+
+**Solución:** Usar `React.memo()` y separar stats en componente aparte.
+
+---
+
+### 3.2. 🐌 Polling Innecesario
+
+**Problema:** Polling cada 3 segundos incluso cuando la app está en background.
+
+**Solución:** Usar Page Visibility API o websockets para actualizaciones en tiempo real.
+
+---
+
+### 3.3. 🐌 Arrays Spread en Loop
+
+**Ubicación:** Log accumulation
+
+**Problema:**
+```javascript
+logsViewer.setLogs((prev) => [...prev, ...data.split("\n").filter(Boolean)])
+```
+
+Crea nuevo array en cada línea de log.
+
+**Solución:** Usar estructura más eficiente o batching.
+
+---
+
+## 4. RECOMENDACIONES GENERALES
+
+### 4.1. Estructura de Proyecto
+- ✅ Buena separación de concerns (components, hooks, helpers)
+- ⚠️ Podría beneficiarse de un directorio `utils/` separado
+- ⚠️ Considerar directorio `constants/` para valores constantes
+
+### 4.2. Calidad de Código
+- ✅ Buen uso de hooks personalizados
+- ✅ Código generalmente legible
+- ⚠️ Necesita más comentarios en lógica compleja
+- ⚠️ Algunos archivos muy largos (useControls.js)
+
+### 4.3. Testing
+- ❌ Cobertura de tests insuficiente
+- ❌ No hay tests de integración
+- ❌ No hay tests E2E
+
+### 4.4. Documentación
+- ✅ README básico útil
+- ⚠️ Falta documentación de arquitectura
+- ⚠️ JSDoc inconsistente
+
+### 4.5. Seguridad
+- ⚠️ No hay validación de input de usuario en varios lugares
+- ⚠️ Errores exponen información sensible
+- ⚠️ No hay sanitización de output de Docker
+
+---
+
+## 5. PLAN DE ACCIÓN PRIORIZADO
+
+### Prioridad ALTA (Crítico - resolver inmediatamente)
+1. ✅ Corregir orden de imports en `containerActions.js`
+2. ✅ Hacer puertos opcionales en creación de contenedores
+3. ✅ Agregar manejo de errores en `getLogsStream`
+4. ✅ Configurar Docker socket para cross-platform
+5. ✅ Prevenir race conditions en stats fetching
+
+### Prioridad MEDIA (Importante - resolver pronto)
+6. Implementar validación de variables de entorno
+7. Corregir cálculo de CPU stats
+8. Agregar timeouts a operaciones Docker
+9. Implementar límite de logs en memoria
+10. Agregar tests unitarios básicos
+
+### Prioridad BAJA (Mejoras - cuando sea posible)
+11. Extraer magic numbers a constantes
+12. Agregar PropTypes o TypeScript
+13. Mejorar logging y debugging
+14. Implementar i18n
+15. Mejorar documentación
+
+---
+
+## 6. MÉTRICAS DE CÓDIGO
+
+- **Líneas de código:** ~1,200
+- **Archivos JavaScript/JSX:** 28
+- **Cobertura de tests:** ~5%
+- **Deuda técnica estimada:** 3-4 semanas de trabajo
+
+---
+
+## 7. CONCLUSIÓN
+
+El proyecto CDD-CLI tiene una base sólida con buena separación de concerns y uso de React hooks. Sin embargo, presenta varios problemas críticos relacionados con:
+
+1. **Manejo de errores insuficiente**
+2. **Memory leaks potenciales**
+3. **Falta de validación de inputs**
+4. **Problemas de portabilidad**
+5. **Cobertura de tests mínima**
+
+Se recomienda abordar primero los **5 problemas de alta prioridad** antes de considerar nuevas features. Estos problemas pueden causar crashes, memory leaks y una mala experiencia de usuario.
+
+La implementación de las mejoras propuestas mejoraría significativamente la robustez, mantenibilidad y calidad general de la aplicación.
+
+---
+
+**Fin del informe de auditoría**