@storm-software/config-tools/bin/config.js

A package containing various utilities to support custom workspace configurations and environment management for Storm Software projects, including configuration file handling, environment variable management, and logging utilities.

#!/usr/bin/env node

// bin/config.ts
import chalk2 from "chalk";
import { Command } from "commander";

// src/create-storm-config.ts
import { workspaceConfigSchema } from "@storm-software/config/schema";
import defu2 from "defu";
import { existsSync as existsSync3 } from "node:fs";

// src/config-file/get-config-file.ts
import { loadConfig } from "c12";
import defu from "defu";

// src/types.ts
var LogLevel = {
  SILENT: 0,
  FATAL: 10,
  ERROR: 20,
  WARN: 30,
  SUCCESS: 35,
  INFO: 40,
  PERFORMANCE: 50,
  DEBUG: 60,
  TRACE: 70,
  ALL: 100
};
var LogLevelLabel = {
  SILENT: "silent",
  FATAL: "fatal",
  ERROR: "error",
  WARN: "warn",
  SUCCESS: "success",
  INFO: "info",
  PERFORMANCE: "performance",
  DEBUG: "debug",
  TRACE: "trace",
  ALL: "all"
};

// src/utilities/colors.ts
var DEFAULT_COLOR_CONFIG = {
  light: {
    background: "#fafafa",
    foreground: "#1d1e22",
    brand: "#1fb2a6",
    alternate: "#db2777",
    help: "#5C4EE5",
    success: "#087f5b",
    info: "#0550ae",
    debug: "#8afafc",
    warning: "#e3b341",
    danger: "#D8314A",
    fatal: "#51070f",
    performance: "#13c302",
    link: "#3fa6ff",
    positive: "#22c55e",
    negative: "#dc2626",
    gradient: ["#1fb2a6", "#db2777", "#5C4EE5"]
  },
  dark: {
    background: "#1d1e22",
    foreground: "#cbd5e1",
    brand: "#2dd4bf",
    alternate: "#db2777",
    help: "#818cf8",
    success: "#10b981",
    info: "#58a6ff",
    debug: "#8afafc",
    warning: "#f3d371",
    danger: "#D8314A",
    fatal: "#a40e26",
    performance: "#80fd74",
    link: "#3fa6ff",
    positive: "#22c55e",
    negative: "#dc2626",
    gradient: ["#1fb2a6", "#db2777", "#818cf8"]
  }
};
function getColors(config) {
  if (!config?.colors || typeof config.colors !== "object" || !config.colors["dark"] && (!config.colors["base"] || typeof config.colors !== "object" || !config.colors["base"]?.["dark"])) {
    return DEFAULT_COLOR_CONFIG;
  }
  if (config.colors["base"]) {
    if (typeof config.colors["base"]["dark"] === "object") {
      return config.colors["base"]["dark"];
    } else if (config.colors["base"]["dark"] === "string") {
      return config.colors["base"];
    }
  }
  if (typeof config.colors["dark"] === "object") {
    return config.colors["dark"];
  }
  return config.colors ?? DEFAULT_COLOR_CONFIG;
}
function getColor(key, config) {
  const colors = getColors(config);
  const result = (typeof colors["dark"] === "object" ? colors["dark"][key] : colors[key]) || DEFAULT_COLOR_CONFIG["dark"][key] || DEFAULT_COLOR_CONFIG[key];
  if (result) {
    return result;
  }
  if (key === "link" || key === "debug") {
    return getColor("info", config);
  } else if (key === "fatal") {
    return getColor("danger", config);
  }
  return getColor("brand", config);
}

// src/logger/chalk.ts
import chalk from "chalk";
var chalkDefault = {
  hex: (_) => (message) => message,
  bgHex: (_) => ({
    whiteBright: (message) => message,
    white: (message) => message
  }),
  white: (message) => message,
  whiteBright: (message) => message,
  gray: (message) => message,
  bold: {
    hex: (_) => (message) => message,
    bgHex: (_) => ({
      whiteBright: (message) => message,
      white: (message) => message
    }),
    whiteBright: (message) => message,
    white: (message) => message
  },
  dim: {
    hex: (_) => (message) => message,
    gray: (message) => message
  }
};
var getChalk = () => {
  let _chalk = chalk;
  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright || !_chalk?.white) {
    _chalk = chalkDefault;
  }
  return _chalk;
};

// src/logger/is-unicode-supported.ts
function isUnicodeSupported() {
  if (process.platform !== "win32") {
    return process.env.TERM !== "linux";
  }
  return Boolean(process.env.WT_SESSION) || // Windows Terminal
  Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
  process.env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
  process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERM === "rxvt-unicode" || process.env.TERM === "rxvt-unicode-256color" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
}

// src/logger/console-icons.ts
var useIcon = (c, fallback) => isUnicodeSupported() ? c : fallback;
var CONSOLE_ICONS = {
  [LogLevelLabel.ERROR]: useIcon("\u2718", "\xD7"),
  [LogLevelLabel.FATAL]: useIcon("\u{1F571}", "\xD7"),
  [LogLevelLabel.WARN]: useIcon("\u26A0", "\u203C"),
  [LogLevelLabel.INFO]: useIcon("\u2139", "i"),
  [LogLevelLabel.PERFORMANCE]: useIcon("\u23F1", "\u23F1"),
  [LogLevelLabel.SUCCESS]: useIcon("\u2714", "\u221A"),
  [LogLevelLabel.DEBUG]: useIcon("\u{1F6E0}", "D"),
  [LogLevelLabel.TRACE]: useIcon("\u2699", "T"),
  [LogLevelLabel.ALL]: useIcon("\u2709", "\u2192")
};

// src/logger/format-timestamp.ts
var formatTimestamp = (date = /* @__PURE__ */ new Date()) => {
  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
};

