cdd-cli 3.1.9 → 3.2.2

package/src/components/StatsBar.jsx

@@ -1,6 +1,6 @@
-import React from "react";
-import { Text } from "ink";
-import chalk from "chalk";
+import React from 'react';
+import { Text } from 'ink';
+import chalk from 'chalk';
 import PropTypes from 'prop-types';
 
 const BAR_WIDTH = 8;
@@ -19,7 +19,9 @@ export default function StatsBar({ cpu, mem }) {
 
   return (
     <Text>
-      CPU:{cpuBar}{colorize(cpu, ` ${formatPercent(cpu)}%`)} MEM:{memBar}{colorize(mem, ` ${formatPercent(mem)}%`)}
+      CPU:{cpuBar}
+      {colorize(cpu, ` ${formatPercent(cpu)}%`)} MEM:{memBar}
+      {colorize(mem, ` ${formatPercent(mem)}%`)}
     </Text>
   );
 }
@@ -38,10 +40,12 @@ StatsBar.propTypes = {
  */
 function makeBar(value, width) {
   const safeWidth = Math.max(1, Math.round(width));
-  const normalized = Number.isFinite(value) ? Math.min(Math.max(value, 0), 100) : 0;
+  const normalized = Number.isFinite(value)
+    ? Math.min(Math.max(value, 0), 100)
+    : 0;
   const filled = Math.round((normalized / 100) * safeWidth);
   const empty = Math.max(0, safeWidth - filled);
-  const bar = "█".repeat(filled) + "░".repeat(empty);
+  const bar = '█'.repeat(filled) + '░'.repeat(empty);
   return colorize(normalized, bar);
 }
 
@@ -49,7 +53,7 @@ function formatPercent(value) {
   if (!Number.isFinite(value)) return 0;
   const normalized = Math.min(Math.max(value, 0), 100);
   if (normalized >= 10) return Math.round(normalized);
-  return normalized.toFixed(1).replace(/\.0$/, "");
+  return normalized.toFixed(1).replace(/\.0$/, '');
 }
 
 /**

package/src/components/SuggestionPanel.jsx

@@ -0,0 +1,53 @@
+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,16 +1,16 @@
-import React from "react";
-import { Box, Text } from "ink";
+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",
+  '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;
@@ -24,7 +24,10 @@ const GRID_COLUMNS = 3;
 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)
+    SHORTCUTS.slice(
+      columnIndex * rowsPerColumn,
+      (columnIndex + 1) * rowsPerColumn
+    )
   ).filter((column) => column.length > 0);
 
   return (
@@ -37,7 +40,9 @@ export default function UsageMenu() {
             marginRight={columnIndex === columns.length - 1 ? 0 : 3}
           >
             {column.map((shortcut, rowIndex) => (
-              <Text key={`shortcut-${columnIndex}-${rowIndex}`}>{shortcut}</Text>
+              <Text key={`shortcut-${columnIndex}-${rowIndex}`}>
+                {shortcut}
+              </Text>
             ))}
           </Box>
         ))}

package/src/helpers/appInfo.js

@@ -1,6 +1,6 @@
-import { readFileSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
 let cachedVersion;
 
@@ -12,12 +12,12 @@ export function getAppVersion() {
   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";
+    const packageJsonPath = path.resolve(moduleDir, '../../package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    cachedVersion = packageJson.version ?? 'unknown';
     return cachedVersion;
   } catch (error) {
-    cachedVersion = "unknown";
+    cachedVersion = 'unknown';
     return cachedVersion;
   }
 }

package/src/helpers/constants.js

@@ -28,3 +28,44 @@ 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

@@ -13,15 +13,26 @@
  *                                            (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);
+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(":");
+  ports.forEach((pair) => {
+    const [host, cont] = pair.split(':');
     if (!host || !cont) return;
     const key = `${cont}/tcp`;
     ExposedPorts[key] = {};

package/src/helpers/dockerService/dockerService.js

@@ -1,4 +1,4 @@
-import Docker from "dockerode";
+import Docker from 'dockerode';
 
 // Use default dockerode configuration which automatically handles:
 // - /var/run/docker.sock on Linux/Mac

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

@@ -1,7 +1,8 @@
-import { docker } from "../dockerService.js";
-import { imageExists, pullImage } from "./imageUtils.js";
-import { TIMEOUTS } 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,13 +30,13 @@ 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);
   }
 }
@@ -45,25 +46,30 @@ export async function removeContainer(containerId) {
  *
  * @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
+ * @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 = {}) {
-  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);
     }
   }
@@ -73,16 +79,24 @@ export async function createContainer(imageName, options = {}) {
     ...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 = [];
 
   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) {
@@ -91,7 +105,10 @@ export async function createContainer(imageName, options = {}) {
               });
             });
           } 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) => {
@@ -101,7 +118,6 @@ export async function createContainer(imageName, options = {}) {
         const pickNextAvailablePort = (base) => {
           const numericBase = Number.parseInt(base, 10);
           if (Number.isNaN(numericBase)) {
-            // If the base port is non-numeric, just return the base.
             if (!usedHostPorts.has(base)) {
               usedHostPorts.add(base);
               return base;
@@ -123,36 +139,93 @@ export async function createContainer(imageName, options = {}) {
           return String(candidate);
         };
 
-        const inspectData = await withTimeout(image.inspect(), TIMEOUTS.CONTAINER_OP);
-        const exposed = inspectData?.Config?.ExposedPorts || inspectData?.ContainerConfig?.ExposedPorts || {};
-        const exposedKeys = Object.keys(exposed || {});
+        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 || {}) };
+          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 containerPort = portKey.split("/")[0];
+            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 }];
+              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 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 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 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);
+    logger.error('Failed to create container from image %s', imageName, err);
     throw new Error('Error creating container: ' + err.message);
   }
 }
@@ -164,12 +237,12 @@ export async function createContainer(imageName, options = {}) {
  */
 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;
   }
 }
@@ -181,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;
   }
 }
@@ -198,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;
   }
 }