cdd-cli 3.2.0 → 4.0.0

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

@@ -1,7 +1,8 @@
-import { docker } from "../dockerService.js";
-import { imageExists, pullImage } from "./imageUtils.js";
-import { TIMEOUTS, IMAGE_PROFILES } from "../../constants.js";
-import { logger } from "../../logger.js";
+import { docker } from '../dockerService.js';
+import { imageExists, pullImage } from './imageUtils.js';
+import { TIMEOUTS, IMAGE_PROFILES } from '../../constants.js';
+import { logger } from '../../logger.js';
+import { normalizeImageName } from '../../imageNameUtils.js';
 
 /**
  * Helper to add timeout to promises. If the provided promise does not settle
@@ -15,9 +16,9 @@ import { logger } from "../../logger.js";
 function withTimeout(promise, ms = TIMEOUTS.CONTAINER_OP) {
   return Promise.race([
     promise,
-    new Promise((_, reject) => 
+    new Promise((_, reject) =>
       setTimeout(() => reject(new Error('Operation timed out')), ms)
-    )
+    ),
   ]);
 }
 
@@ -29,34 +30,17 @@ function withTimeout(promise, ms = TIMEOUTS.CONTAINER_OP) {
  * @throws {Error} If Docker reports an error
  */
 export async function removeContainer(containerId) {
-  logger.debug("Removing container %s", containerId);
+  logger.debug('Removing container %s', containerId);
   const container = docker.getContainer(containerId);
   try {
     await withTimeout(container.remove({ force: true }), TIMEOUTS.CONTAINER_OP);
-    logger.info("Removed container %s", containerId);
+    logger.info('Removed container %s', containerId);
   } catch (err) {
-    logger.error("Failed to remove container %s", containerId, err);
+    logger.error('Failed to remove container %s', containerId, err);
     throw new Error('Error removing container: ' + err.message);
   }
 }
 
-/**
- * Normalize image name to base name (strips registry prefix and tag).
- * e.g. "docker.io/library/postgres:16" → "postgres"
- *
- * @param {string} imageName - Raw image name
- * @returns {string} Base name (lowercase)
- */
-function normalizeImageName(imageName) {
-  if (!imageName) return "";
-  let name = imageName;
-  const slashIdx = name.lastIndexOf("/");
-  if (slashIdx !== -1) name = name.slice(slashIdx + 1);
-  const colonIdx = name.indexOf(":");
-  if (colonIdx !== -1) name = name.slice(0, colonIdx);
-  return name.toLowerCase();
-}
-
 /**
  * Create a new container from an image. If the image is missing locally, it will be pulled.
  *
@@ -66,22 +50,26 @@ function normalizeImageName(imageName) {
  * @returns {Promise<{id: string, ports: Array<{containerPort: string, hostPort: string, protocol: string, source: string}>}>}
  * @throws {Error} If image listing/pull or creation fails
  */
