cdd-cli 3.1.1 → 3.1.3

package/src/helpers/dockerService/serviceComponents/containerActions.js

@@ -1,24 +1,55 @@
+import { docker } from "../dockerService";
+import { imageExists, pullImage } from "./imageUtils.js";
+
+/**
+ * Helper to add timeout to promises
+ * @param {Promise} promise - Promise to wrap
+ * @param {number} ms - Timeout in milliseconds
+ * @returns {Promise}
+ */
+function withTimeout(promise, ms = 30000) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Operation timed out')), ms)
+    )
+  ]);
+}
+
+/**
+ * Remove (delete) a container by id. Force removal so running containers are stopped first.
+ *
+ * @param {string} containerId - Docker container id
+ * @returns {Promise<void>} Resolves when removal completes
+ * @throws {Error} If Docker reports an error
+ */
 export async function removeContainer(containerId) {
   const container = docker.getContainer(containerId);
   try {
-    await container.remove({ force: true });
+    await withTimeout(container.remove({ force: true }), 30000);
   } catch (err) {
     throw new Error('Error removing container: ' + err.message);
   }
 }
-import { docker } from "../dockerService";
-import { imageExists, pullImage } from "./imageUtils.js";
 
+/**
+ * Create a new container from an image. If the image is missing locally, it will be pulled.
+ *
+ * @param {string} imageName - Image name (e.g. 'nginx:alpine')
+ * @param {Object} [options] - Docker create options (Env, ExposedPorts, HostConfig, name, etc.)
+ * @returns {Promise<string>} The created container id
+ * @throws {Error} If image listing/pull or creation fails
+ */
 export async function createContainer(imageName, options = {}) {
   let exists;
   try {
-    exists = await imageExists(imageName);
+    exists = await withTimeout(imageExists(imageName), 10000);
   } catch (err) {
     throw new Error('Error listing local images: ' + err.message);
   }
   if (!exists) {
     try {
-      await pullImage(imageName);
+      await withTimeout(pullImage(imageName), 300000); // 5 minutes for pull
     } catch (err) {
       throw new Error('Could not pull image: ' + err.message);
     }
@@ -29,24 +60,39 @@ export async function createContainer(imageName, options = {}) {
     ...options,
   };
   try {
-    const container = await docker.createContainer(createOpts);
+    const container = await withTimeout(docker.createContainer(createOpts), 30000);
     return container.id || container.Id;
   } catch (err) {
     throw new Error('Error creating container: ' + err.message);
   }
 }
 
+/**
+ * Start a container by id.
+ * @param {string} containerId - Docker container id
+ * @returns {Promise<void>}
+ */
 export async function startContainer(containerId) {
   const container = docker.getContainer(containerId);
-  await container.start();
+  await withTimeout(container.start(), 30000);
 }
 
+/**
+ * Stop a container by id.
+ * @param {string} containerId - Docker container id
+ * @returns {Promise<void>}
+ */
 export async function stopContainer(containerId) {
   const container = docker.getContainer(containerId);
-  await container.stop();
+  await withTimeout(container.stop(), 30000);
 }
 
+/**
+ * Restart a container by id.
+ * @param {string} containerId - Docker container id
+ * @returns {Promise<void>}
+ */
 export async function restartContainer(containerId) {
   const container = docker.getContainer(containerId);
-  await container.restart();
+  await withTimeout(container.restart(), 30000);
 }

package/src/helpers/dockerService/serviceComponents/containerList.js

@@ -1,10 +1,14 @@
 import { docker } from "../dockerService";
 
+/**
+ * Return a list of containers with normalized fields for the UI.
+ * @returns {Promise<Array<Object>>}
+ */
 export async function getContainers() {
   const containers = await docker.listContainers({ all: true });
   return containers.map((container) => ({
     id: container.Id,
-    name: container.Names[0].replace("/", ""),
+    name: (container.Names && container.Names[0] || 'Unknown').replace("/", ""),
     image: container.Image,
     state: container.State,
     status: container.Status,
@@ -16,7 +20,7 @@ export async function getContainers() {
         if (publicPorts.length > 0) {
           return [...new Set(publicPorts)];
         }
-        // Si no hay puertos públicos, mostrar los privados expuestos
+  // If there are no public ports, show private exposed ports
         const privatePorts = container.Ports.filter((port) => port.PrivatePort).map(
           (port) => `:${port.PrivatePort}`
         );

package/src/helpers/dockerService/serviceComponents/containerLogs.js

@@ -1,19 +1,31 @@
 import { docker } from "../dockerService";
 
+/**
+ * Return a stream of logs from a container and call callbacks for events.
+ *
+ * @param {string} containerId - Docker container id
+ * @param {Function} onData - Called with chunk string when data arrives
+ * @param {Function} onEnd - Called when stream ends
+ * @param {Function} onError - Called on error
+ */
 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));
-  });
+  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);
+  }
 }

