cdd-cli 3.2.2 → 4.1.0

package/src/components/SuggestionPanel.jsx

@@ -1,53 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import PropTypes from 'prop-types';
-
-/**
- * Renders an autocomplete suggestion panel as a boxed list below the image input.
- * Displays a window of `maxVisible` items starting at `visibleOffset`.
- * The focused row (selectedIndex) is highlighted cyan with a › prefix.
- *
- * @param {Object} props
- * @param {string[]} props.items - Full list of suggestion strings
- * @param {number} props.selectedIndex - Currently focused index (-1 = none)
- * @param {number} props.visibleOffset - First item index of the visible window
- * @param {number} [props.maxVisible=6] - Maximum number of items visible at once
- * @returns {JSX.Element|null}
- */
-export function SuggestionPanel({
-  items,
-  selectedIndex,
-  visibleOffset,
-  maxVisible = 6,
-}) {
-  if (!items || items.length === 0) return null;
-
-  const visible = items.slice(visibleOffset, visibleOffset + maxVisible);
-
-  return (
-    <Box
-      flexDirection="column"
-      borderStyle="single"
-      borderColor="cyan"
-      paddingX={1}
-      data-testid="suggestion-panel"
-    >
-      {visible.map((item, localIdx) => {
-        const globalIdx = visibleOffset + localIdx;
-        const isFocused = globalIdx === selectedIndex;
-        return (
-          <Text key={item} color={isFocused ? 'cyan' : undefined} dimColor={!isFocused}>
-            {isFocused ? `› ${item}` : `  ${item}`}
-          </Text>
-        );
-      })}
-    </Box>
-  );
-}
-
-SuggestionPanel.propTypes = {
-  items: PropTypes.arrayOf(PropTypes.string).isRequired,
-  selectedIndex: PropTypes.number.isRequired,
-  visibleOffset: PropTypes.number.isRequired,
-  maxVisible: PropTypes.number,
-};

package/src/components/UsageMenu.jsx

@@ -1,52 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-
-const SHORTCUTS = [
-  'Use ↑/↓ for navigation',
-  'I to initiate selected container',
-  'P to stop selected container',
-  'R to restart selected container',
-  'C to create a container',
-  'L to view logs of selected container',
-  'D to toggle debug log panel',
-  'E to remove selected container',
-  'Q to quit',
-];
-
-const GRID_COLUMNS = 3;
-
-/**
- * Small usage menu that explains available keybindings to the user.
- * Renders entries in a responsive grid to avoid an excessively long column.
- *
- * @returns {JSX.Element}
- */
-export default function UsageMenu() {
-  const rowsPerColumn = Math.ceil(SHORTCUTS.length / GRID_COLUMNS);
-  const columns = Array.from({ length: GRID_COLUMNS }, (_, columnIndex) =>
-    SHORTCUTS.slice(
-      columnIndex * rowsPerColumn,
-      (columnIndex + 1) * rowsPerColumn
-    )
-  ).filter((column) => column.length > 0);
-
-  return (
-    <Box flexDirection="column" marginTop={1}>
-      <Box flexDirection="row">
-        {columns.map((column, columnIndex) => (
-          <Box
-            key={`shortcut-column-${columnIndex}`}
-            flexDirection="column"
-            marginRight={columnIndex === columns.length - 1 ? 0 : 3}
-          >
-            {column.map((shortcut, rowIndex) => (
-              <Text key={`shortcut-${columnIndex}-${rowIndex}`}>
-                {shortcut}
-              </Text>
-            ))}
-          </Box>
-        ))}
-      </Box>
-    </Box>
-  );
-}

package/src/helpers/appInfo.js

