@karmaniverous/get-dotenv 6.2.3 → 6.3.0

package/dist/chunks/index-Bi0RIILn.mjs

@@ -0,0 +1,25 @@
+export { f as ENV_ACCOUNT_ID, e as ENV_CREDENTIAL_SCOPE, d as ENV_EXPIRATION, E as ENV_KEY, b as ENV_SECRET, c as ENV_SESSION, g as fromEnv } from './index-BNcKuiBy.mjs';
+import './readMergedOptions-DLBDzpXX.mjs';
+import 'zod';
+import '@commander-js/extra-typings';
+import './overlayEnv-Bqh_kPGA.mjs';
+import 'fs-extra';
+import 'node:path';
+import './loadModuleDefault-Dj8B3Stt.mjs';
+import 'crypto';
+import 'path';
+import 'url';
+import 'nanoid';
+import 'dotenv';
+import './loader-CePOf74i.mjs';
+import 'package-directory';
+import 'yaml';
+import 'execa';
+import 'buffer';
+import 'os';
+import 'node:fs/promises';
+import 'http';
+import 'https';
+import 'stream';
+import 'process';
+import 'node:fs';

package/dist/chunks/index-BqZ3PB6c.mjs

@@ -0,0 +1,375 @@
+import { l as redactTriple, m as maybeWarnEntropy, r as readMergedOptions, g as getDotenvCliOptions2Options, d as definePlugin } from './readMergedOptions-DLBDzpXX.mjs';
+import 'execa';
+import 'fs-extra';
+import 'node:path';
+import 'crypto';
+import 'path';
+import 'url';
+import '@commander-js/extra-typings';
+import 'nanoid';
+import 'dotenv';
+import './loader-CePOf74i.mjs';
+import 'package-directory';
+import 'yaml';
+import { z } from 'zod';
+import { b as resolveCommand, c as resolveShell, t as tokenize, s as shouldCapture, r as runCommand, d as buildSpawnEnv } from './spawnEnv-CQwFu7ZJ.mjs';
+import { m as maybePreserveNodeEvalArgv, c as composeNestedEnv, s as stripOne } from './invoke-DuRPU1oC.mjs';
+import { c as dotenvExpandFromProcessEnv } from './overlayEnv-Bqh_kPGA.mjs';
+import { r as resolveCliOptions, b as baseGetDotenvCliOptions } from './resolveCliOptions-_qtsVxda.mjs';
+
+/**
+ * Trace child env composition with redaction and entropy warnings.
+ * Presentation-only: does not mutate env; writes lines via the provided sink.
+ */
+function traceChildEnv(opts) {
+    const { parentEnv, dotenv, keys, redact, redactPatterns, warnEntropy, entropyThreshold, entropyMinLength, entropyWhitelist, write, } = opts;
+    const parentKeys = Object.keys(parentEnv);
+    const dotenvKeys = Object.keys(dotenv);
+    const allKeys = Array.from(new Set([...parentKeys, ...dotenvKeys])).sort();
+    const effectiveKeys = Array.isArray(keys) && keys.length > 0 ? keys : allKeys;
+    // Redaction options for display
+    const redOpts = {};
+    if (redact) {
+        redOpts.redact = true;
+        if (Array.isArray(redactPatterns))
+            redOpts.redactPatterns = redactPatterns;
+    }
+    // Entropy warning options
+    const entOpts = {};
+    if (typeof warnEntropy === 'boolean')
+        entOpts.warnEntropy = warnEntropy;
+    if (typeof entropyThreshold === 'number')
+        entOpts.entropyThreshold = entropyThreshold;
+    if (typeof entropyMinLength === 'number')
+        entOpts.entropyMinLength = entropyMinLength;
+    if (Array.isArray(entropyWhitelist))
+        entOpts.entropyWhitelist = entropyWhitelist;
+    for (const k of effectiveKeys) {
+        const parentVal = parentEnv[k];
+        const dot = dotenv[k];
+        const final = dot !== undefined ? dot : parentVal;
+        const origin = dot !== undefined
+            ? 'dotenv'
+            : parentVal !== undefined
+                ? 'parent'
+                : 'unset';
+        const tripleIn = {};
+        if (parentVal !== undefined)
+            tripleIn.parent = parentVal;
+        if (dot !== undefined)
+            tripleIn.dotenv = dot;
+        if (final !== undefined)
+            tripleIn.final = final;
+        const triple = redactTriple(k, tripleIn, redOpts);
+        write(`[trace] key=${k} origin=${origin} parent=${triple.parent ?? ''} dotenv=${triple.dotenv ?? ''} final=${triple.final ?? ''}`);
+        maybeWarnEntropy(k, final, origin, entOpts, (line) => {
+            write(line);
+        });
+    }
+}
+
+/** src/plugins/cmd/actions/runner.ts
+ * Unified runner for cmd subcommand and parent alias.
+ * - Resolves command via scripts
+ * - Emits --trace diagnostics (centralized helper with redaction/entropy)
+ * - Preserves Node -e argv under shell-off
+ * - Normalizes child env and honors capture
+ */
+/**
+ * Execute a command using the current CLI context.
+ * Resolves command/shell via scripts, emits traces, and handles execution.
+ *
+ * @param cli - The CLI instance.
+ * @param merged - Merged CLI options.
+ * @param command - Command string or array of args.
+ * @param _opts - Execution options (e.g. origin label).
+ */
+async function runCmdWithContext(cli, merged, command, _opts) {
+    const { logger, debug, capture, scripts: scriptsCfg, shell: shellPref, trace, redact, redactPatterns, warnEntropy, entropyThreshold, entropyMinLength, entropyWhitelist, } = merged;
+    const dotenv = cli.getCtx().dotenv;
+    // Build input string and note original argv (when available).
+    const parts = Array.isArray(command) ? command.map(String) : [];
+    const inputStr = Array.isArray(command) ? parts.join(' ') : command;
+    // Resolve command and shell from scripts/global.
+    const resolved = resolveCommand(scriptsCfg, inputStr);
+    if (debug)
+        logger.debug('\n*** command ***\n', `'${resolved}'`);
+    const shellSetting = resolveShell(scriptsCfg, inputStr, shellPref);
+    // Diagnostics: --trace [keys...]
+    const traceOpt = trace;
+    if (traceOpt) {
+        traceChildEnv({
+            parentEnv: process.env,
+            dotenv,
+            ...(Array.isArray(traceOpt) ? { keys: traceOpt } : {}),
+            ...(redact ? { redact: true } : {}),
+            ...(redact && Array.isArray(redactPatterns) ? { redactPatterns } : {}),
+            ...(typeof warnEntropy === 'boolean' ? { warnEntropy } : {}),
+            ...(typeof entropyThreshold === 'number' ? { entropyThreshold } : {}),
+            ...(typeof entropyMinLength === 'number' ? { entropyMinLength } : {}),
+            ...(Array.isArray(entropyWhitelist) ? { entropyWhitelist } : {}),
+            write: (line) => {
+                try {
+                    process.stderr.write(line + '\n');
+                }
+                catch {
+                    /* ignore */
+                }
+            },
+        });
+    }
+    // Preserve Node -e argv under shell-off when the script did not remap input.
+    let commandArg = resolved;
+    if (shellSetting === false && resolved === inputStr) {
+        if (Array.isArray(command)) {
+            commandArg = maybePreserveNodeEvalArgv(parts);
+        }
+        else {
+            const toks = tokenize(inputStr, { preserveDoubledQuotes: true });
+            if (toks.length >= 3 &&
+                (toks[0] ?? '').toLowerCase() === 'node' &&
+                (toks[1] === '-e' || toks[1] === '--eval')) {
+                toks[2] = stripOne(toks[2] ?? '');
+                commandArg = toks;
+            }
+        }
+    }
+    // Child env: compose nested bag and sanitize.
+    const childOverlay = composeNestedEnv(merged, dotenv);
+    const captureFlag = shouldCapture(capture);
+    let exit;
+    try {
+        exit = await runCommand(commandArg, shellSetting, {
+            env: buildSpawnEnv(process.env, childOverlay),
+            stdio: captureFlag ? 'pipe' : 'inherit',
+        });
+    }
+    catch (e) {
+        // Under unit tests, execa may be mocked to return undefined which causes
+        // pickResult access to throw. Treat as success to allow call-count assertions.
+        if (process.env.VITEST_WORKER_ID)
+            return 0;
+        throw e;
+    }
+    return typeof exit === 'number' ? exit : 0;
+}
+
+/**
+ * Attach the default "cmd" subcommand action.
+ * Mirrors the prior inline implementation in cmd/index.ts.
+ */
+const attachCmdDefaultAction = (cli, cmd, aliasKey) => {
+    cmd.action(async function (...allArgs) {
+        // Commander passes: [...positionals, options, thisCommand]
+        const thisCommand = allArgs[allArgs.length - 1];
+        const commandParts = allArgs[0];
+        const args = Array.isArray(commandParts)
+            ? commandParts.map(String)
+            : [];
+        // No-op when invoked as the default command with no args.
+        if (args.length === 0)
+            return;
+        const merged = readMergedOptions(thisCommand);
+        const parent = thisCommand.parent;
+        if (!parent)
+            throw new Error('parent command not found');
+        // Conflict detection: if an alias option is present on parent, do not
+        // also accept positional cmd args.
+        if (aliasKey) {
+            const p = parent;
+            const pv = typeof p.optsWithGlobals === 'function'
+                ? p.optsWithGlobals()
+                : typeof p.opts === 'function'
+                    ? p.opts()
+                    : {};
+            const ov = pv[aliasKey];
+            if (ov !== undefined) {
+                merged.logger.error(`--${aliasKey} option conflicts with cmd subcommand.`);
+                process.exit(0);
+            }
+        }
+        await runCmdWithContext(cli, merged, args);
+    });
+};
+
+/**
+ * Attach options/arguments for the cmd plugin mount.
+ *
+ * Note: the plugin description is owned by `src/plugins/cmd/index.ts` and must
+ * not be set here.
+ *
+ * @param cli - The `cmd` command mount.
+ * @returns The same `cli` instance for chaining.
+ *
+ * @internal
+ */
+function attachCmdOptions(cli) {
+    return cli
+        .enablePositionalOptions()
+        .passThroughOptions()
+        .argument('[command...]');
+}
+
+/**
+ * Install the parent-level invoker (alias) for the cmd plugin.
+ * Unifies naming with batch attachParentInvoker; behavior unchanged.
+ */
+const attachCmdParentInvoker = (cli, options, plugin) => {
+    const dbg = (...args) => {
+        if (process.env.GETDOTENV_DEBUG) {
+            try {
+                const line = args
+                    .map((a) => (typeof a === 'string' ? a : JSON.stringify(a)))
+                    .join(' ');
+                process.stderr.write(`[getdotenv:alias] ${line}\n`);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    };
+    const aliasSpec = typeof options.optionAlias === 'string'
+        ? { flags: options.optionAlias, description: undefined}
+        : options.optionAlias;
+    if (!aliasSpec)
+        return;
+    const deriveKey = (flags) => {
+        // install alias option
+        if (process.env.GETDOTENV_DEBUG) {
+            console.error('[getdotenv:alias] install alias option', flags);
+        }
+        const long = flags.split(/[ ,|]+/).find((f) => f.startsWith('--')) ?? '--cmd';
+        const name = long.replace(/^--/, '');
+        return name.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+    };
+    const aliasKey = deriveKey(aliasSpec.flags);
+    // Expose the option on the parent (root) command.
+    const parentCmd = cli.parent ??
+        cli;
+    const desc = aliasSpec.description ??
+        'alias of cmd subcommand; provide command tokens (variadic)';
+    parentCmd.option(aliasSpec.flags, desc);
+    // Tag the just-added parent option for grouped help rendering at the root.
+    const optsArr = parentCmd.options;
+    if (optsArr.length > 0) {
+        const last = optsArr[optsArr.length - 1];
+        if (last)
+            parentCmd.setOptionGroup(last, 'plugin:cmd');
+    }
+    // Shared alias executor for either preAction or preSubcommand hooks.
+    // Ensure we only execute once even if both hooks fire in a single parse.
+    const aliasState = { handled: false };
+    const maybeRun = async (thisCommand) => {
+        dbg('maybeRun:start');
+        // Read plugin config expand default; fall back to undefined (handled in maybeRunAlias)
+        let expandDefault = undefined;
+        try {
+            const cfg = plugin.readConfig(cli);
+            if (typeof cfg.expand === 'boolean')
+                expandDefault = cfg.expand;
+        }
+        catch {
+            /* config may be unavailable before resolve; default handled downstream */
+        }
+        // Inspect parent options and rawArgs to detect alias-only invocation.
+        if (aliasState.handled)
+            return;
+        const cmd = thisCommand;
+        dbg('maybeRun:rawArgs', cmd.rawArgs ?? []);
+        const raw = typeof cmd.opts === 'function' ? cmd.opts() : {};
+        const val = raw[aliasKey];
+        const provided = typeof val === 'string'
+            ? val.length > 0
+            : Array.isArray(val)
+                ? val.length > 0
+                : false;
+        dbg('maybeRun:aliasKey', aliasKey, 'provided', provided, 'value', val);
+        if (!provided)
+            return;
+        const childNames = cmd.commands.flatMap((c) => [c.name(), ...c.aliases()]);
+        dbg('maybeRun:childNames', childNames);
+        const hasSub = (cmd.rawArgs ?? []).some((t) => childNames.includes(t));
+        dbg('maybeRun:hasSub', hasSub);
+        if (hasSub)
+            return; // do not run alias when an explicit subcommand is present
+        aliasState.handled = true;
+        // Merge CLI options and resolve dotenv context for this invocation.
+        const { merged } = resolveCliOptions(raw, baseGetDotenvCliOptions, process.env.getDotenvCliOptions);
+        const serviceOptions = getDotenvCliOptions2Options(merged);
+        await cli.resolveAndLoad(serviceOptions);
+        // Build input string and apply optional expansion (by config default).
+        const joined = typeof val === 'string'
+            ? val
+            : Array.isArray(val)
+                ? val.map(String).join(' ')
+                : '';
+        const effectiveExpand = expandDefault !== false;
+        const expanded = dotenvExpandFromProcessEnv(joined);
+        const input = effectiveExpand && expanded !== undefined ? expanded : joined;
+        // Hand off to shared runner and terminate (except under tests).
+        const exitCode = await runCmdWithContext(cli, merged, input);
+        const underTests = process.env.GETDOTENV_TEST === '1' ||
+            typeof process.env.VITEST_WORKER_ID === 'string';
+        if (!underTests) {
+            process.exit(typeof exitCode === 'number' ? exitCode : 0);
+        }
+    };
+    parentCmd.hook('preAction', async (thisCommand) => {
+        await maybeRun(thisCommand);
+    });
+    parentCmd.hook('preSubcommand', async (thisCommand) => {
+        await maybeRun(thisCommand);
+    });
+};
+
+/**
+ * Zod schema for cmd plugin configuration.
+ */
+const cmdPluginConfigSchema = z
+    .object({
+    /** When true, expand the alias value before execution (default behavior when omitted). */
+    expand: z.boolean().optional(),
+})
+    .strict();
+
+/**
+ * @packageDocumentation
+ * Cmd plugin subpath. Provides the `cmd` subcommand and an optional parent‑level
+ * alias to execute a command within the resolved dotenv context.
+ */
+/**
+ * Cmd plugin: executes a command using the current getdotenv CLI context.
+ * Registers the `cmd` subcommand and optionally attaches a parent-level alias (e.g. `-c`).
+ *
+ * @param options - Plugin configuration options.
+ */
+const cmdPlugin = (options = {}) => {
+    const plugin = definePlugin({
+        ns: 'cmd',
+        configSchema: cmdPluginConfigSchema,
+        setup(cli) {
+            const aliasSpec = typeof options.optionAlias === 'string'
+                ? { flags: options.optionAlias}
+                : options.optionAlias;
+            const deriveKey = (flags) => {
+                const long = flags.split(/[ ,|]+/).find((f) => f.startsWith('--')) ?? '--cmd';
+                const name = long.replace(/^--/, '');
+                return name.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+            };
+            const aliasKey = aliasSpec ? deriveKey(aliasSpec.flags) : undefined;
+            // Mount is the command ('cmd'); attach default action.
+            cli.description('Execute command according to the --shell option, conflicts with --command option (default subcommand)');
+            // Options/arguments (positional payload, argv routing) are attached separately.
+            attachCmdOptions(cli);
+            attachCmdDefaultAction(cli, cli, aliasKey);
+            // Parent-attached option alias (optional, unified naming).
+            if (aliasSpec !== undefined) {
+                attachCmdParentInvoker(cli, options, plugin);
+            }
+            return undefined;
+        },
+    });
+    return plugin;
+};
+
+export { cmdPlugin as c, traceChildEnv as t };