cdd-cli 4.0.0 → 4.1.0

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

@@ -1,282 +0,0 @@
-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
- * within `ms` milliseconds it will reject with an Error.
- *
- * @template T
- * @param {Promise<T>} promise - Promise to wrap
- * @param {number} [ms=TIMEOUTS.CONTAINER_OP] - Timeout in milliseconds
- * @returns {Promise<T>} The original promise result or a rejection on timeout
- */
-function withTimeout(promise, ms = TIMEOUTS.CONTAINER_OP) {
-  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) {
-  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);
-  } catch (err) {
-    logger.error('Failed to remove container %s', containerId, err);
-    throw new Error('Error removing container: ' + err.message);
-  }
-}
-
-/**
- * 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.)
- * @param {Object} [imageProfiles] - Image profiles map for defaultPort fallback
- * @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);
-  let exists;
-  try {
-    exists = await withTimeout(imageExists(imageName), 10000);
-  } catch (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);
-    try {
-      await withTimeout(pullImage(imageName), TIMEOUTS.PULL_IMAGE);
-      logger.info('Pulled image %s', imageName);
-    } catch (err) {
-      logger.error('Failed to pull image %s', imageName, err);
-      throw new Error('Could not pull image: ' + err.message);
-    }
-  }
-  const createOpts = {
-    Image: imageName,
-    Tty: true,
-    ...options,
-  };
-
-  const hasUserDefinedPorts = Boolean(
-    createOpts.ExposedPorts && Object.keys(createOpts.ExposedPorts).length
-  );
-
-  /** @type {Array<{containerPort: string, hostPort: string, protocol: string, source: string}>} */
-  const assignedPorts = [];
-
-  if (!hasUserDefinedPorts) {
-    try {
-      const image = docker.getImage(imageName);
-      if (image && typeof image.inspect === 'function') {
-        let usedHostPorts = new Set();
-        if (typeof docker.listContainers === 'function') {
-          try {
-            const containers = await withTimeout(
-              docker.listContainers({ all: true }),
-              TIMEOUTS.CONTAINER_OP
-            );
-            containers.forEach((container) => {
-              (container.Ports || []).forEach((portInfo) => {
-                if (portInfo && portInfo.PublicPort) {
-                  usedHostPorts.add(String(portInfo.PublicPort));
-                }
-              });
-            });
-          } catch (err) {
-            logger.warn(
-              'Could not inspect existing containers to auto-map ports',
-              err
-            );
-          }
-        }
-        const reservePort = (port) => {
-          const portStr = String(port);
-          usedHostPorts.add(portStr);
-        };
-        const pickNextAvailablePort = (base) => {
-          const numericBase = Number.parseInt(base, 10);
-          if (Number.isNaN(numericBase)) {
-            if (!usedHostPorts.has(base)) {
-              usedHostPorts.add(base);
-              return base;
-            }
-            let counter = 1;
-            let candidate = `${base}-${counter}`;
-            while (usedHostPorts.has(candidate)) {
-              counter += 1;
-              candidate = `${base}-${counter}`;
-            }
-            usedHostPorts.add(candidate);
-            return candidate;
-          }
-          let candidate = numericBase;
-          while (usedHostPorts.has(String(candidate))) {
-            candidate += 1;
-          }
-          reservePort(candidate);
-          return String(candidate);
-        };
-
-        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
-        if (!exposedKeys.length) {
-          const baseName = normalizeImageName(imageName);
-          const profile = imageProfiles[baseName];
-          if (profile && profile.defaultPort) {
-            const fallbackKey = `${profile.defaultPort}/tcp`;
-            exposed = { [fallbackKey]: {} };
-            exposedKeys = [fallbackKey];
-          }
-        }
-
-        if (exposedKeys.length) {
-          createOpts.ExposedPorts = createOpts.ExposedPorts || {};
-          createOpts.HostConfig = { ...(createOpts.HostConfig || {}) };
-          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('/');
-              const containerPort = parts[0];
-              const protocol = parts[1] || 'tcp';
-              const hostPort = pickNextAvailablePort(containerPort);
-              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
-      );
-    }
-  } 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 containerPort = parts[0];
-      const protocol = parts[1] || 'tcp';
-      (bindings || []).forEach((b) => {
-        assignedPorts.push({
-          containerPort,
-          hostPort: b.HostPort,
-          protocol,
-          source: 'user',
-        });
-      });
-    });
-  }
-
-  try {
-    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);
-    return { id: containerId, ports: assignedPorts };
-  } catch (err) {
-    logger.error('Failed to create container from image %s', imageName, 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);
-  logger.debug('Starting container %s', containerId);
-  try {
-    await withTimeout(container.start(), TIMEOUTS.CONTAINER_OP);
-    logger.info('Started container %s', containerId);
-  } catch (err) {
-    logger.error('Failed to start container %s', containerId, err);
-    throw err;
-  }
-}
-
-/**
- * Stop a container by id.
- * @param {string} containerId - Docker container id
- * @returns {Promise<void>}
- */
-export async function stopContainer(containerId) {
-  const container = docker.getContainer(containerId);
-  logger.debug('Stopping container %s', containerId);
-  try {
-    await withTimeout(container.stop(), TIMEOUTS.CONTAINER_OP);
-    logger.info('Stopped container %s', containerId);
-  } catch (err) {
-    logger.error('Failed to stop container %s', containerId, err);
-    throw err;
-  }
-}
-
-/**
- * Restart a container by id.
- * @param {string} containerId - Docker container id
- * @returns {Promise<void>}
- */
-export async function restartContainer(containerId) {
-  const container = docker.getContainer(containerId);
-  logger.debug('Restarting container %s', containerId);
-  try {
-    await withTimeout(container.restart(), TIMEOUTS.CONTAINER_OP);
-    logger.info('Restarted container %s', containerId);
-  } catch (err) {
-    logger.error('Failed to restart container %s', containerId, err);
-    throw err;
-  }
-}

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