@@ -1,23 +0,0 @@
-import { readFileSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-let cachedVersion;
-
-export function getAppVersion() {
-  if (cachedVersion) {
-    return cachedVersion;
-  }
-
-  try {
-    const __filename = fileURLToPath(import.meta.url);
-    const moduleDir = path.dirname(__filename);
-    const packageJsonPath = path.resolve(moduleDir, '../../package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    cachedVersion = packageJson.version ?? 'unknown';
-    return cachedVersion;
-  } catch (error) {
-    cachedVersion = 'unknown';
-    return cachedVersion;
-  }
-}

package/src/helpers/constants.js

@@ -1,71 +0,0 @@
-/**
- * Time intervals used across the app (milliseconds).
- * - CONTAINER_LIST: how often to refresh the list of containers
- * - CONTAINER_STATS: how often to fetch stats for running containers
- */
-export const REFRESH_INTERVALS = {
-  CONTAINER_LIST: 3000,
-  CONTAINER_STATS: 1500,
-};
-
-/**
- * Timeout values for UI messages before they disappear.
- */
-export const MESSAGE_TIMEOUTS = {
-  SHORT: 2000,
-  DEFAULT: 3000,
-};
-
-/**
- * Delay used before exiting the process when showing an exit message.
- */
-export const EXIT_DELAY = 500;
-
-/**
- * Operational timeouts for Docker operations and image pulls.
- */
-export const TIMEOUTS = {
-  CONTAINER_OP: 30000,
-  PULL_IMAGE: 300000,
-};
-
-/**
- * List of well-known database image names (without tags or registry prefixes).
- */
-export const DB_IMAGES = [
-  'mysql',
-  'mariadb',
-  'postgres',
-  'mongo',
-  'mssql',
-  'redis',
-];
-
-/**
- * Per-image profiles with required env vars, default exposed port, and suggested env vars.
- * Keys are normalized image names (no tag, no registry prefix).
- *
- * @type {Record<string, { requiredEnv: string[], defaultPort: string, suggestedEnv: string[] }>}
- */
-export const IMAGE_PROFILES = {
-  nginx:         { requiredEnv: [], defaultPort: '80',    suggestedEnv: [] },
-  httpd:         { requiredEnv: [], defaultPort: '80',    suggestedEnv: [] },
-  caddy:         { requiredEnv: [], defaultPort: '80',    suggestedEnv: [] },
-  node:          { requiredEnv: [], defaultPort: '3000',  suggestedEnv: ['NODE_ENV=production'] },
-  python:        { requiredEnv: [], defaultPort: '8000',  suggestedEnv: ['PYTHONUNBUFFERED=1'] },
-  openjdk:       { requiredEnv: [], defaultPort: '8080',  suggestedEnv: ['JAVA_OPTS=-Xms256m -Xmx512m'] },
-  golang:        { requiredEnv: [], defaultPort: '8080',  suggestedEnv: ['GOMAXPROCS=2'] },
-  redis:         { requiredEnv: [], defaultPort: '6379',  suggestedEnv: ['REDIS_PASSWORD=change-me'] },
-  memcached:     { requiredEnv: [], defaultPort: '11211', suggestedEnv: [] },
-  postgres:      { requiredEnv: ['POSTGRES_PASSWORD'], defaultPort: '5432', suggestedEnv: ['POSTGRES_USER=postgres', 'POSTGRES_DB=app'] },
-  mysql:         { requiredEnv: ['MYSQL_ROOT_PASSWORD'], defaultPort: '3306', suggestedEnv: ['MYSQL_DATABASE=app', 'MYSQL_USER=app', 'MYSQL_PASSWORD=app123'] },
-  mariadb:       { requiredEnv: ['MARIADB_ROOT_PASSWORD'], defaultPort: '3306', suggestedEnv: ['MARIADB_DATABASE=app', 'MARIADB_USER=app', 'MARIADB_PASSWORD=app123'] },
-  mongo:         { requiredEnv: [], defaultPort: '27017', suggestedEnv: ['MONGO_INITDB_ROOT_USERNAME=admin', 'MONGO_INITDB_ROOT_PASSWORD=secret'] },
-  mssql:         { requiredEnv: ['ACCEPT_EULA', 'SA_PASSWORD'], defaultPort: '1433', suggestedEnv: ['ACCEPT_EULA=Y', 'MSSQL_PID=Developer'] },
-  rabbitmq:      { requiredEnv: [], defaultPort: '5672',  suggestedEnv: ['RABBITMQ_DEFAULT_USER=guest', 'RABBITMQ_DEFAULT_PASS=guest'] },
-  kafka:         { requiredEnv: [], defaultPort: '9092',  suggestedEnv: ['KAFKA_CFG_LISTENERS=PLAINTEXT://:9092', 'KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092'] },
-  zookeeper:     { requiredEnv: [], defaultPort: '2181',  suggestedEnv: ['ALLOW_ANONYMOUS_LOGIN=yes'] },
-  elasticsearch: { requiredEnv: [], defaultPort: '9200',  suggestedEnv: ['discovery.type=single-node', 'xpack.security.enabled=false'] },
-  minio:         { requiredEnv: ['MINIO_ROOT_USER', 'MINIO_ROOT_PASSWORD'], defaultPort: '9000', suggestedEnv: ['MINIO_CONSOLE_ADDRESS=:9001'] },
-  wordpress:     { requiredEnv: ['WORDPRESS_DB_HOST', 'WORDPRESS_DB_USER', 'WORDPRESS_DB_PASSWORD', 'WORDPRESS_DB_NAME'], defaultPort: '8080', suggestedEnv: ['WORDPRESS_TABLE_PREFIX=wp_'] },
-};

package/src/helpers/containerOptionsBuilder.js

@@ -1,53 +0,0 @@
-/**
- * Builds Docker container creation options from raw user inputs.
- *
- * This is a pure function — it has no side effects and calls no services.
- * It mirrors exactly the option-building logic in useControls.js onCreate callback.
- *
- * @param {object} params
- * @param {string} params.imageName          - Docker image name (e.g. "nginx:alpine")
- * @param {string} [params.containerName]    - Optional container name
- * @param {string} [params.portInput]        - Comma-separated host:container port pairs
- *                                            (e.g. "8080:80,3000:3000")
- * @param {string} [params.envInput]         - Comma-separated KEY=VALUE pairs
- *                                            (e.g. "NODE_ENV=production,PORT=3000")
- * @returns {object} Docker container options ready to pass to createContainer
- */
-export function buildContainerOptions({
-  imageName: _imageName,
-  containerName,
-  portInput,
-  envInput,
-}) {
-  const env = (envInput || '')
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-  const ports = (portInput || '')
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-
-  const ExposedPorts = {};
-  const PortBindings = {};
-
-  ports.forEach((pair) => {
-    const [host, cont] = pair.split(':');
-    if (!host || !cont) return;
-    const key = `${cont}/tcp`;
-    ExposedPorts[key] = {};
-    PortBindings[key] = PortBindings[key] || [];
-    PortBindings[key].push({ HostPort: `${host}` });
-  });
-
-  const options = {
-    Tty: true,
-  };
-
-  if (Object.keys(ExposedPorts).length) options.ExposedPorts = ExposedPorts;
-  if (Object.keys(PortBindings).length) options.HostConfig = { PortBindings };
-  if (env.length) options.Env = env;
-  if (containerName) options.name = containerName;
-
-  return options;
-}

package/src/helpers/dockerService/dockerService.js

@@ -1,28 +0,0 @@
-import Docker from 'dockerode';
-
-// Use default dockerode configuration which automatically handles:
-// - /var/run/docker.sock on Linux/Mac
-// - //./pipe/docker_engine on Windows
-// - Environment variables DOCKER_HOST, DOCKER_CERT_PATH, etc.
-
-/**
- * Typedef for the docker client used in this project.
- * Use a generic object shape so JSDoc can render a meaningful type.
- *
- * @typedef {Object} DockerClient
- * @property {Function} listContainers
- * @property {Function} getContainer
- * @property {Function} listImages
- * @property {Function} createContainer
- * @property {Function} pull
- */
-
-/**
- * Shared Docker client instance (dockerode). Consumers import { docker }
- * and use it to list/create/start/stop containers and images.
- *
- * @type {DockerClient}
- */
-const docker = new Docker();
-
-export { docker };

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;
-  }
-}