cdd-cli 3.1.3 → 3.1.5

package/dist/helpers/logger.js

@@ -0,0 +1,112 @@
+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
+};
+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 {(entry: { level: string, message: string, args: any[], timestamp: string, formatted: string }) => void} listener
+   * Listener invoked for every log entry that passes the current level filter.
+   * @returns {Function} 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);
     };