@abtnode/docker-utils 1.16.38-beta-20250108-235929-17742885

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2025 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/index.cjs

@@ -0,0 +1,656 @@
+'use strict';
+
+const Joi = require('joi');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const Joi__default = /*#__PURE__*/_interopDefaultCompat(Joi);
+
+const whiteDockerArgs = {
+  // 短参数映射
+  "-a": "--attach",
+  // 将标准输入、输出或错误流附加到容器（通常与 -i -t 一起使用）
+  "-d": "--detach",
+  // 以后台模式运行容器（分离模式）
+  "-e": "--env",
+  // 设置环境变量（例如：-e "VAR=value"）
+  "-h": "--hostname",
+  // 设置容器的主机名
+  "-i": "--interactive",
+  // 保持 STDIN 为打开状态（与 -t 一起用可进入交互式模式）
+  "-it": "-it",
+  "-rm": "-rm",
+  "-m": "--memory",
+  // 限制容器可使用的内存大小（例如：-m 512m）
+  "-p": "--publish",
+  // 将容器的端口映射到主机（例如：-p 8080:80）
+  "-P": "--publish-all",
+  // 将容器暴露的所有端口随机映射到主机端口
+  "-l": "--label",
+  // 为容器添加自定义元数据标签（例如：-l "key=value"）
+  "-n": "--name",
+  // 为容器指定名称，而不是自动分配
+  "-q": "--quiet",
+  // 静默模式，不输出日志信息（通常用于 docker build）
+  "-x": "--x-registry",
+  // 非标准参数（此处为自定义场景）可用于指定镜像注册表等
+  "-t": "--tty",
+  // 分配一个伪 TTY（终端），常与 -i 一起使用
+  "-u": "--user",
+  // 指定以哪个用户或 UID 运行容器内的进程
+  "-v": "--volume",
+  // 挂载宿主机目录或数据卷到容器中
+  "-w": "--workdir",
+  // 设置容器内的工作目录
+  "-cgroupns": "--cgroupns",
+  // 设置 cgroup 命名空间的模式（host 或 private）
+  "-cpus": "--cpus",
+  // 限制可用给容器的 CPU 数量
+  "-g": "--gpus",
+  // 分配 GPU 给容器（需要适配 NVIDIA runtime）
+  "-ip6": "--ip6",
+  // 设置容器的 IPv6 地址
+  "--read-only": "--read-only",
+  // 将容器的文件系统设置为只读
+  // 长参数映射
+  "--add-host": "--add-host",
+  // 添加自定义主机名映射到 /etc/hosts 中（格式：host:IP）
+  "--attach": "--attach",
+  // 附加到容器的 STDIN/STDOUT/STDERR
+  "--blkio-weight": "--blkio-weight",
+  // 设置容器块 IO 相对权重（需要 cgroup 支持）
+  "--blkio-weight-device": "--blkio-weight-device",
+  // 针对指定设备设置块 IO 权重
+  "--cap-add": "--cap-add",
+  // 向容器添加 Linux 功能（Capabilities）
+  "--cap-drop": "--cap-drop",
+  // 从容器中移除特定 Linux 功能
+  "--cgroup-parent": "--cgroup-parent",
+  // 指定容器的 cgroup 父组
+  "--cidfile": "--cidfile",
+  // 将创建的容器 ID 写入到指定文件中
+  "--cpu-period": "--cpu-period",
+  // 限制 CPU CFS 调度周期
+  "--cpu-quota": "--cpu-quota",
+  // 限制 CPU CFS 配额，控制 CPU 时间的使用量
+  "--cpu-rt-period": "--cpu-rt-period",
+  // 调整 CPU 实时调度周期（需要特定权限）
+  "--cpu-rt-runtime": "--cpu-rt-runtime",
+  // 调整 CPU 实时调度运行时间（需要特定权限）
+  "--cpu-shares": "--cpu-shares",
+  // 设置 CPU 共享权重（相对值）
+  "--cpus": "--cpus",
+  // 限制容器可用 CPU 数量（例如：--cpus 2.5）
+  "--cpuset-cpus": "--cpuset-cpus",
+  // 指定容器能使用的 CPU 核心（例如：--cpuset-cpus="0-2,4"）
+  "--cpuset-mems": "--cpuset-mems",
+  // 指定容器能使用的内存节点（NUMA 节点）
+  "--detach": "--detach",
+  // 后台运行容器
+  "--detach-keys": "--detach-keys",
+  // 设置分离容器的键组合
+  "--device": "--device",
+  // 将主机设备映射到容器（例如：--device=/dev/sda:/dev/xvda）
+  "--device-cgroup-rule": "--device-cgroup-rule",
+  // 为设备访问添加 cgroup 规则
+  "--device-read-bps": "--device-read-bps",
+  // 限制设备读取速率（字节/秒）
+  "--device-read-iops": "--device-read-iops",
+  // 限制设备读取 IOPS
+  "--device-write-bps": "--device-write-bps",
+  // 限制设备写入速率（字节/秒）
+  "--device-write-iops": "--device-write-iops",
+  // 限制设备写入 IOPS
+  "--disable-content-trust": "--disable-content-trust",
+  // 禁用镜像拉取时的内容信任校验
+  "--dns": "--dns",
+  // 设置容器使用的 DNS 服务器
+  "--dns-opt": "--dns-opt",
+  // 为 DNS 配置添加选项
+  "--dns-search": "--dns-search",
+  // 为 DNS 搜索域配置添加域名
+  "--domainname": "--domainname",
+  // 设置容器的域名（FQDN）
+  "--entrypoint": "--entrypoint",
+  // 覆盖镜像的默认 ENTRYPOINT
+  "--env": "--env",
+  // 设置环境变量
+  "--env-file": "--env-file",
+  // 从文件中读取环境变量
+  "--expose": "--expose",
+  // 声明容器将会监听的端口（不做主机端口映射，只是元数据声明）
+  "--gpus": "--gpus",
+  // 分配 GPU 给容器
+  "--group-add": "--group-add",
+  // 向容器添加更多用户组（GID）
+  "--health-cmd": "--health-cmd",
+  // 容器健康检查命令
+  "--health-interval": "--health-interval",
+  // 健康检查的时间间隔
+  "--health-retries": "--health-retries",
+  // 健康检查的重试次数
+  "--health-start-period": "--health-start-period",
+  // 健康检查开始前的初始化等待时间
+  "--health-timeout": "--health-timeout",
+  // 健康检查的超时时间
+  "--help": "--help",
+  // 显示帮助信息
+  "--hostname": "--hostname",
+  // 设置容器主机名
+  "--init": "--init",
+  // 在容器内使用 init 进程（帮助处理僵尸进程）
+  "--interactive": "--interactive",
+  // 保持 STDIN 打开
+  "--ip": "--ip",
+  // 指定容器的 IPv4 地址（需自定义网络）
+  "--ip6": "--ip6",
+  // 指定容器的 IPv6 地址（需自定义网络）
+  "--ipc": "--ipc",
+  // 设置容器的 IPC 命名空间（shareable, container:id, 或 host）
+  "--isolation": "--isolation",
+  // 指定容器隔离级别（Windows 环境下使用，如 process 或 hyperv）
+  "--kernel-memory": "--kernel-memory",
+  // 限制内核内存使用（已弃用）
+  "--label": "--label",
+  // 为容器添加自定义元数据标签
+  "--label-file": "--label-file",
+  // 从文件中读取标签
+  "--link": "--link",
+  // 连接到另一个容器的网络别名（已弃用，建议用网络替代）
+  "--link-local-ip": "--link-local-ip",
+  // 为容器分配一个链接本地地址（IPv4/IPv6）
+  "--log-driver": "--log-driver",
+  // 设置容器日志驱动（例如 json-file、syslog 等）
+  "--log-opt": "--log-opt",
+  // 为日志驱动添加额外配置选项
+  "--mac-address": "--mac-address",
+  // 设置容器的 MAC 地址（需自定义网络）
+  "--memory": "--memory",
+  // 限制容器可使用的内存
+  "--memory-reservation": "--memory-reservation",
+  // 设置内存软限制（触发内存管理）
+  "--memory-swap": "--memory-swap",
+  // 设置内存+swap 的限制值
+  "--memory-swappiness": "--memory-swappiness",
+  // 调整内存交换行为（0-100）
+  "--mount": "--mount",
+  // 使用高级语法挂载数据卷或绑定宿主机目录
+  "--name": "--name",
+  // 指定容器名称
+  "--network": "--network",
+  // 指定容器使用的网络（默认 bridge）
+  "--network-alias": "--network-alias",
+  // 为容器添加网络别名（在用户定义网络中）
+  "--no-healthcheck": "--no-healthcheck",
+  // 禁用继承自镜像的健康检查
+  "--oom-kill-disable": "--oom-kill-disable",
+  // 禁用内存不足时对容器进程的杀死操作
+  "--oom-score-adj": "--oom-score-adj",
+  // 调整容器的 OOM 分数（影响 OOM 杀死优先级）
+  "--pid": "--pid",
+  // 设置 PID 命名空间（容器与主机共享进程视图）
+  "--pids-limit": "--pids-limit",
+  // 限制容器内可用的进程数
+  "--platform": "--platform",
+  // 指定镜像平台（如 linux/amd64）
+  "--privileged": "--privileged",
+  // 提升容器为特权模式（访问更多主机资源）
+  "--publish": "--publish",
+  // 映射容器端口到宿主机
+  "--publish-all": "--publish-all",
+  // 自动映射容器暴露的所有端口到宿主机随机端口
+  "--pull": "--pull",
+  // 指定拉取镜像策略（always, missing, never）
+  "--restart": "--restart",
+  // 容器退出后的重启策略（no, on-failure, always, unless-stopped）
+  "--rm": "--rm",
+  // 容器停止后自动删除容器
+  "--runtime": "--runtime",
+  // 指定运行时（如 runc, nvidia-container-runtime）
+  "--security-opt": "--security-opt",
+  // 设置安全选项（如 seccomp, apparmor 配置）
+  "--shm-size": "--shm-size",
+  // 设置 /dev/shm 的大小（默认 64M）
+  "--stop-signal": "--stop-signal",
+  // 设置停止容器时发送的信号（默认 SIGTERM）
+  "--stop-timeout": "--stop-timeout",
+  // 停止容器时等待指定秒数后发送 SIGKILL
+  "--storage-opt": "--storage-opt",
+  // 设置存储驱动的选项（如 devicemapper）
+  "--sysctl": "--sysctl",
+  // 设置内核参数（sysctl）
+  "--tmpfs": "--tmpfs",
+  // 挂载一个 tmpfs 临时文件系统
+  "--tty": "--tty",
+  // 分配一个伪终端 TTY
+  "--ulimit": "--ulimit",
+  // 设置容器的 ulimit 限制（如打开文件数）
+  "--user": "--user",
+  // 指定容器内运行进程的用户/组
+  "--userns": "--userns",
+  // 设置用户命名空间模式（host 或 private）
+  "--uts": "--uts",
+  // 设置 UTS 命名空间（host 或 container）
+  "--volume": "--volume",
+  // 挂载宿主机目录或数据卷到容器中
+  "--volume-driver": "--volume-driver",
+  // 指定数据卷驱动
+  "--volumes-from": "--volumes-from",
+  // 从另一个容器挂载数据卷
+  "--workdir": "--workdir"
+  // 设置容器内的工作目录
+};
+const allowDockerArgs = {
+  "--env": true,
+  "--publish": true,
+  "--volume": true,
+  "--attach": true,
+  "--quiet": true,
+  // '--user': true,
+  "--workdir": true,
+  "--cidfile": true,
+  "--detach-keys": true,
+  "--disable-content-trust": true,
+  "--domainname": true,
+  "--expose": true,
+  "--ip": true,
+  "--link-local-ip": true,
+  "--platform": true
+};
+const autoSetDockerArgs = {
+  "-rm": true,
+  "--name": true,
+  "--label": true,
+  "--network": true,
+  "--user": true
+};
+const notAllowUseCustomDockerArgs = {
+  "--volume": true,
+  "--publish": true
+};
+
+const needValueKeys = /* @__PURE__ */ new Set(["--publish", "--volume"]);
+function addBlockletPrefixVolume(args) {
+  return args.map((arg) => {
+    if (arg.key === "--volume" && !arg.value.startsWith("$BLOCKLET_APP_DIR/") && !arg.value.startsWith("$BLOCKLET_DATA_DIR/")) {
+      return {
+        ...arg,
+        value: arg.value.startsWith("/") ? `$BLOCKLET_DATA_DIR${arg.value}` : `$BLOCKLET_DATA_DIR/${arg.value}`
+      };
+    }
+    return arg;
+  });
+}
+function dockerParseCommand(command) {
+  if (!command) {
+    return { dockerArgs: [], dockerEnvs: [], dockerImage: "" };
+  }
+  command = command.trim();
+  if (command.startsWith("$ docker run")) {
+    command = command.replace("$ docker run", "docker run");
+  }
+  if (!command.startsWith("docker run")) {
+    return { dockerArgs: [], dockerEnvs: [], dockerImage: "" };
+  }
+  const cleanedCommand = command.replace(/\\\n/g, "").replace(/\n/g, " ").trim();
+  const parts = cleanedCommand.match(/(?:[^\s"']+|'[^']*'|"[^"]*")+/g);
+  if (!parts) {
+    return { dockerArgs: [], dockerEnvs: [], dockerImage: "" };
+  }
+  const dockerArgs = [];
+  const dockerEnvs = [];
+  let i = 0;
+  let dockerImage = "";
+  while (i < parts.length) {
+    const part = parts[i];
+    if (!part) {
+      i++;
+      continue;
+    }
+    if (part === "docker" || part === "run") {
+      i++;
+      continue;
+    }
+    if ((part === "-e" || part === "--env") && i + 1 < parts.length) {
+      const envString = parts[i + 1] || "";
+      const [envKey, ...envValueParts] = envString.split("=");
+      if (envKey) {
+        const envValue = envValueParts.join("=").replace(/^['"]|['"]$/g, "");
+        dockerEnvs.push({ key: envKey, value: envValue });
+      }
+      i += 2;
+      continue;
+    }
+    if (part.startsWith("-")) {
+      const equalIndex = part.indexOf("=");
+      let rawKey = part;
+      let value = null;
+      if (equalIndex !== -1) {
+        rawKey = part.substring(0, equalIndex);
+        value = part.substring(equalIndex + 1).replace(/^['"]|['"]$/g, "");
+      }
+      const fullKey = whiteDockerArgs[rawKey];
+      if (!fullKey) {
+        i++;
+        continue;
+      }
+      if (fullKey === "--publish") {
+        let publishValue = "";
+        if (value) {
+          publishValue = value;
+          dockerArgs.push({ key: fullKey, value: publishValue });
+        } else {
+          if (i + 1 < parts.length && !(parts[i + 1] || "").startsWith("-")) {
+            const nextVal = (parts[i + 1] || "").replace(/^['"]|['"]$/g, "");
+            publishValue = nextVal;
+            dockerArgs.push({ key: fullKey, value: publishValue });
+            i += 2;
+            continue;
+          } else {
+            dockerArgs.push({ key: fullKey, value: "true" });
+            i++;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+      if (value !== null) {
+        dockerArgs.push({ key: fullKey, value });
+        i++;
+        continue;
+      } else {
+        if (i + 1 < parts.length && !(parts[i + 1] || "").startsWith("-")) {
+          const nextVal = (parts[i + 1] || "").replace(/^['"]|['"]$/g, "");
+          dockerArgs.push({ key: fullKey, value: nextVal });
+          i += 2;
+          continue;
+        } else {
+          dockerArgs.push({ key: fullKey, value: "true" });
+          i++;
+          continue;
+        }
+      }
+    }
+    dockerImage = part.replace(/^['"]|['"]$/g, "");
+    i++;
+  }
+  const filteredDockerArgs = [];
+  for (const arg of dockerArgs) {
+    arg.name = "";
+    arg.path = "";
+    arg.prefix = "";
+    arg.protocol = "";
+    arg.type = "docker";
+    if (needValueKeys.has(arg.key) && arg.value === "true") {
+      continue;
+    }
+    filteredDockerArgs.push(arg);
+  }
+  for (const item of dockerEnvs) {
+    item.custom = "";
+    item.description = "";
+    item.secure = false;
+    item.shared = false;
+    item.required = false;
+  }
+  return { dockerArgs: addBlockletPrefixVolume(filteredDockerArgs), dockerEnvs, dockerImage };
+}
+function dockerBuildCommand({
+  dockerArgs,
+  dockerEnvs,
+  dockerImage
+}) {
+  if (dockerArgs.length === 0 && dockerEnvs.length === 0 && !dockerImage) {
+    return "";
+  }
+  const parts = ["docker run \\"];
+  const multipleArgs = /* @__PURE__ */ new Set([
+    "--publish",
+    "--volume",
+    "--expose",
+    "--device",
+    "--mount",
+    "--label",
+    "--cap-add",
+    "--cap-drop",
+    "--add-host",
+    "--dns",
+    "--network-alias",
+    "--sysctl",
+    "--ulimit",
+    "--network"
+  ]);
+  for (const arg of dockerArgs) {
+    const { key, value } = arg;
+    if (multipleArgs.has(key)) {
+      if (value === "true") {
+        parts.push(`  ${key} \\`);
+      } else {
+        const formattedValue = /[\s"']/g.test(value) ? `"${value}"` : value;
+        parts.push(`  ${key} ${formattedValue} \\`);
+      }
+    } else {
+      if (!parts.some((part) => part.startsWith(`  ${key}`))) {
+        if (value === "true") {
+          parts.push(`  ${key} \\`);
+        } else {
+          const formattedValue = /[\s"']/g.test(value) ? `"${value}"` : value;
+          parts.push(`  ${key} ${formattedValue} \\`);
+        }
+      }
+    }
+  }
+  for (const env of dockerEnvs) {
+    const { key, value } = env;
+    const formattedEnvValue = /["']/g.test(value) ? value : `"${value}"`;
+    parts.push(`  -e ${key}=${formattedEnvValue} \\`);
+  }
+  if (dockerImage) {
+    parts.push(`  ${dockerImage}`);
+  } else {
+    if (parts[parts.length - 1]?.endsWith("\\")) {
+      parts[parts.length - 1] = (parts[parts.length - 1] || "").slice(0, -1).trim();
+    }
+  }
+  return parts.join("\n");
+}
+
+const dockerArgsValidator = {
+  "--volume": (volume) => {
+    if (!volume.startsWith("$BLOCKLET_APP_DIR/") && !volume.startsWith("$BLOCKLET_DATA_DIR/")) {
+      return "Volume must start with $BLOCKLET_APP_DIR or $BLOCKLET_DATA_DIR";
+    }
+    if (volume.indexOf("..") > -1) {
+      return 'Volume cannot contain ".."';
+    }
+    return "";
+  }
+};
+
+const dockerArgsToCamelCase = (str) => {
+  const strippedStr = str.replace(/^[-]+/, "");
+  const camelCaseStr = strippedStr.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+  return camelCaseStr;
+};
+const dockerCamelCaseToDash = (str) => {
+  const kebabCaseStr = str.replace(/([A-Z])/g, "-$1").toLowerCase();
+  return `--${kebabCaseStr}`;
+};
+
+const allowedDockerArgKeys = Array.from(new Set(Object.keys(allowDockerArgs).map(dockerArgsToCamelCase)));
+const multiValueArgs = ["publish", "volume"];
+const dockerSchema = Joi__default.object({
+  workdir: Joi__default.string().trim().optional(),
+  image: Joi__default.string().trim().regex(/^[^\s]+$/).optional(),
+  shell: Joi__default.string().trim().optional(),
+  // network: Joi.string().valid('host', 'bridge', 'none').default('host').optional(),
+  volumes: Joi__default.array().items(Joi__default.string().trim()).optional(),
+  script: Joi__default.string().trim().optional(),
+  installNodeModules: Joi__default.boolean().optional(),
+  command: Joi__default.string().trim().optional(),
+  runBaseScript: Joi__default.boolean().optional(),
+  // 动态 Docker 参数
+  ...allowedDockerArgKeys.reduce(
+    (acc, key) => {
+      const validFn = dockerArgsValidator[dockerCamelCaseToDash(key)];
+      if (multiValueArgs.includes(key)) {
+        acc[key] = Joi__default.array().items(Joi__default.string().trim()).optional();
+        if (validFn) {
+          acc[key] = Joi__default.array().items(
+            Joi__default.string().trim().custom((value, helper) => {
+              const msg = validFn(value);
+              if (msg) {
+                return helper.message(msg);
+              }
+              return value;
+            })
+            // eslint-disable-line @typescript-eslint/comma-dangle
+          ).optional();
+        } else {
+          acc[key] = Joi__default.array().items(Joi__default.string().trim()).optional();
+        }
+        return acc;
+      }
+      if (validFn) {
+        acc[key] = Joi__default.string().trim().custom((value, helper) => {
+          const msg = validFn(value);
+          if (msg) {
+            return helper.message(msg);
+          }
+          return value;
+        }).optional();
+      } else {
+        acc[key] = Joi__default.string().trim().optional();
+      }
+      return acc;
+    },
+    {}
+    // eslint-disable-line @typescript-eslint/comma-dangle
+  )
+}).optional();
+const validateDockerImage = (dockerImage) => {
+  const reg = /^(?:[a-zA-Z0-9.-]+(?::[0-9]+)?\/)?(?:[a-z0-9]+(?:[._-][a-z0-9]+)*\/)?[a-z0-9]+(?:[._-][a-z0-9]+)*(:[a-zA-Z0-9_.-]+)?$/;
+  return Joi__default.string().trim().regex(reg).required().validate(dockerImage);
+};
+const parseDockerArgsToSchema = (dockerImage, args) => {
+  const obj = {};
+  args.forEach((item) => {
+    const key = dockerArgsToCamelCase(item.key);
+    if (multiValueArgs.includes(key)) {
+      obj[key] = [...obj[key] || [], item.value];
+    } else {
+      obj[key] = item.value;
+    }
+  });
+  const { error } = validateDockerImage(dockerImage);
+  if (error) {
+    return { error, value: obj };
+  }
+  obj.image = dockerImage;
+  return dockerSchema.validate(obj);
+};
+
+function dockerParsePublishPorts(dockerImage, dockerArgs) {
+  const updatedDockerArgs = JSON.parse(JSON.stringify(dockerArgs));
+  const hostPortMap = /* @__PURE__ */ new Map();
+  let blockletPortIndex = 1;
+  const publishPorts = [];
+  updatedDockerArgs.forEach((arg) => {
+    if (arg.key === "--publish") {
+      const publishValue = arg.value;
+      const parts = publishValue.split(":");
+      let hostIP = "127.0.0.1";
+      let hostPort = "";
+      let containerPort = "";
+      if (parts.length === 2) {
+        [hostPort, containerPort] = parts;
+      } else if (parts.length === 3) {
+        [hostIP, hostPort, containerPort] = parts;
+      } else if (parts.length === 1) {
+        containerPort = parts[0] || "";
+      }
+      let blockletPort = hostPortMap.get(hostPort || "");
+      if (!blockletPort) {
+        blockletPort = `$BLOCKLET_PORT_${blockletPortIndex++}`;
+        hostPortMap.set(hostPort || "", blockletPort);
+      }
+      if (!publishPorts.find((port) => port.port === hostPort)) {
+        publishPorts.push({
+          type: publishPorts.length === 0 ? "web" : "docker",
+          name: `${dockerImage}-${publishPorts.length + 1}`,
+          path: `/${dockerImage}-${publishPorts.length + 1}`,
+          port: hostPort || containerPort,
+          // 若未指定 hostPort，则使用 containerPort
+          containerPort: Number(containerPort) || 0,
+          hostIP
+        });
+      }
+    }
+  });
+  return publishPorts;
+}
+
+function dockerParseEnvironments(envs, ignoreCustom = false) {
+  const blockletEnvs = [];
+  if (!envs) {
+    return blockletEnvs;
+  }
+  for (const env of envs) {
+    const item = {
+      name: env.key,
+      default: env.value === `$${env.key}` ? "" : env.value,
+      secure: env.secure !== void 0 ? env.secure : false,
+      shared: env.shared !== void 0 ? env.shared : false,
+      required: env.required !== void 0 ? env.required : false,
+      description: env.description || env.key
+    };
+    if (!ignoreCustom) {
+      item.custom = env.custom || "";
+    }
+    blockletEnvs.push(item);
+  }
+  return blockletEnvs;
+}
+
+function getObjByPath(data, path) {
+  const obj = JSON.parse(JSON.stringify(data));
+  const keys = path.split(".").map((key) => {
+    const match = key.match(/(.+)\[(.+?)\]/);
+    return match ? [match[1], match[2]] : key;
+  }).flat();
+  return keys.filter(Boolean).reduce((acc, key) => {
+    if (!acc || !key) {
+      return void 0;
+    }
+    const conditionMatch = key?.match(/(.+?)=(.+)/);
+    if (Array.isArray(acc) && conditionMatch) {
+      const [, field, value] = conditionMatch;
+      if (field && value) {
+        acc = acc.find((item) => {
+          const lowerField = Object.keys(item).find((k) => k.toLowerCase() === field.toLowerCase());
+          return lowerField && item[lowerField] === value;
+        });
+      }
+      return acc;
+    }
+    const lowerKey = Object.keys(acc).find((k) => k.toLowerCase() === key.toLowerCase());
+    return lowerKey ? acc[lowerKey] : void 0;
+  }, obj);
+}
+
+exports.allowDockerArgs = allowDockerArgs;
+exports.autoSetDockerArgs = autoSetDockerArgs;
+exports.dockerArgsToCamelCase = dockerArgsToCamelCase;
+exports.dockerArgsValidator = dockerArgsValidator;
+exports.dockerBuildCommand = dockerBuildCommand;
+exports.dockerCamelCaseToDash = dockerCamelCaseToDash;
+exports.dockerParseCommand = dockerParseCommand;
+exports.dockerParseEnvironments = dockerParseEnvironments;
+exports.dockerParsePublishPorts = dockerParsePublishPorts;
+exports.dockerSchema = dockerSchema;
+exports.getObjByPath = getObjByPath;
+exports.multiValueArgs = multiValueArgs;
+exports.notAllowUseCustomDockerArgs = notAllowUseCustomDockerArgs;
+exports.parseDockerArgsToSchema = parseDockerArgsToSchema;
+exports.whiteDockerArgs = whiteDockerArgs;