// src/logger/get-log-level.ts
var getLogLevel = (label) => {
  switch (label) {
    case "all":
      return LogLevel.ALL;
    case "trace":
      return LogLevel.TRACE;
    case "debug":
      return LogLevel.DEBUG;
    case "performance":
      return LogLevel.PERFORMANCE;
    case "info":
      return LogLevel.INFO;
    case "warn":
      return LogLevel.WARN;
    case "error":
      return LogLevel.ERROR;
    case "fatal":
      return LogLevel.FATAL;
    case "silent":
      return LogLevel.SILENT;
    default:
      return LogLevel.INFO;
  }
};
var getLogLevelLabel = (logLevel = LogLevel.INFO) => {
  if (logLevel >= LogLevel.ALL) {
    return LogLevelLabel.ALL;
  }
  if (logLevel >= LogLevel.TRACE) {
    return LogLevelLabel.TRACE;
  }
  if (logLevel >= LogLevel.DEBUG) {
    return LogLevelLabel.DEBUG;
  }
  if (logLevel >= LogLevel.PERFORMANCE) {
    return LogLevelLabel.PERFORMANCE;
  }
  if (logLevel >= LogLevel.INFO) {
    return LogLevelLabel.INFO;
  }
  if (logLevel >= LogLevel.WARN) {
    return LogLevelLabel.WARN;
  }
  if (logLevel >= LogLevel.ERROR) {
    return LogLevelLabel.ERROR;
  }
  if (logLevel >= LogLevel.FATAL) {
    return LogLevelLabel.FATAL;
  }
  if (logLevel <= LogLevel.SILENT) {
    return LogLevelLabel.SILENT;
  }
  return LogLevelLabel.INFO;
};

// src/logger/console.ts
var getLogFn = (logLevel = LogLevel.INFO, config = {}, _chalk = getChalk()) => {
  const colors = !config.colors?.dark && !config.colors?.["base"] && !config.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config.colors?.dark && typeof config.colors.dark === "string" ? config.colors : config.colors?.["base"]?.dark && typeof config.colors["base"].dark === "string" ? config.colors["base"].dark : config.colors?.["base"] ? config.colors?.["base"] : DEFAULT_COLOR_CONFIG;
  const configLogLevel = config.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
  if (logLevel > getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT || getLogLevel(configLogLevel) <= LogLevel.SILENT) {
    return (_) => {
    };
  }
  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel) {
    return (message) => {
      console.error(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.fatal ?? DEFAULT_COLOR_CONFIG.dark.fatal
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.FATAL]} Fatal] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel) {
    return (message) => {
      console.error(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.danger ?? DEFAULT_COLOR_CONFIG.dark.danger
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.ERROR]} Error] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel) {
    return (message) => {
      console.warn(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.warning ?? DEFAULT_COLOR_CONFIG.dark.warning
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.WARN]} Warn] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel) {
    return (message) => {
      console.info(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.success ?? DEFAULT_COLOR_CONFIG.dark.success
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.SUCCESS]} Success] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel) {
    return (message) => {
      console.info(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.info ?? DEFAULT_COLOR_CONFIG.dark.info
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.INFO]} Info] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.PERFORMANCE >= logLevel) {
    return (message) => {
      console.debug(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.performance ?? DEFAULT_COLOR_CONFIG.dark.performance
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.PERFORMANCE]} Performance] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.DEBUG >= logLevel) {
    return (message) => {
      console.debug(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
          colors.debug ?? DEFAULT_COLOR_CONFIG.dark.debug
        )(
          `[${CONSOLE_ICONS[LogLevelLabel.DEBUG]} Debug] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel) {
    return (message) => {
      console.debug(
        `
${_chalk.gray(formatTimestamp())} ${_chalk.hex("#bbbbbb")(
          `[${CONSOLE_ICONS[LogLevelLabel.TRACE]} Trace] `
        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
      );
    };
  }
  return (message) => {
    console.log(
      `
${_chalk.gray(formatTimestamp())} ${_chalk.hex(
        colors.brand ?? DEFAULT_COLOR_CONFIG.dark.brand
      )(
        `[${CONSOLE_ICONS[LogLevelLabel.ALL]} System] `
      )}${_chalk.bold.whiteBright(formatLogMessage(message))}
`
    );
  };
};
var writeFatal = (message, config) => getLogFn(LogLevel.FATAL, config)(message);
var writeError = (message, config) => getLogFn(LogLevel.ERROR, config)(message);
var writeWarning = (message, config) => getLogFn(LogLevel.WARN, config)(message);
var writeInfo = (message, config) => getLogFn(LogLevel.INFO, config)(message);
var writeSuccess = (message, config) => getLogFn(LogLevel.SUCCESS, config)(message);
var writeTrace = (message, config) => getLogFn(LogLevel.TRACE, config)(message);
var MAX_DEPTH = 6;
var formatLogMessage = (message, options = {}, depth2 = 0) => {
  if (depth2 > MAX_DEPTH) {
    return "<max depth>";
  }
  const prefix = options.prefix ?? "-";
  const skip = options.skip ?? [];
  return typeof message === "undefined" || message === null || !message && typeof message !== "boolean" ? "<none>" : typeof message === "string" ? message : Array.isArray(message) ? `
${message.map((item, index) => ` ${prefix}> #${index} = ${formatLogMessage(item, { prefix: `${prefix}-`, skip }, depth2 + 1)}`).join("\n")}` : typeof message === "object" ? `
${Object.keys(message).filter((key) => !skip.includes(key)).map(
    (key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" ? formatLogMessage(
      message[key],
      { prefix: `${prefix}-`, skip },
      depth2 + 1
    ) : message[key]}`
  ).join("\n")}` : message;
};
var _isFunction = (value) => {
  try {
    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
  } catch {
    return false;
  }
};
var brandIcon = (config = {}, _chalk = getChalk()) => _chalk.hex(getColor("brand", config))("\u{1F5F2}");

// src/utilities/correct-paths.ts
var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
  if (!input) {
    return input;
  }
  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
var _UNC_REGEX = /^[/\\]{2}/;
var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
var correctPaths = function(path) {
  if (!path || path.length === 0) {
    return ".";
  }
  path = normalizeWindowsPath(path);
  const isUNCPath = path?.match(_UNC_REGEX);
  const isPathAbsolute = isAbsolute(path);
  const trailingSeparator = path[path.length - 1] === "/";
  path = normalizeString(path, !isPathAbsolute);
  if (path.length === 0) {
    if (isPathAbsolute) {
      return "/";
    }
    return trailingSeparator ? "./" : ".";
  }
  if (trailingSeparator) {
    path += "/";
  }
  if (_DRIVE_LETTER_RE.test(path)) {
    path += "/";
  }
  if (isUNCPath) {
    if (!isPathAbsolute) {
      return `//./${path}`;
    }
    return `//${path}`;
  }
  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
};
var joinPaths = function(...segments) {
  let path = "";
  for (const seg of segments) {
    if (!seg) {
      continue;
    }
    if (path.length > 0) {
      const pathTrailing = path[path.length - 1] === "/";
      const segLeading = seg[0] === "/";
      const both = pathTrailing && segLeading;
      if (both) {
        path += seg.slice(1);
      } else {
        path += pathTrailing || segLeading ? seg : `/${seg}`;
      }
    } else {
      path += seg;
    }
  }
  return correctPaths(path);
};
function normalizeString(path, allowAboveRoot) {
  let res = "";
  let lastSegmentLength = 0;
  let lastSlash = -1;
  let dots = 0;
  let char = null;
  for (let index = 0; index <= path.length; ++index) {
    if (index < path.length) {
      char = path[index];
    } else if (char === "/") {
      break;
    } else {
      char = "/";
    }
    if (char === "/") {
      if (lastSlash === index - 1 || dots === 1) {
      } else if (dots === 2) {
        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
          if (res.length > 2) {
            const lastSlashIndex = res.lastIndexOf("/");
            if (lastSlashIndex === -1) {
              res = "";
              lastSegmentLength = 0;
            } else {
              res = res.slice(0, lastSlashIndex);
              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
            }
            lastSlash = index;
            dots = 0;
            continue;
          } else if (res.length > 0) {
            res = "";
            lastSegmentLength = 0;
            lastSlash = index;
            dots = 0;
            continue;
          }
        }
        if (allowAboveRoot) {
          res += res.length > 0 ? "/.." : "..";
          lastSegmentLength = 2;
        }
      } else {
        if (res.length > 0) {
          res += `/${path.slice(lastSlash + 1, index)}`;
        } else {
          res = path.slice(lastSlash + 1, index);
        }
        lastSegmentLength = index - lastSlash - 1;
      }
      lastSlash = index;
      dots = 0;
    } else if (char === "." && dots !== -1) {
      ++dots;
    } else {
      dots = -1;
    }
  }
  return res;
}
var isAbsolute = function(p) {
  return _IS_ABSOLUTE_RE.test(p);
};

// src/utilities/find-up.ts
import { existsSync } from "node:fs";
import { join } from "node:path";
var MAX_PATH_SEARCH_DEPTH = 30;
var depth = 0;
function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
  const _startPath = startPath ?? process.cwd();
  if (endDirectoryNames.some(
    (endDirName) => existsSync(join(_startPath, endDirName))
  )) {
    return _startPath;
  }
  if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) {
    return _startPath;
  }
  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
    const parent = join(_startPath, "..");
    return findFolderUp(parent, endFileNames, endDirectoryNames);
  }
  return void 0;
}