@@ -1,74 +0,0 @@
-import { docker } from '../dockerService.js';
-import { logger } from '../../logger.js';
-
-const DEFAULT_CONTAINER_NAME = 'Unknown';
-
-/**
- * Produce a safe, display-friendly container name from the raw Docker payload.
- *
- * @param {Object} container Docker container summary as returned by dockerode.
- * @returns {string} Normalized name without leading slashes and with a fallback applied.
- */
-function normalizeContainerName(container) {
-  const names = container?.Names;
-
-  let rawName;
-  if (
-    Array.isArray(names) &&
-    names.length > 0 &&
-    typeof names[0] === 'string'
-  ) {
-    rawName = names[0];
-  } else if (typeof names === 'string' && names.trim().length > 0) {
-    rawName = names;
-  } else if (
-    typeof container?.Name === 'string' &&
-    container.Name.trim().length > 0
-  ) {
-    rawName = container.Name;
-  } else {
-    rawName = DEFAULT_CONTAINER_NAME;
-  }
-
-  if (typeof rawName !== 'string') {
-    return DEFAULT_CONTAINER_NAME;
-  }
-
-  const cleanedName = rawName.replace(/^\/+/u, '').trim();
-  return cleanedName.length > 0 ? cleanedName : DEFAULT_CONTAINER_NAME;
-}
-
-/**
- * Return a list of containers with normalized fields for the UI.
- * @returns {Promise<Array<Object>>}
- */
-export async function getContainers() {
-  logger.debug('Listing containers');
-  try {
-    const containers = await docker.listContainers({ all: true });
-    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)];
-      })(),
-    }));
-  } catch (err) {
-    logger.error('Failed to list containers', err);
-    throw err;
-  }
-}

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

@@ -1,60 +0,0 @@
-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.
- *
- * @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) {
-  // Use shared safeCall util to call optional callbacks safely
-
-  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.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
-    );
-    safeCall(onError, err);
-  }
-}

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

