dotsec 4.0.0-beta.f6d5ebb.0 → 5.0.0-beta.2d72d7d

package/dist/cli/index.mjs

@@ -1,1493 +0,0 @@
-import { Command, Option } from 'commander';
-import fs from 'fs';
-import path from 'node:path';
-import { bundleRequire } from 'bundle-require';
-import JoyCon from 'joycon';
-import path2 from 'path';
-import fs2, { stat } from 'node:fs/promises';
-import prompts from 'prompts';
-import chalk2 from 'chalk';
-import 'cli-table';
-import { expand } from 'dotenv-expand';
-import fs3 from 'node:fs';
-import { camelCase } from 'camel-case';
-import { spawn } from 'node:child_process';
-import Ajv from 'ajv';
-import yargsParser from 'yargs-parser';
-
-// src/cli/index.ts
-
-// src/constants.ts
-var DOTSEC_DEFAULT_CONFIG_FILE = "dotsec.config.ts";
-var DOTSEC_CONFIG_FILES = [DOTSEC_DEFAULT_CONFIG_FILE];
-var DOTSEC_DEFAULT_DOTSEC_FILENAME = ".sec";
-var DOTSEC_DEFAULT_DOTENV_FILENAME = ".env";
-var defaultConfig = {
-  defaults: {
-    // encryptionEngine: "pke",
-    // plugins: {
-    // 	pke: {},
-    // },
-    options: {
-      showRedacted: false
-    }
-  }
-};
-function jsoncParse(data) {
-  try {
-    return new Function(`return ${data.trim()}`)();
-  } catch {
-    return {};
-  }
-}
-var loadJson = async (filepath) => {
-  try {
-    return jsoncParse(await fs.promises.readFile(filepath, "utf8"));
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(
-        `Failed to parse ${path.relative(process.cwd(), filepath)}: ${error.message}`
-      );
-    } else {
-      throw error;
-    }
-  }
-};
-var getMagicalConfig = async (filename) => {
-  const cwd = process.cwd();
-  const configJoycon = new JoyCon();
-  const configPath = await configJoycon.resolve({
-    files: filename ? [filename] : [...DOTSEC_CONFIG_FILES, "package.json"],
-    cwd,
-    stopDir: path2.parse(cwd).root,
-    packageKey: "dotsec"
-  });
-  if (filename && configPath === null) {
-    throw new Error(`Could not find config file ${filename}`);
-  }
-  if (configPath) {
-    if (configPath.endsWith(".json")) {
-      const rawData = await loadJson(configPath);
-      let data;
-      if (configPath.endsWith("package.json") && rawData.dotsec !== void 0) {
-        data = rawData.dotsec;
-      } else {
-        data = rawData;
-      }
-      return {
-        source: "json",
-        contents: {
-          ...defaultConfig,
-          ...data,
-          defaults: {
-            ...data?.defaults,
-            ...defaultConfig.defaults,
-            options: {
-              ...data?.defaults?.options,
-              ...defaultConfig.defaults?.options
-            },
-            plugins: {
-              ...data?.defaults?.plugins,
-              ...defaultConfig.defaults?.plugins
-            }
-          },
-          push: {
-            ...data?.push
-          }
-        }
-      };
-    } else if (configPath.endsWith(".ts")) {
-      const bundleRequireResult = await bundleRequire({
-        filepath: configPath
-      });
-      const data = bundleRequireResult.mod.dotsec || bundleRequireResult.mod.default || bundleRequireResult.mod;
-      return {
-        source: "ts",
-        contents: {
-          ...defaultConfig,
-          ...data,
-          defaults: {
-            ...data?.defaults,
-            ...defaultConfig.defaults,
-            plugins: {
-              ...data?.defaults?.plugins,
-              ...defaultConfig.defaults?.plugins
-            },
-            options: {
-              ...data?.defaults?.options,
-              ...defaultConfig.defaults?.options
-            }
-          },
-          push: {
-            ...data?.push
-          }
-        }
-      };
-    }
-  }
-  return { source: "defaultConfig", contents: defaultConfig };
-};
-
-// src/lib/loadDotsecPlugin.ts
-var loadDotsecPlugin = async (options) => {
-  return import(options.name).then((imported) => {
-    return imported.default;
-  });
-};
-var addPluginOptions = (options, command, mandatory) => {
-  if (options) {
-    Object.values(options).map((option) => {
-      let optionProps;
-      if (Array.isArray(option)) {
-        const [flags, description, defaultValue] = option;
-        optionProps = {
-          flags,
-          description,
-          defaultValue
-        };
-      } else {
-        const { flags, description, defaultValue, choices, env, fn } = option;
-        optionProps = {
-          flags,
-          description,
-          defaultValue,
-          choices,
-          env,
-          fn
-        };
-      }
-      if (optionProps) {
-        const newOption = new Option(
-          optionProps.flags,
-          optionProps.description
-        );
-        if (optionProps.fn) {
-          newOption.argParser(optionProps.fn);
-        }
-        if (optionProps.defaultValue) {
-          newOption.default(optionProps.defaultValue);
-        }
-        if (optionProps.env) {
-          newOption.env(optionProps.env);
-        }
-        if (mandatory) {
-          newOption.makeOptionMandatory(true);
-        }
-        if (optionProps.choices) {
-          newOption.choices(optionProps.choices);
-        }
-        command.addOption(newOption);
-      }
-    });
-  }
-};
-var readContentsFromFile = async (filePath) => {
-  return await fs2.readFile(filePath, "utf-8");
-};
-var writeContentsToFile = async (filePath, contents) => {
-  return await fs2.writeFile(filePath, contents, "utf-8");
-};
-var fileExists = async (source) => {
-  try {
-    await stat(source);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var promptOverwriteIfFileExists = async ({
-  filePath,
-  skip
-}) => {
-  let overwriteResponse;
-  if (await fileExists(filePath) && skip !== true) {
-    overwriteResponse = await prompts({
-      type: "confirm",
-      name: "overwrite",
-      message: () => {
-        return `Overwrite './${path.relative(process.cwd(), filePath)}' ?`;
-      }
-    });
-  } else {
-    overwriteResponse = void 0;
-  }
-  return overwriteResponse;
-};
-
-// src/lib/parse.ts
-var LINE = /^(#.*)|(\s?\r?\n)|(?:^|^)\s*(?:export\s+)?([\w.-]*)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?(\s*)(#.*)?(?:$|$)/gm;
-var parse = (src) => {
-  const obj = {};
-  const blocks = [];
-  let lines = src.toString();
-  lines = lines.replace(/\r\n?/gm, "\n");
-  let match;
-  while ((match = LINE.exec(lines)) != null) {
-    const key = match[3];
-    if (match?.[1]?.[0] === "#") {
-      blocks.push({ type: "comment", raw: match[1] });
-    } else if (match?.[2]) {
-      blocks.push({ type: "whitespace", raw: match[2] });
-    } else {
-      let value = match[4] || "";
-      value = value.trim();
-      const maybeQuote = value[0];
-      value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
-      if (maybeQuote === '"') {
-        value = value.replace(/\\n/g, "\n");
-        value = value.replace(/\\r/g, "\r");
-      }
-      obj[key] = value;
-      blocks.push({
-        type: "value",
-        key,
-        value,
-        raw: value + (match[5] ? match[5] : "") + (match[6] ? match[6] : "")
-      });
-    }
-  }
-  return { blocks, obj };
-};
-if (import.meta.vitest) {
-  const { it, expect } = import.meta.vitest;
-  it("parse", () => {
-    const input1 = "KEY=value";
-    const input2 = 'KEY="value"';
-    const input3 = "KEY='value'";
-    const input4 = "KEY=value #   this is a comment";
-    expect(parse(input1)).toMatchInlineSnapshot(`
-			{
-			  "blocks": [
-			    {
-			      "key": "KEY",
-			      "raw": "value",
-			      "type": "value",
-			      "value": "value",
-			    },
-			  ],
-			  "obj": {
-			    "KEY": "value",
-			  },
-			}
-		`);
-    expect(parse(input2)).toMatchInlineSnapshot(`
-			{
-			  "blocks": [
-			    {
-			      "key": "KEY",
-			      "raw": "value",
-			      "type": "value",
-			      "value": "value",
-			    },
-			  ],
-			  "obj": {
-			    "KEY": "value",
-			  },
-			}
-		`);
-    expect(parse(input3)).toMatchInlineSnapshot(`
-			{
-			  "blocks": [
-			    {
-			      "key": "KEY",
-			      "raw": "value",
-			      "type": "value",
-			      "value": "value",
-			    },
-			  ],
-			  "obj": {
-			    "KEY": "value",
-			  },
-			}
-		`);
-    expect(parse(input4)).toMatchInlineSnapshot(`
-      {
-        "blocks": [
-          {
-            "key": "KEY",
-            "raw": "value#   this is a comment",
-            "type": "value",
-            "value": "value",
-          },
-        ],
-        "obj": {
-          "KEY": "value",
-        },
-      }
-    `);
-  });
-}
-var strong = (str) => chalk2.yellow.bold(str);
-
-// src/types/colors.ts
-var backgroundColors = [
-  "black",
-  "red",
-  "green",
-  "yellow",
-  "blue",
-  "magenta",
-  "cyan",
-  "white",
-  "black-bright",
-  "gray",
-  "grey",
-  "red-bright",
-  "green-bright",
-  "yellow-bright",
-  "blue-bright",
-  "magenta-bright",
-  "cyan-bright",
-  "white-bright"
-];
-
-// src/cli/options/sharedOptions.ts
-var envFileOption = {
-  option: [
-    "--env-file <envFile>",
-    `Path to .env file. If not provided, will look for value in 'ENV_FILE' environment variable. If not provided, will look for '${DOTSEC_DEFAULT_DOTENV_FILENAME}' file in current directory.`,
-    DOTSEC_DEFAULT_DOTENV_FILENAME
-  ],
-  env: "ENV_FILE"
-};
-var secFileOption = {
-  option: [
-    "--sec-file, <secFile>",
-    `Path to .sec file. If not provided, will look for value in 'SEC_FILE' environment variable. If not provided, will look for '${DOTSEC_DEFAULT_DOTSEC_FILENAME}' file in current directory.`,
-    DOTSEC_DEFAULT_DOTSEC_FILENAME
-  ],
-  env: "SEC_FILE"
-};
-var usingOption = {
-  flags: "--using <using>",
-  description: "Wether to use a dot env file or a dot sec file",
-  choices: ["env", "sec"],
-  env: "DOTSEC_USING"
-};
-var usingNoEncryptionEngineOption = {
-  flags: "--using <using>",
-  description: "Wether to use a dot env file or a dot sec file",
-  choices: ["env"],
-  env: "DOTSEC_USING"
-};
-var showOutputPrefixOption = {
-  flags: "--show-output-prefix",
-  description: "Show output prefix",
-  env: "DOTSEC_SHOW_OUTPUT_PREFIX"
-};
-var outputPrefixOption = {
-  flags: "--output-prefix <outputPrefix>",
-  description: "Output prefix",
-  env: "DOTSEC_OUTPUT_PREFIX"
-};
-var outputBackgroundColorOption = {
-  flags: "--output-background-color <outputBackgroundColor>",
-  description: "Background color of the output.",
-  env: "DOTSEC_OUTPUT_BACKGROUND_COLOR",
-  choices: [...backgroundColors, true]
-};
-var yesOption = {
-  option: ["--yes", "Skip confirmation prompts"]
-};
-var configFileOption = {
-  option: ["-c, --config-file, --configFile <configFile>", "Config file"],
-  env: "DOTSEC_CONFIG_FILE"
-};
-var pluginOption = {
-  option: ["--plugin <plugin>", "Comma-separated list of plugins to use"],
-  env: "DOTSEC_PLUGIN"
-};
-var engineOption = {
-  option: ["--engine <engine>", "Encryption engine to use"],
-  env: "DOTSEC_ENGINE"
-};
-var createManifestOption = {
-  option: [
-    "--create-manifest",
-    "Create a markdown manifest file. See the --manifest-file option for more information."
-  ],
-  env: "CREATE_MANIFEST"
-};
-var manifestFilePrefixOption = {
-  option: [
-    "--manifest-file-prefix <manifestFilePrefix>",
-    "Mmanifest file prefix"
-  ],
-  env: "ENCRYPTION_MANIFEST_FILE"
-};
-
-// src/cli/options/decrypt.ts
-var decryptCommandDefaults = {
-  decrypt: {
-    options: {
-      configFile: configFileOption,
-      envFile: envFileOption,
-      secFile: secFileOption,
-      createManifest: createManifestOption,
-      manifestFilePrefix: manifestFilePrefixOption,
-      yes: yesOption
-    },
-    description: "Decrypt a sec file",
-    helpText: `Examples:
-
-
-Decrypt .sec file to .env file
-
-$ npx dotsec decrypt
-
-
-Specify a different .sec file
-
-$ npx dotsec decrypt --sec-file .sec.dev
-$ SEC_FILE=.sec.dev npx dotsec decrypt
-
-Specify a different .env file
-
-$ npx dotsec decrypt --env-file .env.dev
-$ ENV_FILE=.env.dev npx dotsec decrypt
-
-Write a manifest markdown file
-
-$ npx dotsec decrypt --create-manifest
-$ CREATE_MANIFEST=true npx dotsec decrypt
-
-Specify a different manifest file
-
-$ npx dotsec decrypt --manifest-file .manifest.dev
-$ MANIFEST_FILE=decryption-manifest.md npx dotsec decrypt
-`
-  }
-};
-var decrypt_default = decryptCommandDefaults;
-
-// src/cli/options/dotsec.ts
-var dotsecCommandDefaults = {
-  dotsec: {
-    options: {
-      configFile: configFileOption,
-      plugin: pluginOption
-    }
-  }
-};
-var dotsec_default = dotsecCommandDefaults;
-
-// src/cli/options/encrypt.ts
-var encryptCommandDefaults = {
-  encrypt: {
-    options: {
-      configFile: configFileOption,
-      envFile: envFileOption,
-      secFile: secFileOption,
-      createManifest: createManifestOption,
-      manifestFile: manifestFilePrefixOption,
-      yes: yesOption
-    },
-    description: "Encrypt an env file",
-    helpText: `Examples:
-
-
-Encrypt .env file to .sec file
-
-$ npx dotsec encrypt
-
-
-Specify a different .env file
-
-$ npx dotsec encrypt --env-file .env.dev
-$ ENV_FILE=.env.dev npx dotsec encrypt
-
-
-Specify a different .sec file
-
-$ npx dotsec encrypt --sec-file .sec.dev
-$ SEC_FILE=.sec.dev npx dotsec encrypt
-
-
-Write a manifest markdown file
-
-$ npx dotsec encrypt --create-manifest
-$ CREATE_MANIFEST=true npx dotsec encrypt
-
-
-Specify a different manifest file
-
-$ npx dotsec encrypt --manifest-file manifest.dev
-$ MANIFEST_FILE=encryption-manifest.md npx dotsec encrypt
-`
-  }
-};
-var encrypt_default = encryptCommandDefaults;
-
-// src/cli/options/init.ts
-var initCommandDefaults = {
-  init: {
-    options: {
-      configFile: configFileOption,
-      yes: yesOption
-    },
-    description: "Initialize a dotsec project by creating a dotsec.config.ts file.",
-    helpText: `Examples:
-
-Create a dotsec.config.ts file in the current directory
-
-$ npx dotsec init
-
-
-Overwrite an existing dotsec.config.ts file in the current directory
-
-$ npx dotsec init --yes
-
-
-Create a dotsec config file in the current directory with a specific config file name
-
-By specifying the --config-file option, you can create a dotsec config file with a specific name.
-
-$ npx dotsec init --config-file dotsec.config.ts
-
-$ DOTSEC_CONFIG_FILE=my.config.ts npx dotsec init
-`
-  }
-};
-var init_default = initCommandDefaults;
-
-// src/cli/options/push.ts
-var pushCommandDefaults = {
-  push: {
-    options: {
-      configFile: configFileOption,
-      envFile: envFileOption,
-      secFile: secFileOption,
-      yes: yesOption
-    },
-    requiredOptions: {
-      using: usingOption
-    },
-    description: "Push variables from env or sec file to a remote",
-    helpText: `Examples:
-
-Push variables from .env file to remote
-
-$ npx dotsec push --using env
-$ DOTSEC_USING=env npx dotsec push
-
-
-Push variables from .sec file to remote
-
-$ npx dotsec push --using sec
-$ DOTSEC_USING=sec npx dotsec push
-`
-  }
-};
-var push_default = pushCommandDefaults;
-
-// src/cli/options/run.ts
-var runCommandDefaults = {
-  runEnvOnly: {
-    usage: "--using env [commandArgs...]",
-    options: {
-      configFile: configFileOption,
-      envFile: envFileOption,
-      yes: yesOption,
-      engine: engineOption,
-      outputBackgroundColor: outputBackgroundColorOption,
-      showOutputPrefix: showOutputPrefixOption,
-      outputPrefix: outputPrefixOption
-    },
-    requiredOptions: {
-      using: usingNoEncryptionEngineOption
-    },
-    description: "Run a command in a separate process and populate env with contents of a dotenv file.",
-    helpText: `Examples:
-		
-Run a command with a .env file
-		
-$ npx dotsec run --using env node -e "console.log(process.env)"
-
-
-Run a command with a specific .env file
-
-$ npx dotsec run --using env --env-file .env node -e "console.log(process.env)"
-
-
-Run a command with a specific ENV_FILE variable
-
-$ ENV_FILE=.env.dev npx dotsec run --using env node -e "console.log(process.env)"
-
-
-You can also specify 'using' as an environment variable
-
-$ DOTSEC_USING=env npx dotsec run node -e "console.log(process.env)"
-		`
-  },
-  run: {
-    options: {
-      configFile: configFileOption,
-      envFile: envFileOption,
-      secFile: secFileOption,
-      yes: yesOption,
-      outputBackgroundColor: outputBackgroundColorOption,
-      hideOutputPrefix: showOutputPrefixOption,
-      outputPrefix: outputPrefixOption
-    },
-    requiredOptions: {
-      using: usingOption
-    },
-    usage: "[--using env] [--using sec] [commandArgs...]",
-    description: `Run a command in a separate process and populate env with either 
-			- contents of a dotenv file
-			- decrypted values of a dotsec file.
-
-The --withEnv option will take precedence over the --withSec option. If neither are specified, the --withEnv option will be used by default.`,
-    helpText: `${"Examples:"}
-
-${"Run a command with a .env file"}
-
-$ dotsec run echo "hello world"
-
-
-${"Run a command with a specific .env file"}
-
-$ dotsec run --with-env --env-file .env.dev echo "hello world"
-
-
-${"Run a command with a .sec file"}
-
-$ dotsec run --with-sec echo "hello world"
-
-
-${"Run a command with a specific .sec file"}
-
-$ dotsec run --with-sec --sec-file .sec.dev echo "hello world"
-`
-  }
-  // push: {
-  // 	options: {
-  // 		...dotsecCommandDefaults.dotsec.options,
-  // 		withEnv: withEnvOption,
-  // 		withSec: withSecOption,
-  // 		envFile: envFileOption,
-  // 		secFile: secFileOption,
-  // 		yes: yesOption,
-  // 	},
-  // 	requiredOptions: {
-  // 		...dotsecCommandDefaults.dotsec.requiredOptions,
-  // 	},
-  // },
-};
-var run_default = runCommandDefaults;
-
-// src/cli/options/index.ts
-var commandOptions = {
-  ...dotsec_default,
-  ...init_default,
-  ...encrypt_default,
-  ...decrypt_default,
-  ...run_default,
-  ...push_default
-};
-var expandCommandOption = (commandOption) => {
-  if (Array.isArray(commandOption)) {
-    const [flags, description, defaultValue] = commandOption;
-    const optionProps = {
-      flags,
-      description,
-      defaultValue
-    };
-    return optionProps;
-  } else {
-    if ("option" in commandOption) {
-      const [flags, description, defaultValue] = commandOption.option;
-      const optionProps = {
-        flags,
-        description,
-        defaultValue,
-        env: commandOption.env
-      };
-      return optionProps;
-    }
-    return commandOption;
-  }
-};
-var createOption = (commandOption, options) => {
-  const defaultOptionValueFromConfig = options?.dotsecConfig?.defaults?.options?.[options?.optionKey];
-  const optionProps = expandCommandOption(commandOption);
-  const newOption = new Option(optionProps.flags, optionProps.description);
-  if (optionProps.fn) {
-    newOption.argParser(optionProps.fn);
-  }
-  if (optionProps.defaultValue) {
-    newOption.default(defaultOptionValueFromConfig || optionProps.defaultValue);
-  }
-  if (optionProps.env) {
-    newOption.env(optionProps.env);
-  }
-  if (options.required) {
-    newOption.makeOptionMandatory(true);
-  }
-  if (optionProps.choices) {
-    newOption.choices(optionProps.choices);
-  }
-  return newOption;
-};
-var setProgramOptions = (params) => {
-  const { program: program2, commandName, dotsecConfig } = params;
-  const programOptions = commandOptions[commandName || program2.name()];
-  if (programOptions) {
-    const { options, requiredOptions, description, usage, helpText } = programOptions;
-    if (options) {
-      Object.keys(options).forEach((optionKey) => {
-        const commandOption = options[optionKey];
-        const newOption = createOption(commandOption, {
-          dotsecConfig,
-          optionKey
-        });
-        program2.addOption(newOption);
-      });
-    }
-    if (requiredOptions) {
-      Object.keys(requiredOptions).forEach((requiredOptionKey) => {
-        const requiredOption = requiredOptions[requiredOptionKey];
-        const newOption = createOption(requiredOption, {
-          required: true,
-          dotsecConfig,
-          optionKey: requiredOptionKey
-        });
-        program2.addOption(newOption);
-      });
-    }
-    if (description) {
-      program2.description(description);
-    }
-    if (usage) {
-      program2.usage(usage);
-    }
-    if (helpText) {
-      program2.description(helpText);
-    }
-  }
-};
-
-// src/cli/commands/decrypt.ts
-var addEncryptProgram = async (program2, options) => {
-  const { dotsecConfig, decryptHandlers } = options;
-  const subProgram = program2.enablePositionalOptions().passThroughOptions().command("decrypt").action(async (_options, command) => {
-    try {
-      const {
-        // verbose,
-        envFile,
-        secFile,
-        engine,
-        createManifest,
-        manifestFile,
-        yes
-      } = command.optsWithGlobals();
-      const encryptionEngine = engine || dotsecConfig?.defaults?.encryptionEngine;
-      const pluginCliDecrypt = (decryptHandlers || []).find((handler) => {
-        return handler.triggerOptionValue === encryptionEngine;
-      });
-      if (!pluginCliDecrypt) {
-        throw new Error(
-          `No decryption plugin found, available decryption engine(s): ${options.decryptHandlers.map((e) => `--${e.triggerOptionValue}`).join(", ")}`
-        );
-      }
-      console.log(
-        "Decrypting with",
-        strong(
-          pluginCliDecrypt.encryptionEngineName || pluginCliDecrypt.triggerOptionValue
-        ),
-        "engine"
-      );
-      const allOptionKeys = [
-        ...Object.keys(pluginCliDecrypt.options || {}),
-        ...Object.keys(pluginCliDecrypt.requiredOptions || {})
-      ];
-      const allOptionsValues = Object.fromEntries(
-        allOptionKeys.map((key) => {
-          return [key, _options[key]];
-        })
-      );
-      const dotsecString = await readContentsFromFile(secFile);
-      const plaintext = await pluginCliDecrypt.handler({
-        ciphertext: dotsecString,
-        ...allOptionsValues
-      });
-      const dotenvOverwriteResponse = await promptOverwriteIfFileExists({
-        filePath: envFile,
-        skip: yes
-      });
-      if (dotenvOverwriteResponse === void 0 || dotenvOverwriteResponse.overwrite === true) {
-        await writeContentsToFile(envFile, plaintext);
-        console.log(
-          `Wrote plaintext contents of ${strong(secFile)} file to ${strong(
-            envFile
-          )}`
-        );
-      }
-      if (createManifest || dotsecConfig?.defaults?.options?.createManifest) {
-        const dotenvVars = parse(plaintext).obj;
-        const markdownManifest = `# Dotsec decryption manifest
-
-## Overview
-
-- plaintext source: ${envFile}
-- ciphertext target: ${secFile}
-- created: ${( new Date()).toUTCString()}
-- Decryption engine: ${pluginCliDecrypt.encryptionEngineName || pluginCliDecrypt.triggerOptionValue}
-- Decryption engine options: ${JSON.stringify(allOptionsValues)}
-
-## Variables
-
-| Key |
-| --- |
-${Object.keys(dotenvVars).map((key) => {
-          return `| \`${key} \`| `;
-        }).join("\n")}
-`;
-        const manifestTargetFile = manifestFile || `${envFile}.decryption-manifest.md`;
-        await writeContentsToFile(manifestTargetFile, markdownManifest);
-        console.log(
-          `Wrote manifest of ${strong(envFile)} file to ${strong(
-            manifestTargetFile
-          )}`
-        );
-      }
-    } catch (e) {
-      console.error(strong(e.message));
-      command.help();
-    }
-  });
-  options.decryptHandlers.map((decryption) => {
-    const { options: options2, requiredOptions } = decryption;
-    addPluginOptions(options2, subProgram);
-    addPluginOptions(requiredOptions, subProgram, true);
-  });
-  const engines = options.decryptHandlers.map((e) => e.triggerOptionValue);
-  subProgram.option(
-    "--engine <engine>",
-    `Encryption engine${engines.length > 0 ? "s" : ""} to use: ${engines.length === 1 ? engines[0] : engines.join(", ")}`,
-    engines.length === 1 ? engines[0] : void 0
-  );
-  setProgramOptions({ program: subProgram, dotsecConfig });
-  return subProgram;
-};
-var decrypt_default2 = addEncryptProgram;
-
-// src/cli/commands/encrypt.ts
-var addEncryptProgram2 = async (program2, options) => {
-  const { encryptHandlers, dotsecConfig } = options;
-  const subProgram = program2.enablePositionalOptions().passThroughOptions().command("encrypt").action(async (_options, command) => {
-    try {
-      const {
-        // verbose,
-        envFile,
-        secFile,
-        engine,
-        createManifest,
-        manifestFile,
-        yes
-      } = command.optsWithGlobals();
-      const encryptionEngine = engine || dotsecConfig?.defaults?.encryptionEngine;
-      const pluginCliEncrypt = (encryptHandlers || []).find((handler) => {
-        return handler.triggerOptionValue === encryptionEngine;
-      });
-      if (!pluginCliEncrypt) {
-        throw new Error(
-          `No encryption plugin found, available encryption engine(s): ${options.encryptHandlers.map((e) => e.triggerOptionValue).join(", ")}`
-        );
-      }
-      const allOptionKeys = [
-        ...Object.keys(pluginCliEncrypt.options || {}),
-        ...Object.keys(pluginCliEncrypt.requiredOptions || {})
-      ];
-      const allOptionsValues = Object.fromEntries(
-        allOptionKeys.map((key) => {
-          return [key, _options[key]];
-        })
-      );
-      const dotenvString = await readContentsFromFile(envFile);
-      let dotsecString;
-      try {
-        dotsecString = await readContentsFromFile(secFile);
-      } catch (e) {
-      }
-      const cipherText = await pluginCliEncrypt.handler({
-        plaintext: dotenvString,
-        ciphertext: dotsecString,
-        ...allOptionsValues
-      });
-      const dotsecOverwriteResponse = await promptOverwriteIfFileExists({
-        filePath: secFile,
-        skip: yes
-      });
-      if (dotsecOverwriteResponse === void 0 || dotsecOverwriteResponse.overwrite === true) {
-        await writeContentsToFile(secFile, cipherText);
-        console.log(
-          `Wrote encrypted contents of ${strong(envFile)} file to ${strong(
-            secFile
-          )}`
-        );
-        if (createManifest || dotsecConfig?.defaults?.options?.createManifest) {
-          const dotenvVars = parse(dotenvString).obj;
-          const markdownManifest = `# Dotsec encryption manifest 
-
-## Overview
-
-- plaintext source: ${envFile}
-- ciphertext target: ${secFile}
-- created: ${( new Date()).toUTCString()}
-- encryption engine: ${pluginCliEncrypt.encryptionEngineName || pluginCliEncrypt.triggerOptionValue}
-- encryption engine options: ${JSON.stringify(allOptionsValues)}
-
-## Variables
-
-| Key | 
-| --- | 
-${Object.keys(dotenvVars).map((key) => {
-            return `| \`${key} \`| `;
-          }).join("\n")}
-`;
-          const manifestTargetFile = manifestFile || `${secFile}.encryption-manifest.md`;
-          await writeContentsToFile(manifestTargetFile, markdownManifest);
-          console.log(
-            `Wrote manifest of ${strong(envFile)} file to ${strong(
-              manifestTargetFile
-            )}`
-          );
-        }
-      }
-    } catch (e) {
-      console.error(strong(e.message));
-      command.help();
-    }
-  });
-  options.encryptHandlers.map((encryptionHandler) => {
-    const { options: options2, requiredOptions } = encryptionHandler;
-    addPluginOptions(options2, subProgram);
-    addPluginOptions(requiredOptions, subProgram, true);
-  });
-  const engines = options.encryptHandlers.map((e) => e.triggerOptionValue);
-  const encryptionEngineNames = options.encryptHandlers.map(
-    (e) => e.encryptionEngineName
-  );
-  subProgram.option(
-    "--engine <engine>",
-    `Encryption engine${engines.length > 0 ? "s" : ""}: ${engines.length === 1 ? engines[0] : engines.join(", ")}`,
-    engines.length === 1 ? engines[0] : void 0
-  );
-  setProgramOptions({ program: subProgram, dotsecConfig });
-  subProgram.description(
-    `Encrypt .env file using ${encryptionEngineNames.join(", ")}`
-  );
-  return subProgram;
-};
-var encrypt_default2 = addEncryptProgram2;
-var addInitProgram = async (program2, options) => {
-  const { dotsecConfig } = options;
-  const subProgram = program2.enablePositionalOptions().passThroughOptions().command("init").action(async (_options, command) => {
-    const { configFile = "dotsec.config.ts", yes } = command.optsWithGlobals();
-    try {
-      const configTemplate = await readContentsFromFile(
-        path.resolve(__dirname, "../../src/templates/dotsec.config.ts")
-      );
-      const dotsecConfigOverwriteResponse = await promptOverwriteIfFileExists(
-        {
-          filePath: configFile,
-          skip: yes
-        }
-      );
-      if (dotsecConfigOverwriteResponse === void 0 || dotsecConfigOverwriteResponse.overwrite === true) {
-        await writeContentsToFile(configFile, configTemplate);
-        console.log(`Wrote config file to ${strong(configFile)}`);
-      }
-    } catch (e) {
-      command.error(e);
-    }
-  });
-  setProgramOptions({ program: subProgram, dotsecConfig });
-  return subProgram;
-};
-var init_default2 = addInitProgram;
-var addPushProgram = async (program2, options) => {
-  const { dotsecConfig, handlers } = options;
-  const subProgram = program2.enablePositionalOptions().passThroughOptions().command("push").action(async (_options, command) => {
-    try {
-      const {
-        // verbose,
-        using,
-        envFile,
-        secFile,
-        engine,
-        yes
-      } = command.optsWithGlobals();
-      const encryptionEngine = engine || dotsecConfig?.defaults?.encryptionEngine;
-      const pluginCliDecrypt = (handlers || []).find((handler) => {
-        return handler.decrypt?.triggerOptionValue === encryptionEngine;
-      })?.decrypt;
-      const pluginCliPush = (handlers || []).find((handler) => {
-        return handler.push?.triggerOptionValue === encryptionEngine;
-      })?.push;
-      if (!pluginCliPush) {
-        throw new Error("No push plugin found!");
-      }
-      const allOptionKeys = [
-        ...Object.keys(pluginCliDecrypt?.options || {}),
-        ...Object.keys(pluginCliDecrypt?.requiredOptions || {}),
-        ...Object.keys(pluginCliPush?.options || {}),
-        ...Object.keys(pluginCliPush?.requiredOptions || {})
-      ];
-      const allOptionsValues = Object.fromEntries(
-        allOptionKeys.map((key) => {
-          return [key, _options[key]];
-        })
-      );
-      let envContents;
-      if (using === "env") {
-        if (!envFile) {
-          throw new Error("No dotenv file specified in --env-file option");
-        }
-        envContents = fs3.readFileSync(envFile, "utf8");
-      } else {
-        if (!secFile) {
-          throw new Error("No dotsec file specified in --sec-file option");
-        }
-        if (!pluginCliDecrypt) {
-          throw new Error(
-            `No decryption plugin found, available decryption engine(s): ${handlers.map((e) => `--${e.decrypt?.triggerOptionValue}`).join(", ")}`
-          );
-        }
-        const dotSecContents = fs3.readFileSync(secFile, "utf8");
-        envContents = await pluginCliDecrypt.handler({
-          ciphertext: dotSecContents,
-          ...allOptionsValues
-        });
-      }
-      if (envContents) {
-        const dotenvVars = parse(envContents).obj;
-        const expandedEnvVars = expand({
-          ignoreProcessEnv: true,
-          parsed: {
-            // add standard env variables
-            ...process.env,
-            // add custom env variables, either from .env or .sec, (or empty object if none)
-            ...dotenvVars
-          }
-        });
-        if (expandedEnvVars.parsed) {
-          await pluginCliPush.handler({
-            push: expandedEnvVars.parsed,
-            yes,
-            ...allOptionsValues
-          });
-        }
-      } else {
-        throw new Error("No .env or .sec file provided");
-      }
-    } catch (e) {
-      console.error(e);
-      process.exit(1);
-    }
-  });
-  setProgramOptions({ program: subProgram, dotsecConfig });
-  const engines = options.handlers.map(
-    ({ decrypt }) => decrypt.triggerOptionValue
-  );
-  subProgram.option(
-    "--engine <engine>",
-    `Encryption engine${engines.length > 0 ? "s" : ""} to use: ${engines.length === 1 ? engines[0] : engines.join(", ")}`,
-    engines.length === 1 ? engines[0] : void 0
-  );
-  const allOptions = {};
-  options.handlers.forEach((handlers2) => {
-    Object.keys(handlers2).map((handlerName) => {
-      const { options: cliOptions, requiredOptions } = handlers2[handlerName];
-      Object.keys(cliOptions || {}).forEach((key) => {
-        allOptions[key] = Array.isArray(cliOptions[key]) ? cliOptions[key] : { ...allOptions[key], ...cliOptions[key] };
-      });
-      Object.keys(requiredOptions || {}).forEach((key) => {
-        allOptions[key] = Array.isArray(requiredOptions[key]) ? requiredOptions[key] : {
-          ...allOptions[key],
-          ...requiredOptions[key],
-          required: true
-        };
-      });
-    });
-  });
-  const usage = [];
-  const descriptions = [];
-  handlers.forEach((handler) => {
-    if (handler.push?.description) {
-      descriptions.push(handler.push.description);
-    }
-    if (handler.push?.usage) {
-      usage.push(handler.push.usage);
-    }
-  });
-  if (descriptions.length > 0) {
-    subProgram.description(descriptions.join("\n"));
-  }
-  if (usage.length > 0) {
-    subProgram.usage(usage.join("\n"));
-  }
-  addPluginOptions(
-    Object.fromEntries(
-      Object.entries(allOptions).filter(
-        ([_key, value]) => value.required !== true
-      )
-    ),
-    subProgram
-  );
-  addPluginOptions(
-    Object.fromEntries(
-      Object.entries(allOptions).filter(
-        ([_key, value]) => value.required === true
-      )
-    ),
-    subProgram,
-    true
-  );
-  return subProgram;
-};
-var push_default2 = addPushProgram;
-var addRunProgam = (program2, options) => {
-  const { dotsecConfig, decryptHandlers } = options || {};
-  const hasDecryptEngine = decryptHandlers !== void 0 && decryptHandlers.length > 0;
-  const subProgram = program2.command("run <command...>").allowUnknownOption(true).enablePositionalOptions().passThroughOptions().showHelpAfterError(true).action(
-    async (commands, _options, command) => {
-      try {
-        const {
-          envFile,
-          using,
-          secFile,
-          engine,
-          outputBackgroundColor,
-          showOutputPrefix,
-          outputPrefix
-        } = command.optsWithGlobals();
-        let envContents;
-        if (using === "env" || hasDecryptEngine === false) {
-          if (!envFile) {
-            throw new Error("No dotenv file specified in --env-file option");
-          }
-          envContents = fs3.readFileSync(envFile, "utf8");
-        } else if (using === "sec") {
-          if (!secFile) {
-            throw new Error("No dotsec file specified in --sec-file option");
-          }
-          const encryptionEngine = engine || dotsecConfig?.defaults?.encryptionEngine;
-          const pluginCliDecrypt = (decryptHandlers || []).find((handler) => {
-            return handler.triggerOptionValue === encryptionEngine;
-          });
-          if (!pluginCliDecrypt) {
-            throw new Error(
-              `No decryption plugin found, available decryption engine(s): ${(decryptHandlers || []).map((e) => `--${e.triggerOptionValue}`).join(", ")}`
-            );
-          }
-          const allOptionKeys = [
-            ...Object.keys(pluginCliDecrypt.options || {}),
-            ...Object.keys(pluginCliDecrypt.requiredOptions || {})
-          ];
-          const allOptionsValues = Object.fromEntries(
-            allOptionKeys.map((key) => {
-              return [key, _options[key]];
-            })
-          );
-          try {
-            const dotSecContents = fs3.readFileSync(secFile, "utf8");
-            envContents = await pluginCliDecrypt.handler({
-              ciphertext: dotSecContents,
-              ...allOptionsValues
-            });
-          } catch (e) {
-            console.error("Something bad happened while decrypting.");
-            console.error(`File: ${secFile}`);
-            throw e;
-          }
-        }
-        if (envContents) {
-          const dotenvVars = parse(envContents).obj;
-          const expandedEnvVars = expand({
-            ignoreProcessEnv: true,
-            parsed: {
-              // add standard env variables
-              ...process.env,
-              // add custom env variables, either from .env or .sec, (or empty object if none)
-              ...dotenvVars
-            }
-          });
-          const [userCommand, ...userCommandArgs] = commands;
-          const waiter = await new Promise((resolve) => {
-            const cprocess = spawn(userCommand, [...userCommandArgs], {
-              stdio: "pipe",
-              shell: false,
-              env: {
-                ...expandedEnvVars.parsed,
-                ...process.env,
-                __DOTSEC_ENV__: JSON.stringify(Object.keys(dotenvVars))
-              }
-            });
-            const expandedEnvVarsWithoutEnv = expand({
-              ignoreProcessEnv: true,
-              parsed: {
-                // add standard env variables
-                // add custom env variables, either from .env or .sec, (or empty object if none)
-                ...dotenvVars
-              }
-            });
-            cprocess.stdout.setEncoding("utf8");
-            let backgroundColor = outputBackgroundColor || dotsecConfig.defaults?.options?.outputBackgroundColor;
-            if (typeof backgroundColor === "boolean" && backgroundColor === true) {
-              backgroundColor = "red-bright";
-            }
-            let addBackgroundColor = (str) => str;
-            if (backgroundColor) {
-              if (!backgroundColors.includes(backgroundColor)) {
-                throw new Error(
-                  `Invalid background color: ${backgroundColor}`
-                );
-              }
-              const backgroundColorFnName = camelCase(
-                `bg-${backgroundColor}`
-              );
-              if (chalk2[backgroundColorFnName]) {
-                addBackgroundColor = chalk2[backgroundColorFnName];
-              } else {
-                console.warn(
-                  `Invalid background color: ${backgroundColorFnName}, using default: red`
-                );
-                addBackgroundColor = chalk2.bgRedBright;
-              }
-            }
-            const prefix = showOutputPrefix || dotsecConfig?.defaults?.options?.showOutputPrefix ? `${dotsecConfig?.defaults?.options?.outputPrefix || outputPrefix || "(dotsec) "}` : "";
-            let lineBuffer = "";
-            cprocess.stdout.on("data", function(data) {
-              lineBuffer += data.toString();
-              const lines = lineBuffer.split("\n");
-              for (let i = 0; i < lines.length - 1; i++) {
-                const line = lines[i];
-                const redactedLines = Object.entries(
-                  expandedEnvVarsWithoutEnv.parsed || {}
-                ).sort(([, a], [, b]) => {
-                  if (a.length > b.length) {
-                    return -1;
-                  } else if (a.length < b.length) {
-                    return 1;
-                  } else {
-                    return 0;
-                  }
-                }).reduce((acc, [key, value]) => {
-                  if (dotsecConfig?.redaction?.show?.includes(key)) {
-                    return acc;
-                  } else {
-                    const redactedValue = value.replace(/./g, "*");
-                    return acc.replace(value, redactedValue);
-                  }
-                }, line);
-                console.log(prefix + addBackgroundColor(redactedLines));
-              }
-              lineBuffer = lines[lines.length - 1];
-            });
-            cprocess.stdout.on("end", function() {
-              console.log(prefix + addBackgroundColor(lineBuffer));
-            });
-            cprocess.stderr.setEncoding("utf8");
-            cprocess.stderr.on("data", function(data) {
-              process.stderr.write(data.toString());
-            });
-            cprocess.on("exit", (code) => {
-              resolve(code);
-            });
-          });
-          if (waiter !== 0) {
-            process.exit(waiter || 1);
-          }
-        } else {
-          throw new Error("No .env or .sec file provided");
-        }
-      } catch (e) {
-        console.error(strong(e.message));
-        command.help();
-      }
-    }
-  );
-  setProgramOptions({
-    program: subProgram,
-    commandName: hasDecryptEngine ? "run" : "runEnvOnly",
-    dotsecConfig
-  });
-  if (hasDecryptEngine) {
-    decryptHandlers?.map((run) => {
-      const { options: options2, requiredOptions } = run;
-      addPluginOptions(options2, subProgram);
-      addPluginOptions(requiredOptions, subProgram, true);
-    });
-    const engines = decryptHandlers?.map((e) => e.triggerOptionValue);
-    subProgram.option(
-      "--engine <engine>",
-      `Encryption engine${engines.length > 0 ? "s" : ""}: ${engines.join(", "), engines.length === 1 ? engines[0] : void 0}`
-      // engines.length === 1 ? engines[0] : undefined,
-    );
-  }
-  return subProgram;
-};
-var run_default2 = addRunProgam;
-var separator = {
-  keyword: "separator",
-  type: "string",
-  metaSchema: {
-    type: "string",
-    description: "value separator"
-  },
-  modifying: true,
-  valid: true,
-  errors: false,
-  compile: (schema) => (data, ctx) => {
-    if (ctx) {
-      const { parentData, parentDataProperty } = ctx;
-      parentData[parentDataProperty] = data === "" ? [] : data.split(schema);
-      return true;
-    } else {
-      return false;
-    }
-  }
-};
-var program = new Command();
-(async () => {
-  const parsedOptions = yargsParser(process.argv);
-  const argvPluginModules = [];
-  if (parsedOptions.plugin) {
-    if (Array.isArray(parsedOptions.plugin)) {
-      argvPluginModules.push(...parsedOptions.plugin);
-    } else {
-      argvPluginModules.push(parsedOptions.plugin);
-    }
-  }
-  const someConfigFile = parsedOptions.configFile || parsedOptions.c;
-  const configFile = [
-    ...Array.isArray(someConfigFile) ? someConfigFile : [someConfigFile]
-  ]?.[0] || process.env.DOTSEC_CONFIG_FILE;
-  const { contents: dotsecConfig = {} } = await getMagicalConfig(configFile);
-  const { defaults = {}, push: pushVariables, plugins } = dotsecConfig;
-  program.name("dotsec").description(".env, but secure").version("1.0.0").passThroughOptions().action((_options, other) => {
-    other.help();
-  });
-  setProgramOptions({ program, dotsecConfig });
-  const ajv = new Ajv({
-    allErrors: true,
-    removeAdditional: true,
-    useDefaults: true,
-    coerceTypes: true,
-    allowUnionTypes: true,
-    addUsedSchema: false,
-    keywords: [separator]
-  });
-  const pluginModules = {};
-  if (plugins) {
-    for (const pluginName of plugins) {
-      if (!defaults?.plugins?.[pluginName]) {
-        defaults.plugins = {
-          ...defaults.plugins,
-          [pluginName]: {}
-        };
-      }
-    }
-  }
-  if (argvPluginModules.length > 0) {
-    for (const pluginModule of argvPluginModules) {
-      const plugin = await loadDotsecPlugin({ name: pluginModule });
-      const loadedPlugin = await plugin({
-        dotsecConfig,
-        ajv,
-        configFile
-      });
-      pluginModules[loadedPlugin.name] = pluginModule;
-      if (argvPluginModules.length === 1) {
-        dotsecConfig.defaults = {
-          ...dotsecConfig.defaults,
-          encryptionEngine: String(loadedPlugin.name),
-          plugins: {
-            ...dotsecConfig.defaults?.plugins,
-            [loadedPlugin.name]: {
-              ...dotsecConfig.defaults?.plugins?.[loadedPlugin.name]
-            }
-          }
-        };
-      }
-    }
-  }
-  if (defaults?.encryptionEngine) {
-    if (!defaults?.plugins?.[defaults.encryptionEngine]) {
-      defaults.plugins = {
-        ...defaults.plugins,
-        [defaults.encryptionEngine]: {}
-      };
-    }
-  }
-  if (defaults?.plugins) {
-    Object.entries(defaults?.plugins).forEach(
-      ([pluginName, pluginModule]) => {
-        if (pluginModule?.name) {
-          pluginModules[pluginName] = pluginModule?.name;
-        } else {
-          pluginModules[pluginName] = `@dotsec/plugin-${pluginName}`;
-        }
-      }
-    );
-  }
-  Object.values(pushVariables || {}).forEach((pushVariable) => {
-    Object.keys(pushVariable).forEach((pluginName) => {
-      if (!pluginModules[pluginName]) {
-        pluginModules[pluginName] = `@dotsec/plugin-${pluginName}`;
-      }
-    });
-  });
-  const cliPluginEncryptHandlers = [];
-  const cliPluginDecryptHandlers = [];
-  const cliPluginPushHandlers = [];
-  for (const pluginName of Object.keys(pluginModules)) {
-    const pluginModule = pluginModules[pluginName];
-    const initDotsecPlugin = await loadDotsecPlugin({ name: pluginModule });
-    const { addCliCommand, cliHandlers: cli } = await initDotsecPlugin({
-      ajv,
-      dotsecConfig,
-      configFile
-    });
-    if (cli?.encrypt) {
-      cliPluginEncryptHandlers.push(cli.encrypt);
-    }
-    if (cli?.decrypt) {
-      cliPluginDecryptHandlers.push(cli.decrypt);
-      if (cli?.push) {
-        cliPluginPushHandlers.push({ push: cli.push, decrypt: cli.decrypt });
-      }
-    }
-    if (addCliCommand) {
-      addCliCommand({ program });
-    }
-  }
-  if (cliPluginEncryptHandlers.length) {
-    await encrypt_default2(program, {
-      dotsecConfig,
-      encryptHandlers: cliPluginEncryptHandlers
-    });
-  }
-  if (cliPluginDecryptHandlers.length) {
-    await decrypt_default2(program, {
-      dotsecConfig,
-      decryptHandlers: cliPluginDecryptHandlers
-    });
-  }
-  if (cliPluginPushHandlers.length) {
-    await push_default2(program, {
-      dotsecConfig,
-      handlers: cliPluginPushHandlers
-    });
-  }
-  await init_default2(program, { dotsecConfig });
-  await run_default2(program, {
-    dotsecConfig,
-    decryptHandlers: cliPluginDecryptHandlers
-  });
-  await program.parse();
-})();
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.mjs.map