// src/utilities/find-workspace-root.ts
var rootFiles = [
  "storm-workspace.json",
  "storm-workspace.yaml",
  "storm-workspace.yml",
  "storm-workspace.js",
  "storm-workspace.ts",
  ".storm-workspace.json",
  ".storm-workspace.yaml",
  ".storm-workspace.yml",
  ".storm-workspace.js",
  ".storm-workspace.ts",
  "lerna.json",
  "nx.json",
  "turbo.json",
  "npm-workspace.json",
  "yarn-workspace.json",
  "pnpm-workspace.json",
  "npm-workspace.yaml",
  "yarn-workspace.yaml",
  "pnpm-workspace.yaml",
  "npm-workspace.yml",
  "yarn-workspace.yml",
  "pnpm-workspace.yml",
  "npm-lock.json",
  "yarn-lock.json",
  "pnpm-lock.json",
  "npm-lock.yaml",
  "yarn-lock.yaml",
  "pnpm-lock.yaml",
  "npm-lock.yml",
  "yarn-lock.yml",
  "pnpm-lock.yml",
  "bun.lockb"
];
var rootDirectories = [
  ".storm-workspace",
  ".nx",
  ".git",
  ".github",
  ".vscode",
  ".verdaccio"
];
function findWorkspaceRootSafe(pathInsideMonorepo) {
  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
    return correctPaths(
      process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH
    );
  }
  return correctPaths(
    findFolderUp(
      pathInsideMonorepo ?? process.cwd(),
      rootFiles,
      rootDirectories
    )
  );
}
function findWorkspaceRoot(pathInsideMonorepo) {
  const result = findWorkspaceRootSafe(pathInsideMonorepo);
  if (!result) {
    throw new Error(
      `Cannot find workspace root upwards from known path. Files search list includes: 
${rootFiles.join(
        "\n"
      )}
Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
    );
  }
  return result;
}

// src/utilities/get-default-config.ts
import {
  STORM_DEFAULT_ERROR_CODES_FILE,
  STORM_DEFAULT_LICENSE
} from "@storm-software/config";
import { existsSync as existsSync2 } from "node:fs";
import { readFile } from "node:fs/promises";
import { join as join2 } from "node:path";
async function getPackageJsonConfig(root) {
  let license = STORM_DEFAULT_LICENSE;
  let homepage = void 0;
  let support = void 0;
  let name = void 0;
  let namespace = void 0;
  let repository = void 0;
  const workspaceRoot = findWorkspaceRoot(root);
  if (existsSync2(join2(workspaceRoot, "package.json"))) {
    const file = await readFile(
      joinPaths(workspaceRoot, "package.json"),
      "utf8"
    );
    if (file) {
      const packageJson = JSON.parse(file);
      if (packageJson.name) {
        name = packageJson.name;
      }
      if (packageJson.namespace) {
        namespace = packageJson.namespace;
      }
      if (packageJson.repository) {
        if (typeof packageJson.repository === "string") {
          repository = packageJson.repository;
        } else if (packageJson.repository.url) {
          repository = packageJson.repository.url;
        }
      }
      if (packageJson.license) {
        license = packageJson.license;
      }
      if (packageJson.homepage) {
        homepage = packageJson.homepage;
      }
      if (packageJson.bugs) {
        if (typeof packageJson.bugs === "string") {
          support = packageJson.bugs;
        } else if (packageJson.bugs.url) {
          support = packageJson.bugs.url;
        }
      }
    }
  }
  return {
    workspaceRoot,
    name,
    namespace,
    repository,
    license,
    homepage,
    support
  };
}
function applyDefaultConfig(config) {
  if (!config.support && config.contact) {
    config.support = config.contact;
  }
  if (!config.contact && config.support) {
    config.contact = config.support;
  }
  if (config.homepage) {
    if (!config.docs) {
      config.docs = `${config.homepage}/docs`;
    }
    if (!config.license) {
      config.license = `${config.homepage}/license`;
    }
    if (!config.support) {
      config.support = `${config.homepage}/support`;
    }
    if (!config.contact) {
      config.contact = `${config.homepage}/contact`;
    }
    if (!config.error?.codesFile || !config?.error?.url) {
      config.error ??= { codesFile: STORM_DEFAULT_ERROR_CODES_FILE };
      if (config.homepage) {
        config.error.url ??= `${config.homepage}/errors`;
      }
    }
  }
  return config;
}

// src/utilities/process-handler.ts
var exitWithError = (config) => {
  writeFatal("Exiting script with an error status...", config);
  process.exit(1);
};
var exitWithSuccess = (config) => {
  writeSuccess("Script completed successfully. Exiting...", config);
  process.exit(0);
};
var handleProcess = (config) => {
  writeTrace(
    `Using the following arguments to process the script: ${process.argv.join(", ")}`,
    config
  );
  process.on("unhandledRejection", (error) => {
    writeError(
      `An Unhandled Rejection occurred while running the program: ${error}`,
      config
    );
    exitWithError(config);
  });
  process.on("uncaughtException", (error) => {
    writeError(
      `An Uncaught Exception occurred while running the program: ${error.message} 
Stacktrace: ${error.stack}`,
      config
    );
    exitWithError(config);
  });
  process.on("SIGTERM", (signal) => {
    writeError(`The program terminated with signal code: ${signal}`, config);
    exitWithError(config);
  });
  process.on("SIGINT", (signal) => {
    writeError(`The program terminated with signal code: ${signal}`, config);
    exitWithError(config);
  });
  process.on("SIGHUP", (signal) => {
    writeError(`The program terminated with signal code: ${signal}`, config);
    exitWithError(config);
  });
};

// src/config-file/get-config-file.ts
var getConfigFileByName = async (fileName, filePath, options = {}) => {
  const workspacePath = filePath || findWorkspaceRoot(filePath);
  const configs = await Promise.all([
    loadConfig({
      cwd: workspacePath,
      packageJson: true,
      name: fileName,
      envName: fileName?.toUpperCase(),
      jitiOptions: {
        debug: false,
        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
          "jiti"
        )
      },
      ...options
    }),
    loadConfig({
      cwd: workspacePath,
      packageJson: true,
      name: fileName,
      envName: fileName?.toUpperCase(),
      jitiOptions: {
        debug: false,
        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
          "jiti"
        )
      },
      configFile: fileName,
      ...options
    })
  ]);
  return defu(configs[0] ?? {}, configs[1] ?? {});
};
var getConfigFile = async (filePath, additionalFileNames = []) => {
  const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
  const result = await getConfigFileByName("storm-workspace", workspacePath);
  let config = result.config;
  const configFile = result.configFile;
  if (config && configFile && Object.keys(config).length > 0 && !config.skipConfigLogging) {
    writeTrace(
      `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`,
      {
        logLevel: "all"
      }
    );
  }
  if (additionalFileNames && additionalFileNames.length > 0) {
    const results = await Promise.all(
      additionalFileNames.map(
        (fileName) => getConfigFileByName(fileName, workspacePath)
      )
    );
    for (const result2 of results) {
      if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
        if (!config.skipConfigLogging && !result2.config.skipConfigLogging) {
          writeTrace(
            `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`,
            {
              logLevel: "all"
            }
          );
        }
        config = defu(result2.config ?? {}, config ?? {});
      }
    }
  }
  if (!config || Object.keys(config).length === 0) {
    return void 0;
  }
  config.configFile = configFile;
  return config;
};

// src/env/get-env.ts
import {
  COLOR_KEYS,
  STORM_DEFAULT_DOCS,
  STORM_DEFAULT_HOMEPAGE,
  STORM_DEFAULT_LICENSING
} from "@storm-software/config";
var getExtensionEnv = (extensionName) => {
  const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
  return Object.keys(process.env).filter((key) => key.startsWith(prefix)).reduce((ret, key) => {
    const name = key.replace(prefix, "").split("_").map(
      (i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""
    ).join("");
    if (name) {
      ret[name] = process.env[key];
    }
    return ret;
  }, {});
};
var getConfigEnv = () => {
  const prefix = "STORM_";
  let config = {
    extends: process.env[`${prefix}EXTENDS`] || void 0,
    name: process.env[`${prefix}NAME`] || void 0,
    variant: process.env[`${prefix}VARIANT`] || void 0,
    namespace: process.env[`${prefix}NAMESPACE`] || void 0,
    owner: process.env[`${prefix}OWNER`] || void 0,
    bot: {
      name: process.env[`${prefix}BOT_NAME`] || void 0,
      email: process.env[`${prefix}BOT_EMAIL`] || void 0
    },
    release: {
      banner: {
        url: process.env[`${prefix}RELEASE_BANNER_URL`] || void 0,
        alt: process.env[`${prefix}RELEASE_BANNER_ALT`] || void 0
      },
      header: process.env[`${prefix}RELEASE_HEADER`] || void 0,
      footer: process.env[`${prefix}RELEASE_FOOTER`] || void 0
    },
    error: {
      codesFile: process.env[`${prefix}ERROR_CODES_FILE`] || void 0,
      url: process.env[`${prefix}ERROR_URL`] || void 0
    },
    socials: {
      twitter: process.env[`${prefix}SOCIAL_TWITTER`] || void 0,
      discord: process.env[`${prefix}SOCIAL_DISCORD`] || void 0,
      telegram: process.env[`${prefix}SOCIAL_TELEGRAM`] || void 0,
      slack: process.env[`${prefix}SOCIAL_SLACK`] || void 0,
      medium: process.env[`${prefix}SOCIAL_MEDIUM`] || void 0,
      github: process.env[`${prefix}SOCIAL_GITHUB`] || void 0
    },
    organization: process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`] ? process.env[`${prefix}ORG_DESCRIPTION`] || process.env[`${prefix}ORGANIZATION_DESCRIPTION`] || process.env[`${prefix}ORG_URL`] || process.env[`${prefix}ORGANIZATION_URL`] || process.env[`${prefix}ORG_LOGO`] || process.env[`${prefix}ORGANIZATION_LOGO`] ? {
      name: process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`],
      description: process.env[`${prefix}ORG_DESCRIPTION`] || process.env[`${prefix}ORGANIZATION_DESCRIPTION`] || void 0,
      url: process.env[`${prefix}ORG_URL`] || process.env[`${prefix}ORGANIZATION_URL`] || void 0,
      logo: process.env[`${prefix}ORG_LOGO`] || process.env[`${prefix}ORGANIZATION_LOGO`] || void 0,
      icon: process.env[`${prefix}ORG_ICON`] || process.env[`${prefix}ORGANIZATION_ICON`] || void 0
    } : process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`] : void 0,
    packageManager: process.env[`${prefix}PACKAGE_MANAGER`] || void 0,
    license: process.env[`${prefix}LICENSE`] || void 0,
    homepage: process.env[`${prefix}HOMEPAGE`] || void 0,
    docs: process.env[`${prefix}DOCS`] || void 0,
    portal: process.env[`${prefix}PORTAL`] || void 0,
    licensing: process.env[`${prefix}LICENSING`] || void 0,
    contact: process.env[`${prefix}CONTACT`] || void 0,
    support: process.env[`${prefix}SUPPORT`] || void 0,
    timezone: process.env[`${prefix}TIMEZONE`] || process.env.TZ || void 0,
    locale: process.env[`${prefix}LOCALE`] || process.env.LOCALE || void 0,
    configFile: process.env[`${prefix}WORKSPACE_CONFIG_FILE`] ? correctPaths(process.env[`${prefix}WORKSPACE_CONFIG_FILE`]) : void 0,
    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`] ? correctPaths(process.env[`${prefix}WORKSPACE_ROOT`]) : void 0,
    directories: {
      cache: process.env[`${prefix}CACHE_DIR`] ? correctPaths(process.env[`${prefix}CACHE_DIR`]) : process.env[`${prefix}CACHE_DIRECTORY`] ? correctPaths(process.env[`${prefix}CACHE_DIRECTORY`]) : void 0,
      data: process.env[`${prefix}DATA_DIR`] ? correctPaths(process.env[`${prefix}DATA_DIR`]) : process.env[`${prefix}DATA_DIRECTORY`] ? correctPaths(process.env[`${prefix}DATA_DIRECTORY`]) : void 0,
      config: process.env[`${prefix}CONFIG_DIR`] ? correctPaths(process.env[`${prefix}CONFIG_DIR`]) : process.env[`${prefix}CONFIG_DIRECTORY`] ? correctPaths(process.env[`${prefix}CONFIG_DIRECTORY`]) : void 0,
      temp: process.env[`${prefix}TEMP_DIR`] ? correctPaths(process.env[`${prefix}TEMP_DIR`]) : process.env[`${prefix}TEMP_DIRECTORY`] ? correctPaths(process.env[`${prefix}TEMP_DIRECTORY`]) : void 0,
      log: process.env[`${prefix}LOG_DIR`] ? correctPaths(process.env[`${prefix}LOG_DIR`]) : process.env[`${prefix}LOG_DIRECTORY`] ? correctPaths(process.env[`${prefix}LOG_DIRECTORY`]) : void 0,
      build: process.env[`${prefix}BUILD_DIR`] ? correctPaths(process.env[`${prefix}BUILD_DIR`]) : process.env[`${prefix}BUILD_DIRECTORY`] ? correctPaths(process.env[`${prefix}BUILD_DIRECTORY`]) : void 0
    },
    skipCache: process.env[`${prefix}SKIP_CACHE`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CACHE`]) : void 0,
    mode: (process.env[`${prefix}MODE`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT) || void 0,
    // ci:
    //   process.env[`${prefix}CI`] !== undefined
    //     ? Boolean(
    //         process.env[`${prefix}CI`] ??
    //           process.env.CI ??
    //           process.env.CONTINUOUS_INTEGRATION
    //       )
    //     : undefined,
    repository: process.env[`${prefix}REPOSITORY`] || void 0,
    branch: process.env[`${prefix}BRANCH`] || void 0,
    preid: process.env[`${prefix}PRE_ID`] || void 0,
    registry: {
      github: process.env[`${prefix}REGISTRY_GITHUB`] || void 0,
      npm: process.env[`${prefix}REGISTRY_NPM`] || void 0,
      cargo: process.env[`${prefix}REGISTRY_CARGO`] || void 0,
      cyclone: process.env[`${prefix}REGISTRY_CYCLONE`] || void 0,
      container: process.env[`${prefix}REGISTRY_CONTAINER`] || void 0
    },
    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(
      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
    ) ? getLogLevelLabel(
      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
    ) : process.env[`${prefix}LOG_LEVEL`] : void 0,
    skipConfigLogging: process.env[`${prefix}SKIP_CONFIG_LOGGING`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CONFIG_LOGGING`]) : void 0
  };
  const themeNames = Object.keys(process.env).filter(
    (envKey) => envKey.startsWith(`${prefix}COLOR_`) && COLOR_KEYS.every(
      (colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)
    )
  );
  config.colors = themeNames.length > 0 ? themeNames.reduce(
    (ret, themeName) => {
      ret[themeName] = getThemeColorsEnv(prefix, themeName);
      return ret;
    },
    {}
  ) : getThemeColorsEnv(prefix);
  if (config.docs === STORM_DEFAULT_DOCS) {
    if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
      config.docs = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/docs`;
    } else {
      config.docs = `${config.homepage}/docs`;
    }
  }
  if (config.licensing === STORM_DEFAULT_LICENSING) {
    if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
      config.licensing = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/licensing`;
    } else {
      config.licensing = `${config.homepage}/docs`;
    }
  }
  const serializedConfig = process.env[`${prefix}WORKSPACE_CONFIG`];
  if (serializedConfig) {
    const parsed = JSON.parse(serializedConfig);
    config = {
      ...config,
      ...parsed,
      colors: { ...config.colors, ...parsed.colors },
      extensions: { ...config.extensions, ...parsed.extensions }
    };
  }
  return config;
};
var getThemeColorsEnv = (prefix, theme) => {
  const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
  return process.env[`${prefix}${themeName}LIGHT_BRAND`] || process.env[`${prefix}${themeName}DARK_BRAND`] ? getMultiThemeColorsEnv(prefix + themeName) : getSingleThemeColorsEnv(prefix + themeName);
};
var getSingleThemeColorsEnv = (prefix) => {
  const gradient = [];
  if (process.env[`${prefix}GRADIENT_START`] && process.env[`${prefix}GRADIENT_END`]) {
    gradient.push(
      process.env[`${prefix}GRADIENT_START`],
      process.env[`${prefix}GRADIENT_END`]
    );
  } else if (process.env[`${prefix}GRADIENT_0`] || process.env[`${prefix}GRADIENT_1`]) {
    let index = process.env[`${prefix}GRADIENT_0`] ? 0 : 1;
    while (process.env[`${prefix}GRADIENT_${index}`]) {
      gradient.push(process.env[`${prefix}GRADIENT_${index}`]);
      index++;
    }
  }
  return {
    dark: process.env[`${prefix}DARK`],
    light: process.env[`${prefix}LIGHT`],
    brand: process.env[`${prefix}BRAND`],
    alternate: process.env[`${prefix}ALTERNATE`],
    accent: process.env[`${prefix}ACCENT`],
    link: process.env[`${prefix}LINK`],
    help: process.env[`${prefix}HELP`],
    success: process.env[`${prefix}SUCCESS`],
    info: process.env[`${prefix}INFO`],
    debug: process.env[`${prefix}DEBUG`],
    warning: process.env[`${prefix}WARNING`],
    danger: process.env[`${prefix}DANGER`],
    fatal: process.env[`${prefix}FATAL`],
    performance: process.env[`${prefix}PERFORMANCE`],
    positive: process.env[`${prefix}POSITIVE`],
    negative: process.env[`${prefix}NEGATIVE`],
    gradient
  };
};
var getMultiThemeColorsEnv = (prefix) => {
  return {
    light: getBaseThemeColorsEnv(`${prefix}_LIGHT_`),
    dark: getBaseThemeColorsEnv(`${prefix}_DARK_`)
  };
};
var getBaseThemeColorsEnv = (prefix) => {
  const gradient = [];
  if (process.env[`${prefix}GRADIENT_START`] && process.env[`${prefix}GRADIENT_END`]) {
    gradient.push(
      process.env[`${prefix}GRADIENT_START`],
      process.env[`${prefix}GRADIENT_END`]
    );
  } else if (process.env[`${prefix}GRADIENT_0`] || process.env[`${prefix}GRADIENT_1`]) {
    let index = process.env[`${prefix}GRADIENT_0`] ? 0 : 1;
    while (process.env[`${prefix}GRADIENT_${index}`]) {
      gradient.push(process.env[`${prefix}GRADIENT_${index}`]);
      index++;
    }
  }
  return {
    foreground: process.env[`${prefix}FOREGROUND`],
    background: process.env[`${prefix}BACKGROUND`],
    brand: process.env[`${prefix}BRAND`],
    alternate: process.env[`${prefix}ALTERNATE`],
    accent: process.env[`${prefix}ACCENT`],
    link: process.env[`${prefix}LINK`],
    help: process.env[`${prefix}HELP`],
    success: process.env[`${prefix}SUCCESS`],
    info: process.env[`${prefix}INFO`],
    debug: process.env[`${prefix}DEBUG`],
    warning: process.env[`${prefix}WARNING`],
    danger: process.env[`${prefix}DANGER`],
    fatal: process.env[`${prefix}FATAL`],
    performance: process.env[`${prefix}PERFORMANCE`],
    positive: process.env[`${prefix}POSITIVE`],
    negative: process.env[`${prefix}NEGATIVE`],
    gradient
  };
};

// src/env/set-env.ts
var setExtensionEnv = (extensionName, extension) => {
  for (const key of Object.keys(extension ?? {})) {
    if (extension[key]) {
      const result = key?.replace(
        /([A-Z])+/g,
        (input) => input ? input[0]?.toUpperCase() + input.slice(1) : ""
      ).split(/(?=[A-Z])|[.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
      let extensionKey;
      if (result.length === 0) {
        return;
      }
      if (result.length === 1) {
        extensionKey = result[0]?.toUpperCase() ?? "";
      } else {
        extensionKey = result.reduce((ret, part) => {
          return `${ret}_${part.toLowerCase()}`;
        });
      }
      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
    }
  }
};
var setConfigEnv = (config) => {
  const prefix = "STORM_";
  if (config.extends) {
    process.env[`${prefix}EXTENDS`] = Array.isArray(config.extends) ? JSON.stringify(config.extends) : config.extends;
  }
  if (config.name) {
    process.env[`${prefix}NAME`] = config.name;
  }
  if (config.variant) {
    process.env[`${prefix}VARIANT`] = config.variant;
  }
  if (config.namespace) {
    process.env[`${prefix}NAMESPACE`] = config.namespace;
  }
  if (config.owner) {
    process.env[`${prefix}OWNER`] = config.owner;
  }
  if (config.bot) {
    process.env[`${prefix}BOT_NAME`] = config.bot.name;
    process.env[`${prefix}BOT_EMAIL`] = config.bot.email;
  }
  if (config.error) {
    process.env[`${prefix}ERROR_CODES_FILE`] = config.error.codesFile;
    process.env[`${prefix}ERROR_URL`] = config.error.url;
  }
  if (config.release) {
    if (config.release.banner) {
      if (typeof config.release.banner === "string") {
        process.env[`${prefix}RELEASE_BANNER`] = config.release.banner;
        process.env[`${prefix}RELEASE_BANNER_URL`] = config.release.banner;
      } else {
        process.env[`${prefix}RELEASE_BANNER`] = config.release.banner.url;
        process.env[`${prefix}RELEASE_BANNER_URL`] = config.release.banner.url;
        process.env[`${prefix}RELEASE_BANNER_ALT`] = config.release.banner.alt;
      }
    }
    process.env[`${prefix}RELEASE_HEADER`] = config.release.header;
    process.env[`${prefix}RELEASE_FOOTER`] = config.release.footer;
  }
  if (config.socials) {
    if (config.socials.twitter) {
      process.env[`${prefix}SOCIAL_TWITTER`] = config.socials.twitter;
    }
    if (config.socials.discord) {
      process.env[`${prefix}SOCIAL_DISCORD`] = config.socials.discord;
    }
    if (config.socials.telegram) {
      process.env[`${prefix}SOCIAL_TELEGRAM`] = config.socials.telegram;
    }
    if (config.socials.slack) {
      process.env[`${prefix}SOCIAL_SLACK`] = config.socials.slack;
    }
    if (config.socials.medium) {
      process.env[`${prefix}SOCIAL_MEDIUM`] = config.socials.medium;
    }
    if (config.socials.github) {
      process.env[`${prefix}SOCIAL_GITHUB`] = config.socials.github;
    }
  }
  if (config.organization) {
    if (typeof config.organization === "string") {
      process.env[`${prefix}ORG`] = config.organization;
      process.env[`${prefix}ORG_NAME`] = config.organization;
      process.env[`${prefix}ORGANIZATION`] = config.organization;
      process.env[`${prefix}ORGANIZATION_NAME`] = config.organization;
    } else {
      process.env[`${prefix}ORG`] = config.organization.name;
      process.env[`${prefix}ORG_NAME`] = config.organization.name;
      process.env[`${prefix}ORGANIZATION`] = config.organization.name;
      process.env[`${prefix}ORGANIZATION_NAME`] = config.organization.name;
      if (config.organization.url) {
        process.env[`${prefix}ORG_URL`] = config.organization.url;
        process.env[`${prefix}ORGANIZATION_URL`] = config.organization.url;
      }
      if (config.organization.description) {
        process.env[`${prefix}ORG_DESCRIPTION`] = config.organization.description;
        process.env[`${prefix}ORGANIZATION_DESCRIPTION`] = config.organization.description;
      }
      if (config.organization.logo) {
        process.env[`${prefix}ORG_LOGO`] = config.organization.logo;
        process.env[`${prefix}ORGANIZATION_LOGO`] = config.organization.logo;
      }
      if (config.organization.icon) {
        process.env[`${prefix}ORG_ICON`] = config.organization.icon;
        process.env[`${prefix}ORGANIZATION_ICON`] = config.organization.icon;
      }
    }
  }
  if (config.packageManager) {
    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
  }
  if (config.license) {
    process.env[`${prefix}LICENSE`] = config.license;
  }
  if (config.homepage) {
    process.env[`${prefix}HOMEPAGE`] = config.homepage;
  }
  if (config.docs) {
    process.env[`${prefix}DOCS`] = config.docs;
  }
  if (config.portal) {
    process.env[`${prefix}PORTAL`] = config.portal;
  }
  if (config.licensing) {
    process.env[`${prefix}LICENSING`] = config.licensing;
  }
  if (config.contact) {
    process.env[`${prefix}CONTACT`] = config.contact;
  }
  if (config.support) {
    process.env[`${prefix}SUPPORT`] = config.support;
  }
  if (config.timezone) {
    process.env[`${prefix}TIMEZONE`] = config.timezone;
    process.env.TZ = config.timezone;
    process.env.DEFAULT_TIMEZONE = config.timezone;
    process.env.TIMEZONE = config.timezone;
  }
  if (config.locale) {
    process.env[`${prefix}LOCALE`] = config.locale;
    process.env.DEFAULT_LOCALE = config.locale;
    process.env.LOCALE = config.locale;
    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
  }
  if (config.configFile) {
    process.env[`${prefix}WORKSPACE_CONFIG_FILE`] = correctPaths(
      config.configFile
    );
  }
  if (config.workspaceRoot) {
    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config.workspaceRoot);
    process.env.NX_WORKSPACE_ROOT = correctPaths(config.workspaceRoot);
    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config.workspaceRoot);
  }
  if (config.directories) {
    if (!config.skipCache && config.directories.cache) {
      process.env[`${prefix}CACHE_DIR`] = correctPaths(
        config.directories.cache
      );
      process.env[`${prefix}CACHE_DIRECTORY`] = process.env[`${prefix}CACHE_DIR`];
    }
    if (config.directories.data) {
      process.env[`${prefix}DATA_DIR`] = correctPaths(config.directories.data);
      process.env[`${prefix}DATA_DIRECTORY`] = process.env[`${prefix}DATA_DIR`];
    }
    if (config.directories.config) {
      process.env[`${prefix}CONFIG_DIR`] = correctPaths(
        config.directories.config
      );
      process.env[`${prefix}CONFIG_DIRECTORY`] = process.env[`${prefix}CONFIG_DIR`];
    }
    if (config.directories.temp) {
      process.env[`${prefix}TEMP_DIR`] = correctPaths(config.directories.temp);
      process.env[`${prefix}TEMP_DIRECTORY`] = process.env[`${prefix}TEMP_DIR`];
    }
    if (config.directories.log) {
      process.env[`${prefix}LOG_DIR`] = correctPaths(config.directories.log);
      process.env[`${prefix}LOG_DIRECTORY`] = process.env[`${prefix}LOG_DIR`];
    }
    if (config.directories.build) {
      process.env[`${prefix}BUILD_DIR`] = correctPaths(
        config.directories.build
      );
      process.env[`${prefix}BUILD_DIRECTORY`] = process.env[`${prefix}BUILD_DIR`];
    }
  }
  if (config.skipCache !== void 0) {
    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
    if (config.skipCache) {
      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
    }
  }
  if (config.mode) {
    process.env[`${prefix}MODE`] = config.mode;
    process.env.NODE_ENV = config.mode;
    process.env.ENVIRONMENT = config.mode;
  }
  if (config.colors?.base?.light || config.colors?.base?.dark) {
    for (const key of Object.keys(config.colors)) {
      setThemeColorsEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
    }
  } else {
    setThemeColorsEnv(
      `${prefix}COLOR_`,
      config.colors
    );
  }
  if (config.repository) {
    process.env[`${prefix}REPOSITORY`] = config.repository;
  }
  if (config.branch) {
    process.env[`${prefix}BRANCH`] = config.branch;
  }
  if (config.preid) {
    process.env[`${prefix}PRE_ID`] = String(config.preid);
  }
  if (config.registry) {
    if (config.registry.github) {
      process.env[`${prefix}REGISTRY_GITHUB`] = String(config.registry.github);
    }
    if (config.registry.npm) {
      process.env[`${prefix}REGISTRY_NPM`] = String(config.registry.npm);
    }
    if (config.registry.cargo) {
      process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
    }
    if (config.registry.cyclone) {
      process.env[`${prefix}REGISTRY_CYCLONE`] = String(
        config.registry.cyclone
      );
    }
    if (config.registry.container) {
      process.env[`${prefix}REGISTRY_CONTAINER`] = String(
        config.registry.container
      );
    }
  }
  if (config.logLevel) {
    process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
    process.env.LOG_LEVEL = String(config.logLevel);
    process.env.NX_VERBOSE_LOGGING = String(
      getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false
    );
    process.env.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
  }
  if (config.skipConfigLogging !== void 0) {
    process.env[`${prefix}SKIP_CONFIG_LOGGING`] = String(
      config.skipConfigLogging
    );
  }
  process.env[`${prefix}WORKSPACE_CONFIG`] = JSON.stringify(config);
  for (const key of Object.keys(config.extensions ?? {})) {
    if (config.extensions[key] && Object.keys(config.extensions[key])) {
      setExtensionEnv(key, config.extensions[key]);
    }
  }
};
var setThemeColorsEnv = (prefix, config) => {
  return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorsEnv(prefix, config) : setSingleThemeColorsEnv(prefix, config);
};
var setSingleThemeColorsEnv = (prefix, config) => {
  if (config.dark) {
    process.env[`${prefix}DARK`] = config.dark;
  }
  if (config.light) {
    process.env[`${prefix}LIGHT`] = config.light;
  }
  if (config.brand) {
    process.env[`${prefix}BRAND`] = config.brand;
  }
  if (config.alternate) {
    process.env[`${prefix}ALTERNATE`] = config.alternate;
  }
  if (config.accent) {
    process.env[`${prefix}ACCENT`] = config.accent;
  }
  if (config.link) {
    process.env[`${prefix}LINK`] = config.link;
  }
  if (config.help) {
    process.env[`${prefix}HELP`] = config.help;
  }
  if (config.success) {
    process.env[`${prefix}SUCCESS`] = config.success;
  }
  if (config.info) {
    process.env[`${prefix}INFO`] = config.info;
  }
  if (config.debug) {
    process.env[`${prefix}DEBUG`] = config.debug;
  }
  if (config.warning) {
    process.env[`${prefix}WARNING`] = config.warning;
  }
  if (config.danger) {
    process.env[`${prefix}DANGER`] = config.danger;
  }
  if (config.fatal) {
    process.env[`${prefix}FATAL`] = config.fatal;
  }
  if (config.performance) {
    process.env[`${prefix}PERFORMANCE`] = config.performance;
  }
  if (config.positive) {
    process.env[`${prefix}POSITIVE`] = config.positive;
  }
  if (config.negative) {
    process.env[`${prefix}NEGATIVE`] = config.negative;
  }
  if (config.gradient) {
    for (let i = 0; i < config.gradient.length; i++) {
      process.env[`${prefix}GRADIENT_${i}`] = config.gradient[i];
    }
  }
};
var setMultiThemeColorsEnv = (prefix, config) => {
  return {
    light: setBaseThemeColorsEnv(`${prefix}LIGHT_`, config.light),
    dark: setBaseThemeColorsEnv(`${prefix}DARK_`, config.dark)
  };
};
var setBaseThemeColorsEnv = (prefix, config) => {
  if (config.foreground) {
    process.env[`${prefix}FOREGROUND`] = config.foreground;
  }
  if (config.background) {
    process.env[`${prefix}BACKGROUND`] = config.background;
  }
  if (config.brand) {
    process.env[`${prefix}BRAND`] = config.brand;
  }
  if (config.alternate) {
    process.env[`${prefix}ALTERNATE`] = config.alternate;
  }
  if (config.accent) {
    process.env[`${prefix}ACCENT`] = config.accent;
  }
  if (config.link) {
    process.env[`${prefix}LINK`] = config.link;
  }
  if (config.help) {
    process.env[`${prefix}HELP`] = config.help;
  }
  if (config.success) {
    process.env[`${prefix}SUCCESS`] = config.success;
  }
  if (config.info) {
    process.env[`${prefix}INFO`] = config.info;
  }
  if (config.debug) {
    process.env[`${prefix}DEBUG`] = config.debug;
  }
  if (config.warning) {
    process.env[`${prefix}WARNING`] = config.warning;
  }
  if (config.danger) {
    process.env[`${prefix}DANGER`] = config.danger;
  }
  if (config.fatal) {
    process.env[`${prefix}FATAL`] = config.fatal;
  }
  if (config.performance) {
    process.env[`${prefix}PERFORMANCE`] = config.performance;
  }
  if (config.positive) {
    process.env[`${prefix}POSITIVE`] = config.positive;
  }
  if (config.negative) {
    process.env[`${prefix}NEGATIVE`] = config.negative;
  }
  if (config.gradient) {
    for (let i = 0; i < config.gradient.length; i++) {
      process.env[`${prefix}GRADIENT_${i}`] = config.gradient[i];
    }
  }
};

// src/create-storm-config.ts
var _extension_cache = /* @__PURE__ */ new WeakMap();
var _static_cache = void 0;
var createStormWorkspaceConfig = async (extensionName, schema, workspaceRoot, skipLogs = false, useDefault = true) => {
  let result;
  if (!_static_cache?.data || !_static_cache?.timestamp || _static_cache.timestamp < Date.now() - 8e3) {
    let _workspaceRoot = workspaceRoot;
    if (!_workspaceRoot) {
      _workspaceRoot = findWorkspaceRoot();
    }
    const configEnv = getConfigEnv();
    const configFile = await getConfigFile(_workspaceRoot);
    if (!configFile) {
      if (!skipLogs) {
        writeWarning(
          "No Storm Workspace configuration file found in the current repository. Please ensure this is the expected behavior - you can add a `storm-workspace.json` file to the root of your workspace if it is not.\n",
          { logLevel: "all" }
        );
      }
      if (useDefault === false) {
        return void 0;
      }
    }
    const defaultConfig = await getPackageJsonConfig(_workspaceRoot);
    const configInput = defu2(
      configEnv,
      configFile,
      defaultConfig
    );
    if (!configInput.variant) {
      configInput.variant = existsSync3(joinPaths(_workspaceRoot, "nx.json")) || existsSync3(joinPaths(_workspaceRoot, ".nx")) || existsSync3(joinPaths(_workspaceRoot, "lerna.json")) || existsSync3(joinPaths(_workspaceRoot, "turbo.json")) ? "monorepo"