@@ -1,69 +0,0 @@
-import { docker } from '../dockerService.js';
-import { logger } from '../../logger.js';
-
-/**
- * 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);
-  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);
-    throw err;
-  }
-
-  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;
-
-  // Get number of CPUs for proper normalization
-  let numCpus = 1;
-  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 &&
-    Array.isArray(stream.cpu_stats.cpu_usage.percpu_usage) &&
-    stream.cpu_stats.cpu_usage.percpu_usage.length > 0
-  ) {
-    numCpus = stream.cpu_stats.cpu_usage.percpu_usage.length;
-  }
-
-  // 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;
-  const memPercent = (memUsage / memLimit) * 100;
-
-  const rx = stream.networks
-    ? Object.values(stream.networks)
-        .map((n) => n.rx_bytes)
-        .reduce((a, b) => a + b, 0)
-    : 0;
-  const tx = stream.networks
-    ? Object.values(stream.networks)
-        .map((n) => n.tx_bytes)
-        .reduce((a, b) => a + b, 0)
-    : 0;
-
-  const snapshot = {
-    cpuPercent: cpuPercent.toFixed(1),
-    memPercent: memPercent.toFixed(1),
-    netIO: { rx, tx },
-  };
-
-  logger.debug('Stats fetched for container %s', containerId, snapshot);
-  return snapshot;
-}

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

@@ -1,32 +0,0 @@
-import { docker } from '../dockerService.js';
-
-/**
- * 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) =>
-      (img.RepoTags || []).includes(imageName) ||
-      (img.RepoDigests || []).some((d) => d.includes(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) => {
-      if (err) return reject(new Error('Error pulling image: ' + err.message));
-      docker.modem.followProgress(stream, (pullErr) => {
-        if (pullErr) reject(new Error('Error during pull: ' + pullErr.message));
-        else resolve();
-      });
-    });
-  });
-}

package/src/helpers/exitWithMessage.js

@@ -1,32 +0,0 @@
-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.
- *
- * @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 = EXIT_DELAY,
-}) {
-  setMessage(message);
-  setMessageColor(color);
-  setTimeout(() => {
-    setMessage('');
-    if (process.platform === 'win32') {
-      spawn('cmd', ['/c', 'cls'], { stdio: 'inherit' });
-    } else {
-      spawn('clear', [], { stdio: 'inherit' });
-    }
-    process.exit();
-  }, delay);
-}

package/src/helpers/imageNameUtils.js

@@ -1,32 +0,0 @@
-/**
- * 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();
-}

package/src/helpers/logger.js

@@ -1,112 +0,0 @@
-/**
- * Supported log levels in ascending verbosity.
- * Lower numeric values represent higher severity.
- */
-const LOG_LEVELS = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-};
-
-/**
- * @typedef {Object} LogEntry
- * @property {string} level Severity string (error, warn, info, debug)
- * @property {string} message Primary log message
- * @property {any[]} args Additional payload values forwarded to listeners
- * @property {string} timestamp ISO timestamp when the entry was created
- * @property {string} formatted Preformatted message used for console output
- */
-
-/**
- * @callback LogListener
- * @param {LogEntry} entry Log entry data emitted by the logger
- */
-
-function parseLevel(value) {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized in LOG_LEVELS) {
-    return LOG_LEVELS[normalized];
-  }
-  return null;
-}
-
-const envLevel =
-  parseLevel(process.env.CDD_LOG_LEVEL) ??
-  parseLevel(process.env.LOG_LEVEL) ??
-  LOG_LEVELS.info;
-
-const currentLevel = typeof envLevel === 'number' ? envLevel : LOG_LEVELS.info;
-
-const listeners = new Set();
-
-function shouldLog(level) {
-  const target = LOG_LEVELS[level];
-  return typeof target === 'number' && target <= currentLevel;
-}
-
-function log(level, message, ...args) {
-  if (!shouldLog(level)) {
-    return;
-  }
-
-  const timestamp = new Date().toISOString();
-  const upperLevel = level.toUpperCase();
-  const formatted = `[${timestamp}] [${upperLevel}] ${message}`;
-  const entry = { level, message, args, timestamp, formatted };
-
-  const shouldWriteToConsole = listeners.size === 0;
-
-  if (shouldWriteToConsole) {
-    const method = level === 'debug' ? 'log' : level;
-    if (typeof console[method] === 'function') {
-      console[method](formatted, ...args);
-    } else {
-      console.log(formatted, ...args);
-    }
-  }
-
-  listeners.forEach((listener) => {
-    try {
-      listener(entry);
-    } catch (err) {
-      // Ignore listener errors so logging remains resilient.
-    }
-  });
-}
-
-/**
- * Shared logger instance with leveled output and in-memory subscriptions.
- * Consumers can import `{ logger }` to emit messages or to listen for
- * log entries (used by the CLI debug panel).
- */
-export const logger = {
-  debug(message, ...args) {
-    log('debug', message, ...args);
-  },
-  info(message, ...args) {
-    log('info', message, ...args);
-  },
-  warn(message, ...args) {
-    log('warn', message, ...args);
-  },
-  error(message, ...args) {
-    log('error', message, ...args);
-  },
-  /**
-   * Subscribe to log events.
-   *
-   * @param {LogListener} listener Listener invoked for every log entry that passes the current level filter.
-   * @returns {function(): void} Cleanup function that removes the listener when called.
-   */
-  subscribe(listener) {
-    if (typeof listener !== 'function') {
-      return () => {};
-    }
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  },
-};