-export async function createContainer(imageName, options = {}, imageProfiles = IMAGE_PROFILES) {
-  logger.info("Creating container from image %s", imageName);
+export async function createContainer(
+  imageName,
+  options = {},
+  imageProfiles = IMAGE_PROFILES
+) {
+  logger.info('Creating container from image %s', imageName);
   let exists;
   try {
     exists = await withTimeout(imageExists(imageName), 10000);
   } catch (err) {
-    logger.error("Could not check local images for %s", imageName, err);
+    logger.error('Could not check local images for %s', imageName, err);
     throw new Error('Error listing local images: ' + err.message);
   }
   if (!exists) {
-    logger.info("Image %s not found locally, pulling", imageName);
+    logger.info('Image %s not found locally, pulling', imageName);
     try {
       await withTimeout(pullImage(imageName), TIMEOUTS.PULL_IMAGE);
-      logger.info("Pulled image %s", imageName);
+      logger.info('Pulled image %s', imageName);
     } catch (err) {
-      logger.error("Failed to pull image %s", imageName, err);
+      logger.error('Failed to pull image %s', imageName, err);
       throw new Error('Could not pull image: ' + err.message);
     }
   }
@@ -91,7 +79,9 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
     ...options,
   };
 
-  const hasUserDefinedPorts = Boolean(createOpts.ExposedPorts && Object.keys(createOpts.ExposedPorts).length);
+  const hasUserDefinedPorts = Boolean(
+    createOpts.ExposedPorts && Object.keys(createOpts.ExposedPorts).length
+  );
 
   /** @type {Array<{containerPort: string, hostPort: string, protocol: string, source: string}>} */
   const assignedPorts = [];
@@ -99,11 +89,14 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
   if (!hasUserDefinedPorts) {
     try {
       const image = docker.getImage(imageName);
-      if (image && typeof image.inspect === "function") {
+      if (image && typeof image.inspect === 'function') {
         let usedHostPorts = new Set();
-        if (typeof docker.listContainers === "function") {
+        if (typeof docker.listContainers === 'function') {
           try {
-            const containers = await withTimeout(docker.listContainers({ all: true }), TIMEOUTS.CONTAINER_OP);
+            const containers = await withTimeout(
+              docker.listContainers({ all: true }),
+              TIMEOUTS.CONTAINER_OP
+            );
             containers.forEach((container) => {
               (container.Ports || []).forEach((portInfo) => {
                 if (portInfo && portInfo.PublicPort) {
@@ -112,7 +105,10 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
               });
             });
           } catch (err) {
-            logger.warn("Could not inspect existing containers to auto-map ports", err);
+            logger.warn(
+              'Could not inspect existing containers to auto-map ports',
+              err
+            );
           }
         }
         const reservePort = (port) => {
@@ -143,8 +139,14 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
           return String(candidate);
         };
 
-        const inspectData = await withTimeout(image.inspect(), TIMEOUTS.CONTAINER_OP);
-        let exposed = inspectData?.Config?.ExposedPorts || inspectData?.ContainerConfig?.ExposedPorts || {};
+        const inspectData = await withTimeout(
+          image.inspect(),
+          TIMEOUTS.CONTAINER_OP
+        );
+        let exposed =
+          inspectData?.Config?.ExposedPorts ||
+          inspectData?.ContainerConfig?.ExposedPorts ||
+          {};
         let exposedKeys = Object.keys(exposed || {});
 
         // If no ExposedPorts in image, fall back to IMAGE_PROFILES defaultPort
@@ -161,45 +163,69 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
         if (exposedKeys.length) {
           createOpts.ExposedPorts = createOpts.ExposedPorts || {};
           createOpts.HostConfig = { ...(createOpts.HostConfig || {}) };
-          createOpts.HostConfig.PortBindings = { ...(createOpts.HostConfig.PortBindings || {}) };
+          createOpts.HostConfig.PortBindings = {
+            ...(createOpts.HostConfig.PortBindings || {}),
+          };
           exposedKeys.forEach((portKey) => {
             if (!createOpts.ExposedPorts[portKey]) {
               createOpts.ExposedPorts[portKey] = exposed[portKey] || {};
             }
-            if (!createOpts.HostConfig.PortBindings[portKey] || !createOpts.HostConfig.PortBindings[portKey].length) {
-              const parts = portKey.split("/");
+            if (
+              !createOpts.HostConfig.PortBindings[portKey] ||
+              !createOpts.HostConfig.PortBindings[portKey].length
+            ) {
+              const parts = portKey.split('/');
               const containerPort = parts[0];
-              const protocol = parts[1] || "tcp";
+              const protocol = parts[1] || 'tcp';
               const hostPort = pickNextAvailablePort(containerPort);
-              createOpts.HostConfig.PortBindings[portKey] = [{ HostPort: hostPort }];
-              assignedPorts.push({ containerPort, hostPort, protocol, source: "auto" });
+              createOpts.HostConfig.PortBindings[portKey] = [
+                { HostPort: hostPort },
+              ];
+              assignedPorts.push({
+                containerPort,
+                hostPort,
+                protocol,
+                source: 'auto',
+              });
             }
           });
         }
       }
     } catch (err) {
-      logger.warn("Could not inspect image %s for default ports", imageName, err);
+      logger.warn(
+        'Could not inspect image %s for default ports',
+        imageName,
+        err
+      );
     }
   } else {
     // User-defined ports: collect them with source: "user"
     const portBindings = createOpts.HostConfig?.PortBindings || {};
     Object.entries(portBindings).forEach(([portKey, bindings]) => {
-      const parts = portKey.split("/");
+      const parts = portKey.split('/');
       const containerPort = parts[0];
-      const protocol = parts[1] || "tcp";
+      const protocol = parts[1] || 'tcp';
       (bindings || []).forEach((b) => {
-        assignedPorts.push({ containerPort, hostPort: b.HostPort, protocol, source: "user" });
+        assignedPorts.push({
+          containerPort,
+          hostPort: b.HostPort,
+          protocol,
+          source: 'user',
+        });
       });
     });
   }
 
   try {
-    const container = await withTimeout(docker.createContainer(createOpts), TIMEOUTS.CONTAINER_OP);
+    const container = await withTimeout(
+      docker.createContainer(createOpts),
+      TIMEOUTS.CONTAINER_OP
+    );
     const containerId = container.id || container.Id;
-    logger.info("Created container %s from image %s", containerId, imageName);
+    logger.info('Created container %s from image %s', containerId, imageName);
     return { id: containerId, ports: assignedPorts };
   } catch (err) {
-    logger.error("Failed to create container from image %s", imageName, err);
+    logger.error('Failed to create container from image %s', imageName, err);
     throw new Error('Error creating container: ' + err.message);
   }
 }
@@ -211,12 +237,12 @@ export async function createContainer(imageName, options = {}, imageProfiles = I
  */
 export async function startContainer(containerId) {
   const container = docker.getContainer(containerId);
-  logger.debug("Starting container %s", containerId);
+  logger.debug('Starting container %s', containerId);
   try {
     await withTimeout(container.start(), TIMEOUTS.CONTAINER_OP);
-    logger.info("Started container %s", containerId);
+    logger.info('Started container %s', containerId);
   } catch (err) {
-    logger.error("Failed to start container %s", containerId, err);
+    logger.error('Failed to start container %s', containerId, err);
     throw err;
   }
 }
@@ -228,12 +254,12 @@ export async function startContainer(containerId) {
  */
 export async function stopContainer(containerId) {
   const container = docker.getContainer(containerId);
-  logger.debug("Stopping container %s", containerId);
+  logger.debug('Stopping container %s', containerId);
   try {
     await withTimeout(container.stop(), TIMEOUTS.CONTAINER_OP);
-    logger.info("Stopped container %s", containerId);
+    logger.info('Stopped container %s', containerId);
   } catch (err) {
-    logger.error("Failed to stop container %s", containerId, err);
+    logger.error('Failed to stop container %s', containerId, err);
     throw err;
   }
 }
@@ -245,12 +271,12 @@ export async function stopContainer(containerId) {
  */
 export async function restartContainer(containerId) {
   const container = docker.getContainer(containerId);
-  logger.debug("Restarting container %s", containerId);
+  logger.debug('Restarting container %s', containerId);
   try {
     await withTimeout(container.restart(), TIMEOUTS.CONTAINER_OP);
-    logger.info("Restarted container %s", containerId);
+    logger.info('Restarted container %s', containerId);
   } catch (err) {
-    logger.error("Failed to restart container %s", containerId, err);
+    logger.error('Failed to restart container %s', containerId, err);
     throw err;
   }
 }

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

@@ -1,7 +1,7 @@
-import { docker } from "../dockerService.js";
-import { logger } from "../../logger.js";
+import { docker } from '../dockerService.js';
+import { logger } from '../../logger.js';
 
-const DEFAULT_CONTAINER_NAME = "Unknown";
+const DEFAULT_CONTAINER_NAME = 'Unknown';
 
 /**
  * Produce a safe, display-friendly container name from the raw Docker payload.
@@ -13,21 +13,28 @@ function normalizeContainerName(container) {
   const names = container?.Names;
 
   let rawName;
-  if (Array.isArray(names) && names.length > 0 && typeof names[0] === "string") {
+  if (
+    Array.isArray(names) &&
+    names.length > 0 &&
+    typeof names[0] === 'string'
+  ) {
     rawName = names[0];
-  } else if (typeof names === "string" && names.trim().length > 0) {
+  } else if (typeof names === 'string' && names.trim().length > 0) {
     rawName = names;
-  } else if (typeof container?.Name === "string" && container.Name.trim().length > 0) {
+  } else if (
+    typeof container?.Name === 'string' &&
+    container.Name.trim().length > 0
+  ) {
     rawName = container.Name;
   } else {
     rawName = DEFAULT_CONTAINER_NAME;
   }
 
-  if (typeof rawName !== "string") {
+  if (typeof rawName !== 'string') {
     return DEFAULT_CONTAINER_NAME;
   }
 
-  const cleanedName = rawName.replace(/^\/+/u, "").trim();
+  const cleanedName = rawName.replace(/^\/+/u, '').trim();
   return cleanedName.length > 0 ? cleanedName : DEFAULT_CONTAINER_NAME;
 }
 
@@ -36,33 +43,32 @@ function normalizeContainerName(container) {
  * @returns {Promise<Array<Object>>}
  */
 export async function getContainers() {
-  logger.debug("Listing containers");
+  logger.debug('Listing containers');
   try {
     const containers = await docker.listContainers({ all: true });
-    logger.debug("Retrieved %d containers", containers.length);
+    logger.debug('Retrieved %d containers', containers.length);
     return containers.map((container) => ({
       id: container.Id,
       name: normalizeContainerName(container),
       image: container.Image,
       state: container.State,
       status: container.Status,
-      ports:
-        (() => {
-          const publicPorts = container.Ports.filter((port) => port.PublicPort).map(
-            (port) => `${port.PublicPort}:${port.PrivatePort}`
-          );
-          if (publicPorts.length > 0) {
-            return [...new Set(publicPorts)];
-          }
-          // Fall back to exposed private ports when there are no bindings.
-          const privatePorts = container.Ports.filter((port) => port.PrivatePort).map(
-            (port) => `${port.PrivatePort}`
-          );
-          return [...new Set(privatePorts)];
-        })()
+      ports: (() => {
+        const publicPorts = container.Ports.filter(
+          (port) => port.PublicPort
+        ).map((port) => `${port.PublicPort}:${port.PrivatePort}`);
+        if (publicPorts.length > 0) {
+          return [...new Set(publicPorts)];
+        }
+        // Fall back to exposed private ports when there are no bindings.
+        const privatePorts = container.Ports.filter(
+          (port) => port.PrivatePort
+        ).map((port) => `${port.PrivatePort}`);
+        return [...new Set(privatePorts)];
+      })(),
     }));
   } catch (err) {
-    logger.error("Failed to list containers", err);
+    logger.error('Failed to list containers', err);
     throw err;
   }
 }

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

@@ -1,6 +1,6 @@
-import { docker } from "../dockerService.js";
-import { safeCall } from "../../safeCall.js";
-import { logger } from "../../logger.js";
+import { docker } from '../dockerService.js';
+import { safeCall } from '../../safeCall.js';
+import { logger } from '../../logger.js';
 
 /**
  * Return a stream of logs from a container and call callbacks for events.
@@ -15,31 +15,46 @@ export function getLogsStream(containerId, onData, onEnd, onError) {
 
   try {
     const container = docker.getContainer(containerId);
-    logger.debug("Opening logs stream for container %s", containerId);
-    container.logs({
-      follow: true,
-      stdout: true,
-      stderr: true,
-      tail: 100
-    }, (err, stream) => {
-      if (err) {
-        logger.error("Failed to open logs stream for container %s", containerId, err);
-        safeCall(onError, err);
-        return;
+    logger.debug('Opening logs stream for container %s', containerId);
+    container.logs(
+      {
+        follow: true,
+        stdout: true,
+        stderr: true,
+        tail: 100,
+      },
+      (err, stream) => {
+        if (err) {
+          logger.error(
+            'Failed to open logs stream for container %s',
+            containerId,
+            err
+          );
+          safeCall(onError, err);
+          return;
+        }
+        logger.info('Logs stream established for container %s', containerId);
+        stream.on('data', (chunk) => safeCall(onData, chunk.toString()));
+        stream.on('end', () => {
+          logger.debug('Logs stream ended for container %s', containerId);
+          safeCall(onEnd);
+        });
+        stream.on('error', (streamErr) => {
+          logger.error(
+            'Logs stream error for container %s',
+            containerId,
+            streamErr
+          );
+          safeCall(onError, streamErr);
+        });
       }
-      logger.info("Logs stream established for container %s", containerId);
-      stream.on('data', chunk => safeCall(onData, chunk.toString()));
-      stream.on('end', () => {
-        logger.debug("Logs stream ended for container %s", containerId);
-        safeCall(onEnd);
-      });
-      stream.on('error', streamErr => {
-        logger.error("Logs stream error for container %s", containerId, streamErr);
-        safeCall(onError, streamErr);
-      });
-    });
+    );
   } catch (err) {
-    logger.error("Unexpected error while opening logs stream for container %s", containerId, err);
+    logger.error(
+      'Unexpected error while opening logs stream for container %s',
+      containerId,
+      err
+    );
     safeCall(onError, err);
   }
 }

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

@@ -1,5 +1,5 @@
-import { docker } from "../dockerService.js";
-import { logger } from "../../logger.js";
+import { docker } from '../dockerService.js';
+import { logger } from '../../logger.js';
 
 /**
  * Retrieve a snapshot of container resource usage (CPU, memory, network).
@@ -9,12 +9,12 @@ import { logger } from "../../logger.js";
  */
 export async function getStats(containerId) {
   const container = docker.getContainer(containerId);
-  logger.debug("Fetching stats for container %s", containerId);
+  logger.debug('Fetching stats for container %s', containerId);
   let stream;
   try {
     stream = await container.stats({ stream: false });
   } catch (err) {
-    logger.error("Failed to fetch stats for container %s", containerId, err);
+    logger.error('Failed to fetch stats for container %s', containerId, err);
     throw err;
   }
 
@@ -23,10 +23,13 @@ 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;
-  
+
   // Get number of CPUs for proper normalization
   let numCpus = 1;
-  if (typeof stream.cpu_stats.online_cpus === 'number' && stream.cpu_stats.online_cpus > 0) {
+  if (
+    typeof stream.cpu_stats.online_cpus === 'number' &&
+    stream.cpu_stats.online_cpus > 0
+  ) {
     numCpus = stream.cpu_stats.online_cpus;
   } else if (
     stream.cpu_stats.cpu_usage &&
@@ -35,11 +38,10 @@ export async function getStats(containerId) {
   ) {
     numCpus = stream.cpu_stats.cpu_usage.percpu_usage.length;
   }
-  
+
   // Calculate normalized CPU percentage
-  const cpuPercent = systemDelta > 0 
-    ? ((cpuDelta / systemDelta) * numCpus * 100) 
-    : 0;
+  const cpuPercent =
+    systemDelta > 0 ? (cpuDelta / systemDelta) * numCpus * 100 : 0;
 
   const memUsage = stream.memory_stats.usage || 0;
   const memLimit = stream.memory_stats.limit || 1;
@@ -62,6 +64,6 @@ export async function getStats(containerId) {
     netIO: { rx, tx },
   };
 
-  logger.debug("Stats fetched for container %s", containerId, snapshot);
+  logger.debug('Stats fetched for container %s', containerId, snapshot);
   return snapshot;
 }

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

@@ -1,4 +1,4 @@
-import { docker } from "../dockerService.js";
+import { docker } from '../dockerService.js';
 
 /**
  * Check whether an image exists locally.
@@ -7,9 +7,10 @@ import { docker } from "../dockerService.js";
  */
 export async function imageExists(imageName) {
   const images = await docker.listImages();
-  return images.some(img =>
-    (img.RepoTags || []).includes(imageName) ||
-    (img.RepoDigests || []).some(d => d.includes(imageName))
+  return images.some(
+    (img) =>
+      (img.RepoTags || []).includes(imageName) ||
+      (img.RepoDigests || []).some((d) => d.includes(imageName))
   );
 }
 

package/src/helpers/exitWithMessage.js

@@ -1,5 +1,5 @@
-import { spawn } from "child_process";
-import { EXIT_DELAY } from "./constants";
+import { spawn } from 'child_process';
+import { EXIT_DELAY } from './constants';
 
 /**
  * Show an exit message using provided setters, clear the terminal and exit after a delay.
@@ -11,15 +11,21 @@ import { EXIT_DELAY } from "./constants";
  * @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 = EXIT_DELAY }) {
+export function exitWithMessage({
+  setMessage,
+  setMessageColor,
+  message = 'Exiting...',
+  color = 'yellow',
+  delay = EXIT_DELAY,
+}) {
   setMessage(message);
   setMessageColor(color);
   setTimeout(() => {
-    setMessage("");
-    if (process.platform === "win32") {
-      spawn("cmd", ["/c", "cls"], { stdio: "inherit" });
+    setMessage('');
+    if (process.platform === 'win32') {
+      spawn('cmd', ['/c', 'cls'], { stdio: 'inherit' });
     } else {
-      spawn("clear", [], { stdio: "inherit" });
+      spawn('clear', [], { stdio: 'inherit' });
     }
     process.exit();
   }, delay);

package/src/helpers/imageNameUtils.js

@@ -0,0 +1,32 @@
+/**
+ * Utility for normalizing Docker image names.
+ * Extracted from validationHelpers.js and containerActions.js — both had
+ * identical implementations; consolidated here to avoid duplication.
+ */
+
+/**
+ * Normalize an image name to its base name (strips registry prefix and tag).
+ *
+ * Examples:
+ *   "docker.io/library/postgres:16-alpine" → "postgres"
+ *   "nginx:alpine"                         → "nginx"
+ *   "myregistry.io/myorg/myapp:latest"     → "myapp"
+ *
+ * @param {string} imageName - Raw image name (from user input or Docker API)
+ * @returns {string} Base image name in lowercase, empty string if input is falsy
+ */
+export function normalizeImageName(imageName) {
+  if (!imageName) return '';
+  // Remove registry prefix (everything up to and including the last '/')
+  let name = imageName;
+  const slashIdx = name.lastIndexOf('/');
+  if (slashIdx !== -1) {
+    name = name.slice(slashIdx + 1);
+  }
+  // Remove tag (everything from the first ':' onward)
+  const colonIdx = name.indexOf(':');
+  if (colonIdx !== -1) {
+    name = name.slice(0, colonIdx);
+  }
+  return name.toLowerCase();
+}