package/src/helpers/dockerService/serviceComponents/containerStats.js

@@ -1,5 +1,11 @@
 import { docker } from "../dockerService";
 
+/**
+ * Retrieve a snapshot of container resource usage (CPU, memory, network).
+ *
+ * @param {string} containerId - Docker container id
+ * @returns {Promise<Object>} Object with cpuPercent, memPercent and netIO {rx,tx}
+ */
 export async function getStats(containerId) {
   const container = docker.getContainer(containerId);
   const stream = await container.stats({ stream: false });
@@ -9,7 +15,15 @@ export async function getStats(containerId) {
     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;
+  
+  // Get number of CPUs for proper normalization
+  const numCpus = stream.cpu_stats.online_cpus || 
+                  stream.cpu_stats.cpu_usage.percpu_usage?.length || 1;
+  
+  // Calculate normalized CPU percentage
+  const cpuPercent = systemDelta > 0 
+    ? ((cpuDelta / systemDelta) * numCpus * 100) 
+    : 0;
 
   const memUsage = stream.memory_stats.usage || 0;
   const memLimit = stream.memory_stats.limit || 1;

package/src/helpers/dockerService/serviceComponents/imageUtils.js

@@ -1,5 +1,10 @@
 import { docker } from "../dockerService";
 
+/**
+ * Check whether an image exists locally.
+ * @param {string} imageName - Image name or tag
+ * @returns {Promise<boolean>}
+ */
 export async function imageExists(imageName) {
   const images = await docker.listImages();
   return images.some(img =>
@@ -8,6 +13,11 @@ export async function imageExists(imageName) {
   );
 }
 
+/**
+ * Pull an image from the registry.
+ * @param {string} imageName - Image name to pull
+ * @returns {Promise<void>}
+ */
 export async function pullImage(imageName) {
   await new Promise((resolve, reject) => {
     docker.pull(imageName, (err, stream) => {

package/src/helpers/exitWithMessage.js

@@ -1,5 +1,15 @@
 import { spawn } from "child_process";
 
+/**
+ * Show an exit message using provided setters, clear the terminal and exit after a delay.
+ *
+ * @param {Object} params
+ * @param {Function} params.setMessage - Setter for message text
+ * @param {Function} params.setMessageColor - Setter for message color
+ * @param {string} [params.message] - Message to display
+ * @param {string} [params.color] - Color for the message
+ * @param {number} [params.delay] - Delay in milliseconds before exiting
+ */
 export function exitWithMessage({ setMessage, setMessageColor, message = "Exiting...", color = "yellow", delay = 1500 }) {
   setMessage(message);
   setMessageColor(color);

package/src/helpers/validationHelpers.js

@@ -11,6 +11,18 @@ export function validatePorts(portInput) {
 }
 
 export function validateEnvVars(envInput) {
-  // Future specific validations
-  return true;
+  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;
 }

package/src/hooks/creation/useContainerCreation.js

@@ -42,12 +42,8 @@ export function useContainerCreation({ onCreate, onCancel, dbImages = [] }) {
       return;
     }
     if (step === 2) {
-      if (!portInput.trim()) {
-        setMessage("You must specify at least one port to expose (e.g. 8080:80)");
-        setMessageColor("red");
-        return;
-      }
-      if (!validatePorts(portInput)) {
+      // Ports are now optional - only validate if provided
+      if (portInput.trim() && !validatePorts(portInput)) {
         setMessage("Port format must be host:container and both must be numbers (e.g. 8080:80)");
         setMessageColor("red");
         return;

package/src/hooks/useContainers.js

@@ -1,11 +1,9 @@
 /**
  * React hook to manage Docker containers state.
- * Hook de React para gestionar el estado de contenedores Docker.
  *
  * @returns {[Array, Function]} [containers, refresh] / [contenedores, refrescar]
  * @example
- * // EN: Use in a component
- * // ES: Usar en un componente
+ * // Use in a component
  * const [containers, refresh] = useContainers();
  */
 import React, { useState, useEffect } from "react";

package/src/hooks/useControls.js

@@ -7,6 +7,29 @@ import { getLogsStream } from "../helpers/dockerService/serviceComponents/contai
 import { createContainer as svcCreateContainer } from "../helpers/dockerService/serviceComponents/containerActions.js";
 
 // Principal hook to manage user inputs and control the app state
+/**
+ * Main hook that wires user input, creation, actions and logs viewing.
+ * It coordinates the modular hooks and exposes a compact API consumed by the App.
+ *
+ * @param {Array<Object>} containers - Current list of Docker containers
+ * @returns {Object} controls - API for the App component
+ * @property {number} selected - Index of the currently selected container
+ * @property {function} setSelected - Setter for selected index
+ * @property {string} message - Current feedback message (creation or actions)
+ * @property {string} messageColor - Color to show for the feedback message
+ * @property {boolean} showLogs - Whether the logs viewer is active
+ * @property {Array<string>} logs - Array of log lines currently collected
+ * @property {function} exitLogs - Helper to close the logs viewer
+ * @property {boolean} creatingContainer - Whether the create-container prompt is open
+ * @property {number} creationStep - Current step in the creation flow
+ * @property {string} imageNameInput - Current value of the image name field
+ * @property {string} containerNameInput - Current value of the container name field
+ * @property {string} portInput - Current value of the port input field
+ * @property {string} envInput - Current value of the env input field
+ * @property {Object} creation - The creation hook API (setters and helpers)
+ * @property {Object} actions - The actions hook API (helpers to start/stop/remove)
+ * @property {Object} logsViewer - The logs viewer hook API
+ */
 export function useControls(containers = []) {
   const [selected, setSelected] = React.useState(0);
   const [creatingContainer, setCreatingContainer] = React.useState(false);
@@ -61,7 +84,7 @@ export function useControls(containers = []) {
   const exitLogs = logsViewer.closeLogs;
 
   useInput((input, key) => {
-    // Confirmación de borrado
+  // Erase confirmation
     if (confirmErase) {
       if (input === "y" || input === "Y") {
         actions.handleAction({
@@ -177,7 +200,11 @@ export function useControls(containers = []) {
       logsViewer.openLogs();
       getLogsStream(
         containers[selected].id,
-        (data) => logsViewer.setLogs((prev) => [...prev, ...data.split("\n").filter(Boolean)]),
+        (data) => logsViewer.setLogs((prev) => {
+          const newLogs = [...prev, ...data.split("\n").filter(Boolean)];
+          // Limit to last 1000 lines to prevent memory leak
+          return newLogs.slice(-1000);
+        }),
         () => {},
         (err) => logsViewer.setLogs((prev) => [...prev, `Error: ${err.message}`])
       );

package/src/hooks/useLogsStream.js

@@ -1,6 +1,11 @@
 import React, { useRef, useCallback } from "react";
 import { getLogsStream } from "../helpers/dockerService/serviceComponents/containerLogs";
 
+/**
+ * Hook that manages opening and closing a logs stream for a container.
+ *
+ * @returns {Object} { openLogs, closeLogs }
+ */
 export function useLogsStream() {
   const logsStreamRef = useRef(null);
 

package/src/index.js

@@ -1,17 +1,13 @@
 #!/usr/bin/env node
-
 /**
  * Entry point for the CDD CLI application.
- * Punto de entrada para la aplicación CLI de CDD.
  *
  * @module index
  * @example
- * // EN: Run the CLI
- * // ES: Ejecutar el CLI
+ * // Run the CLI
  * node index.js
  */
 
-
 import React from "react";
 import { render } from "ink";
 import App from './App';

package/test/validationHelpers.test.js

@@ -1,8 +1,10 @@
 let validatePorts;
+let validateEnvVars;
 
 beforeAll(async () => {
   const mod = await import('../src/helpers/validationHelpers.js');
   validatePorts = mod.validatePorts;
+  validateEnvVars = mod.validateEnvVars;
 });
 
 describe('validatePorts', () => {
@@ -26,3 +28,33 @@ describe('validatePorts', () => {
     expect(validatePorts('')).toBe(false);
   });
 });
+
+describe('validateEnvVars', () => {
+  test('empty input is valid', () => {
+    expect(validateEnvVars('')).toBe(true);
+  });
+
+  test('valid single env var', () => {
+    expect(validateEnvVars('NODE_ENV=production')).toBe(true);
+  });
+
+  test('valid multiple env vars', () => {
+    expect(validateEnvVars('NODE_ENV=production,PORT=3000')).toBe(true);
+  });
+
+  test('valid env var with underscores', () => {
+    expect(validateEnvVars('MY_VAR_NAME=value')).toBe(true);
+  });
+
+  test('invalid env var without equals sign', () => {
+    expect(validateEnvVars('NOEQUALS')).toBe(false);
+  });
+
+  test('invalid env var with invalid name', () => {
+    expect(validateEnvVars('123INVALID=value')).toBe(false);
+  });
+
+  test('invalid env var with special characters in name', () => {
+    expect(validateEnvVars('MY-VAR=value')).toBe(false);
+  });
+});