cdd-cli 3.1.4 → 3.1.6

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

@@ -9,6 +9,33 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 import { docker } from "../dockerService.js";
+import { logger } from "../../logger.js";
+var 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) {
+  var names = container === null || container === void 0 ? void 0 : container.Names;
+  var 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 === null || container === void 0 ? void 0 : container.Name) === "string" && container.Name.trim().length > 0) {
+    rawName = container.Name;
+  } else {
+    rawName = DEFAULT_CONTAINER_NAME;
+  }
+  if (typeof rawName !== "string") {
+    return DEFAULT_CONTAINER_NAME;
+  }
+  var cleanedName = rawName.replace(/^\/+/, "").trim();
+  return cleanedName.length > 0 ? cleanedName : DEFAULT_CONTAINER_NAME;
+}
 
 /**
  * Return a list of containers with normalized fields for the UI.
@@ -19,20 +46,23 @@ export function getContainers() {
 }
 function _getContainers() {
   _getContainers = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-    var containers;
+    var containers, _t;
     return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
+      while (1) switch (_context.p = _context.n) {
         case 0:
-          _context.n = 1;
+          logger.debug("Listing containers");
+          _context.p = 1;
+          _context.n = 2;
           return docker.listContainers({
             all: true
           });
-        case 1:
+        case 2:
           containers = _context.v;
+          logger.debug("Retrieved %d containers", containers.length);
           return _context.a(2, containers.map(function (container) {
             return {
               id: container.Id,
-              name: (container.Names && container.Names[0] || 'Unknown').replace("/", ""),
+              name: normalizeContainerName(container),
               image: container.Image,
               state: container.State,
               status: container.Status,
@@ -45,18 +75,25 @@ function _getContainers() {
                 if (publicPorts.length > 0) {
                   return _toConsumableArray(new Set(publicPorts));
                 }
-                // If there are no public ports, show private exposed ports
+                // Fall back to exposed private ports when there are no bindings.
                 var privatePorts = container.Ports.filter(function (port) {
                   return port.PrivatePort;
                 }).map(function (port) {
-                  return ":".concat(port.PrivatePort);
+                  return "".concat(port.PrivatePort);
                 });
                 return _toConsumableArray(new Set(privatePorts));
               }()
             };
           }));
+        case 3:
+          _context.p = 3;
+          _t = _context.v;
+          logger.error("Failed to list containers", _t);
+          throw _t;
+        case 4:
+          return _context.a(2);
       }
-    }, _callee);
+    }, _callee, null, [[1, 3]]);
   }));
   return _getContainers.apply(this, arguments);
 }

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

@@ -1,4 +1,6 @@
 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.
@@ -9,8 +11,11 @@ import { docker } from "../dockerService.js";
  * @param {Function} onError - Called on error
  */
 export function getLogsStream(containerId, onData, onEnd, onError) {
+  // Use shared safeCall util to call optional callbacks safely
+
   try {
     var container = docker.getContainer(containerId);
+    logger.debug("Opening logs stream for container %s", containerId);
     container.logs({
       follow: true,
       stdout: true,
@@ -18,20 +23,25 @@ export function getLogsStream(containerId, onData, onEnd, onError) {
       tail: 100
     }, function (err, stream) {
       if (err) {
-        onError === null || onError === void 0 || onError(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', function (chunk) {
-        return onData === null || onData === void 0 ? void 0 : onData(chunk.toString());
+        return safeCall(onData, chunk.toString());
       });
       stream.on('end', function () {
-        return onEnd === null || onEnd === void 0 ? void 0 : onEnd();
+        logger.debug("Logs stream ended for container %s", containerId);
+        safeCall(onEnd);
       });
-      stream.on('error', function (err) {
-        return onError === null || onError === void 0 ? void 0 : onError(err);
+      stream.on('error', function (streamErr) {
+        logger.error("Logs stream error for container %s", containerId, streamErr);
+        safeCall(onError, streamErr);
       });
     });
   } catch (err) {
-    onError === null || onError === void 0 || onError(err);
+    logger.error("Unexpected error while opening logs stream for container %s", containerId, err);
+    safeCall(onError, err);
   }
 }

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

@@ -3,6 +3,7 @@ function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try {
 function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 import { docker } from "../dockerService.js";
+import { logger } from "../../logger.js";
 
 /**
  * Retrieve a snapshot of container resource usage (CPU, memory, network).
@@ -15,21 +16,37 @@ export function getStats(_x) {
 }
 function _getStats() {
   _getStats = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(containerId) {
-    var _stream$cpu_stats$cpu;
-    var container, stream, cpuDelta, systemDelta, numCpus, cpuPercent, memUsage, memLimit, memPercent, rx, tx;
+    var container, stream, cpuDelta, systemDelta, numCpus, cpuPercent, memUsage, memLimit, memPercent, rx, tx, snapshot, _t;
     return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
+      while (1) switch (_context.p = _context.n) {
         case 0:
           container = docker.getContainer(containerId);
-          _context.n = 1;
+          logger.debug("Fetching stats for container %s", containerId);
+          _context.p = 1;
+          _context.n = 2;
           return container.stats({
             stream: false
           });
-        case 1:
+        case 2:
           stream = _context.v;
+          _context.n = 4;
+          break;
+        case 3:
+          _context.p = 3;
+          _t = _context.v;
+          logger.error("Failed to fetch stats for container %s", containerId, _t);
+          throw _t;
+        case 4:
           cpuDelta = stream.cpu_stats.cpu_usage.total_usage - stream.precpu_stats.cpu_usage.total_usage;
           systemDelta = stream.cpu_stats.system_cpu_usage - stream.precpu_stats.system_cpu_usage; // Get number of CPUs for proper normalization
-          numCpus = stream.cpu_stats.online_cpus || ((_stream$cpu_stats$cpu = stream.cpu_stats.cpu_usage.percpu_usage) === null || _stream$cpu_stats$cpu === void 0 ? void 0 : _stream$cpu_stats$cpu.length) || 1; // Calculate normalized CPU percentage
+          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
           cpuPercent = systemDelta > 0 ? cpuDelta / systemDelta * numCpus * 100 : 0;
           memUsage = stream.memory_stats.usage || 0;
           memLimit = stream.memory_stats.limit || 1;
@@ -44,16 +61,18 @@ function _getStats() {
           }).reduce(function (a, b) {
             return a + b;
           }, 0) : 0;
-          return _context.a(2, {
+          snapshot = {
             cpuPercent: cpuPercent.toFixed(1),
             memPercent: memPercent.toFixed(1),
             netIO: {
               rx: rx,
               tx: tx
             }
-          });
+          };
+          logger.debug("Stats fetched for container %s", containerId, snapshot);
+          return _context.a(2, snapshot);
       }
-    }, _callee);
+    }, _callee, null, [[1, 3]]);
   }));
   return _getStats.apply(this, arguments);
 }

package/dist/helpers/exitWithMessage.js

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { EXIT_DELAY } from "./constants.js";
 
 /**
  * Show an exit message using provided setters, clear the terminal and exit after a delay.
@@ -18,7 +19,7 @@ export function exitWithMessage(_ref) {
     _ref$color = _ref.color,
     color = _ref$color === void 0 ? "yellow" : _ref$color,
     _ref$delay = _ref.delay,
-    delay = _ref$delay === void 0 ? 1500 : _ref$delay;
+    delay = _ref$delay === void 0 ? EXIT_DELAY : _ref$delay;
   setMessage(message);
   setMessageColor(color);
   setTimeout(function () {

package/dist/helpers/logger.js

@@ -0,0 +1,126 @@
+var _ref, _parseLevel;
+/**
+ * Supported log levels in ascending verbosity.
+ * Lower numeric values represent higher severity.
+ */
+var 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;
+  }
+  var normalized = value.trim().toLowerCase();
+  if (normalized in LOG_LEVELS) {
+    return LOG_LEVELS[normalized];
+  }
+  return null;
+}
+var envLevel = (_ref = (_parseLevel = parseLevel(process.env.CDD_LOG_LEVEL)) !== null && _parseLevel !== void 0 ? _parseLevel : parseLevel(process.env.LOG_LEVEL)) !== null && _ref !== void 0 ? _ref : LOG_LEVELS.info;
+var currentLevel = typeof envLevel === "number" ? envLevel : LOG_LEVELS.info;
+var listeners = new Set();
+function shouldLog(level) {
+  var target = LOG_LEVELS[level];
+  return typeof target === "number" && target <= currentLevel;
+}
+function log(level, message) {
+  if (!shouldLog(level)) {
+    return;
+  }
+  var timestamp = new Date().toISOString();
+  var upperLevel = level.toUpperCase();
+  var formatted = "[".concat(timestamp, "] [").concat(upperLevel, "] ").concat(message);
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+  var entry = {
+    level: level,
+    message: message,
+    args: args,
+    timestamp: timestamp,
+    formatted: formatted
+  };
+  var shouldWriteToConsole = listeners.size === 0 || level === "error" || level === "warn";
+  if (shouldWriteToConsole) {
+    var method = level === "debug" ? "log" : level;
+    if (typeof console[method] === "function") {
+      var _console;
+      (_console = console)[method].apply(_console, [formatted].concat(args));
+    } else {
+      var _console2;
+      (_console2 = console).log.apply(_console2, [formatted].concat(args));
+    }
+  }
+  listeners.forEach(function (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 var logger = {
+  debug: function debug(message) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    log.apply(void 0, ["debug", message].concat(args));
+  },
+  info: function info(message) {
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    log.apply(void 0, ["info", message].concat(args));
+  },
+  warn: function warn(message) {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+    log.apply(void 0, ["warn", message].concat(args));
+  },
+  error: function error(message) {
+    for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+      args[_key5 - 1] = arguments[_key5];
+    }
+    log.apply(void 0, ["error", message].concat(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: function subscribe(listener) {
+    if (typeof listener !== "function") {
+      return function () {};
+    }
+    listeners.add(listener);
+    return function () {
+      return listeners["delete"](listener);
+    };
+  }
+};

package/dist/helpers/safeCall.js

@@ -0,0 +1,21 @@
+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) {
+  if (typeof fn === 'function') {
+    try {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return fn.apply(void 0, args);
+    } catch (e) {
+      logger.error("safeCall caught error", e);
+    }
+  }
+}

package/dist/helpers/validationHelpers.js

@@ -6,11 +6,20 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 // Reusable validations for ports and environment variables
 
+/**
+ * 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;
   var ports = portInput.split(",").map(function (p) {
     return p.trim();
   }).filter(Boolean);
-  if (ports.length === 0) return false;
+  if (ports.length === 0) return true;
   var invalid = ports.find(function (pair) {
     var _pair$split = pair.split(":"),
       _pair$split2 = _slicedToArray(_pair$split, 2),
@@ -20,6 +29,16 @@ export function validatePorts(portInput) {
   });
   return !invalid;
 }
+
+/**
+ * Validate environment variable input as comma-separated VAR=value pairs.
+ * Empty or whitespace-only input is considered valid (no env vars).
+ * Variable names must start with a letter or underscore and contain only
+ * alphanumeric characters and underscores.
+ *
+ * @param {string} envInput - Comma-separated environment variable assignments
+ * @returns {boolean} True when all env var assignments are valid, false otherwise
+ */
 export function validateEnvVars(envInput) {
   if (!envInput || !envInput.trim()) return true; // Empty is valid
 

package/dist/hooks/creation/useContainerActions.js

@@ -9,6 +9,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 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";
 
 /**
@@ -77,7 +78,7 @@ export function useContainerActions(_ref) {
           case 4:
             setMessage("".concat(actionLabel, " container successful."));
             setMessageColor("green");
-            if (onAction) onAction();
+            safeCall(onAction);
             _context5.n = 6;
             break;
           case 5:

package/dist/hooks/creation/useContainerCreation.js

@@ -5,7 +5,8 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 import { useState } from "react";
-import { validatePorts, validateEnvVars } from "../../helpers/validationHelpers.js";
+import { validatePorts } from "../../helpers/validationHelpers.js";
+import { safeCall } from "../../helpers/safeCall.js";
 
 /**
  * Custom hook to manage the container creation flow, step by step.
@@ -93,8 +94,8 @@ export function useContainerCreation(_ref) {
       return;
     }
     if (step === 3) {
-      // Final step: call onCreate with all data
-      onCreate({
+      // Final step: call onCreate with all data (safely)
+      safeCall(onCreate, {
         imageName: imageName,
         containerName: containerName,
         portInput: portInput,
@@ -114,7 +115,7 @@ export function useContainerCreation(_ref) {
     setEnvInput("");
     setMessage("");
     setMessageColor("yellow");
-    if (onCancel) onCancel();
+    safeCall(onCancel);
   }
   return {
     step: step,

package/dist/hooks/creation/useLogsViewer.js

@@ -5,6 +5,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 import { useState, useRef } from "react";
+import { safeCall } from "../../helpers/safeCall.js";
 
 /**
  * Custom hook to manage the logs viewer state and stream reference.
@@ -45,8 +46,8 @@ export function useLogsViewer() {
     setShowLogs(false);
     setLogs([]);
     if (logsStreamRef.current) {
-      var _logsStreamRef$curren, _logsStreamRef$curren2;
-      (_logsStreamRef$curren = (_logsStreamRef$curren2 = logsStreamRef.current).destroy) === null || _logsStreamRef$curren === void 0 || _logsStreamRef$curren.call(_logsStreamRef$curren2);
+      var _logsStreamRef$curren;
+      safeCall((_logsStreamRef$curren = logsStreamRef.current.destroy) === null || _logsStreamRef$curren === void 0 ? void 0 : _logsStreamRef$curren.bind(logsStreamRef.current));
       logsStreamRef.current = null;
     }
   }

package/dist/hooks/useContainers.js

@@ -11,13 +11,16 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 /**
  * React hook to manage Docker containers state.
  *
- * @returns {[Array, Function]} [containers, refresh] / [contenedores, refrescar]
+ * @returns {{containers: Array<Object>}} An object containing the current
+ * containers array. The hook starts a periodic refresh and fetches the
+ * container list immediately on mount.
  * @example
  * // Use in a component
- * const [containers, refresh] = useContainers();
+ * const { containers } = useContainers();
  */
 import React, { useState, useEffect } from "react";
 import { getContainers } from "../helpers/dockerService/serviceComponents/containerList.js";
+import { REFRESH_INTERVALS } from "../helpers/constants.js";
 export function useContainers() {
   var _useState = useState([]),
     _useState2 = _slicedToArray(_useState, 2),
@@ -43,7 +46,7 @@ export function useContainers() {
       };
     }();
     fetch();
-    var timer = setInterval(fetch, 3000);
+    var timer = setInterval(fetch, REFRESH_INTERVALS.CONTAINER_LIST);
     return function () {
       return clearInterval(timer);
     };