cdd-cli 3.2.2 → 4.1.0

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,113 +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 || level === 'error' || level === 'warn';
-
-  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);
-  },
-};

package/src/helpers/safeCall.js

@@ -1,18 +0,0 @@
-import { logger } from './logger.js';
-
-/**
- * Call a function safely: if it's a function call it with provided args and
- * catch any errors so they don't bubble to the host application.
- *
- * @param {Function} fn
- * @param  {...any} args
- */
-export function safeCall(fn, ...args) {
-  if (typeof fn === 'function') {
-    try {
-      return fn(...args);
-    } catch (e) {
-      logger.error('safeCall caught error', e);
-    }
-  }
-}

package/src/helpers/validationHelpers.js

@@ -1,87 +0,0 @@
-// Reusable validations for ports and environment variables
-import { normalizeImageName } from './imageNameUtils.js';
-
-/**
- * Validate a comma-separated list of port mappings in the form "host:container".
- * Examples of valid input: "8080:80, 3000:3000"
- *
- * @param {string} portInput - Comma-separated port mappings
- * @returns {boolean} True when all mappings are valid, false otherwise
- */
-export function validatePorts(portInput) {
-  // Empty or whitespace-only input is considered valid (ports are optional)
-  if (!portInput || !portInput.trim()) return true;
-  const ports = portInput
-    .split(',')
-    .map((p) => p.trim())
-    .filter(Boolean);
-  if (ports.length === 0) return true;
-  const invalid = ports.find((pair) => {
-    const [host, cont] = pair.split(':');
-    return !host || !cont || isNaN(Number(host)) || isNaN(Number(cont));
-  });
-  return !invalid;
-}
-
-/**
- * Validate environment variable input as comma-separated VAR=value pairs.
- *
- * When called with 3 arguments (envInput, imageName, imageProfiles), performs
- * contextual validation: checks that all required env vars for the given image
- * are present and non-empty. Returns an object { valid, errors, parsedEnv }.
- *
- * When called with 1 argument (legacy), returns a boolean for backward compatibility.
- *
- * @param {string} envInput - Comma-separated environment variable assignments
- * @param {string} [imageName] - Optional Docker image name for contextual validation
- * @param {Object} [imageProfiles] - Optional map of image profiles (from constants.js)
- * @returns {boolean|{valid: boolean, errors: string[], parsedEnv: Record<string,string>}}
- */
-export function validateEnvVars(envInput, imageName, imageProfiles) {
-  const contextual = imageName !== undefined && imageProfiles !== undefined;
-
-  // Parse: split on FIRST '=' only
-  const parsedEnv = {};
-  const syntaxErrors = [];
-
-  if (envInput && envInput.trim()) {
-    const vars = envInput
-      .split(',')
-      .map((v) => v.trim())
-      .filter(Boolean);
-    for (const v of vars) {
-      const eqIdx = v.indexOf('=');
-      if (eqIdx === -1) {
-        syntaxErrors.push(`"${v}" is missing an '=' sign`);
-        continue;
-      }
-      const varName = v.slice(0, eqIdx).trim();
-      const varValue = v.slice(eqIdx + 1);
-      if (!/^[A-Z_][A-Z0-9_]*$/i.test(varName)) {
-        syntaxErrors.push(`"${varName}" is not a valid variable name`);
-        continue;
-      }
-      parsedEnv[varName] = varValue;
-    }
-  }
-
-  if (!contextual) {
-    // Legacy: return boolean
-    return syntaxErrors.length === 0;
-  }
-
-  // Contextual: also check required env vars from the profile
-  const errors = [...syntaxErrors];
-  const baseName = normalizeImageName(imageName);
-  const profile = imageProfiles[baseName];
-
-  if (profile && profile.requiredEnv && profile.requiredEnv.length) {
-    for (const required of profile.requiredEnv) {
-      if (!parsedEnv[required] || parsedEnv[required].trim() === '') {
-        errors.push(`Missing required env var: ${required}`);
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors, parsedEnv };
-}

package/src/hooks/creation/useContainerActions.js

@@ -1,76 +0,0 @@
-import { useState } from 'react';
-import { safeCall } from '../../helpers/safeCall.js';
-import {
-  startContainer as svcStartContainer,
-  stopContainer as svcStopContainer,
-  restartContainer as svcRestartContainer,
-  removeContainer as svcRemoveContainer,
-} from '../../helpers/dockerService/serviceComponents/containerActions.js';
-
-/**
- * Custom hook to manage container actions (start, stop, restart, remove).
- * Handles feedback messages and exposes helpers for each action.
- *
- * @param {Object} params
- * @param {Array} params.containers - List of containers
- * @param {Function} params.onAction - Callback after action is performed
- * @returns {Object} Action helpers and feedback state
- */
-export function useContainerActions({ containers, onAction }) {
-  const [message, setMessage] = useState('');
-  const [messageColor, setMessageColor] = useState('yellow');
-
-  /**
-   * Handles a generic container action and sets feedback.
-   * @param {Function} actionFn - The async action function (start, stop, etc)
-   * @param {string} actionLabel - Action label for feedback
-   * @param {number} selected - Index of selected container
-   * @param {Function} [stateCheck] - Optional function to check state before action
-   */
-  async function handleAction({ actionFn, actionLabel, selected, stateCheck }) {
-    const container = containers[selected];
-    if (!container) return;
-    if (stateCheck) {
-      const checkMsg = stateCheck(container);
-      if (checkMsg) {
-        setMessage(checkMsg);
-        setMessageColor('yellow');
-        return;
-      }
-    }
-    setMessage(`${actionLabel} container...`);
-    setMessageColor('yellow');
-    try {
-      await actionFn(container.id);
-      setMessage(`${actionLabel} container successful.`);
-      setMessageColor('green');
-      safeCall(onAction);
-    } catch (err) {
-      setMessage(
-        `Failed to ${actionLabel.toLowerCase()} container: ${err.message}`
-      );
-      setMessageColor('red');
-    }
-  }
-
-  return {
-    message,
-    setMessage,
-    messageColor,
-    setMessageColor,
-    handleAction,
-    // Expose concrete actions so callers can use actions.startContainer(id)
-    startContainer: async (id) => {
-      return await svcStartContainer(id);
-    },
-    stopContainer: async (id) => {
-      return await svcStopContainer(id);
-    },
-    restartContainer: async (id) => {
-      return await svcRestartContainer(id);
-    },
-    removeContainer: async (id) => {
-      return await svcRemoveContainer(id);
-    },
-  };
-}