@karmaniverous/get-dotenv 6.2.2 → 6.2.4

package/dist/chunks/createCli-BY6_cfZr.mjs

@@ -0,0 +1,439 @@
+import 'zod';
+import 'path';
+import { r as resolveGetDotenvConfigSources } from './loader-DnhPeGfq.mjs';
+import 'fs-extra';
+import { j as defaultsDeep, c as getDotenvCliOptions2Options, e as baseRootOptionDefaults, G as GetDotenvCli, k as attachRootOptions } from './readMergedOptions-Nt0TR7dX.mjs';
+import 'crypto';
+import 'url';
+import 'nanoid';
+import 'dotenv';
+import 'execa';
+import { t as toHelpConfig } from './helpConfig-CGejgwWW.mjs';
+import { r as resolveCliOptions } from './resolveCliOptions-TFRzhB2c.mjs';
+import { v as validateEnvAgainstSources } from './validate-CDl0rE6k.mjs';
+import { awsPlugin } from '../plugins-aws.mjs';
+import { a as awsWhoamiPlugin } from './index-CeCufHlm.mjs';
+import { batchPlugin } from '../plugins-batch.mjs';
+import { c as cmdPlugin } from './index-Bc3h0a95.mjs';
+import { initPlugin } from '../plugins-init.mjs';
+
+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:rootHooks] ${line}\n`);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+};
+// Typed projection for concise debug logs without unsafe member access.
+const debugView = (o) => ({
+    env: o.env,
+    shell: o.shell,
+    log: o.log,
+    capture: o.capture,
+    strict: o.strict,
+});
+function computeRootDefaults(defaults, sources) {
+    const cfgDefaults = defaultsDeep({}, sources.packaged?.rootOptionDefaults ?? {}, sources.project?.public?.rootOptionDefaults ?? {}, sources.project?.local?.rootOptionDefaults ?? {});
+    return defaultsDeep(baseRootOptionDefaults, defaults ?? {}, cfgDefaults);
+}
+/**
+ * Install root-level hooks (preSubcommand/preAction) to handle configuration loading,
+ * option resolution, and context initialization before actions run.
+ *
+ * @param program - The CLI host instance.
+ * @param defaults - Optional root defaults overlay.
+ */
+function installRootHooks(program, defaults) {
+    // Hook: preSubcommand — always runs for subcommand flows.
+    program.hook('preSubcommand', async (thisCommand) => {
+        const sources = await resolveGetDotenvConfigSources(import.meta.url);
+        const rawArgs = thisCommand.rawArgs ?? [];
+        dbg('preSubcommand:rawArgs', rawArgs);
+        const raw = thisCommand.opts?.() ?? {};
+        // Build unified defaults stack for this run:
+        // baseRootOptionDefaults < createCli root defaults (argument) < config.rootOptionDefaults
+        const d = computeRootDefaults(defaults ?? {}, sources);
+        const { merged } = resolveCliOptions(raw, d, process.env.getDotenvCliOptions);
+        dbg('preSubcommand:merged', debugView(merged));
+        // Inject merged scripts from config sources (packaged < project/public < project/local).
+        merged.scripts = defaultsDeep({}, merged.scripts ?? {}, sources.packaged?.scripts ?? {}, sources.project?.public?.scripts ?? {}, sources.project?.local?.scripts ?? {});
+        // Persist merged bag for nested flows and ergonomic access.
+        thisCommand.getDotenvCliOptions = merged;
+        program._setOptionsBag(merged);
+        // Resolve context for this run via programmatic converter.
+        const serviceOptions = getDotenvCliOptions2Options(merged);
+        await program.resolveAndLoad(serviceOptions);
+        // Refresh dynamic help text using the resolved config slices.
+        try {
+            const ctx = program.getCtx();
+            const helpCfg = toHelpConfig(merged, ctx.pluginConfigs);
+            program.evaluateDynamicOptions(helpCfg);
+        }
+        catch {
+            /* best-effort */
+        }
+        // Global validation (once after overlays). Honor --strict.
+        try {
+            const ctx = program.getCtx();
+            const dotenv = ctx.dotenv;
+            const sources2 = await resolveGetDotenvConfigSources(import.meta.url);
+            const issues = validateEnvAgainstSources(dotenv, sources2);
+            if (Array.isArray(issues) && issues.length > 0) {
+                const logger = merged.logger;
+                issues.forEach((m) => {
+                    logger.error(m);
+                });
+                if (merged.strict)
+                    process.exit(1);
+            }
+        }
+        catch {
+            /* tolerate non-strict flows */
+        }
+    });
+    // Hook: preAction — root-only and parent-alias flows.
+    program.hook('preAction', async (thisCommand) => {
+        const sources = await resolveGetDotenvConfigSources(import.meta.url);
+        const rawArgs = thisCommand.rawArgs ?? [];
+        dbg('preAction:rawArgs', rawArgs);
+        const raw = thisCommand.opts?.() ?? {};
+        // Build unified defaults stack for this run:
+        // baseRootOptionDefaults < createCli root defaults (argument) < config.rootOptionDefaults
+        const d = computeRootDefaults(defaults ?? {}, sources);
+        const { merged } = resolveCliOptions(raw, d, process.env.getDotenvCliOptions);
+        dbg('preAction:merged', debugView(merged));
+        // Inject merged scripts from config sources (packaged < project/public < project/local).
+        merged.scripts = defaultsDeep({}, merged.scripts ?? {}, sources.packaged?.scripts ?? {}, sources.project?.public?.scripts ?? {}, sources.project?.local?.scripts ?? {});
+        thisCommand.getDotenvCliOptions = merged;
+        program._setOptionsBag(merged);
+        if (!program.hasCtx()) {
+            const serviceOptions = getDotenvCliOptions2Options(merged);
+            await program.resolveAndLoad(serviceOptions);
+            try {
+                const ctx = program.getCtx();
+                const helpCfg = toHelpConfig(merged, ctx.pluginConfigs);
+                program.evaluateDynamicOptions(helpCfg);
+            }
+            catch {
+                /* tolerate */
+            }
+            try {
+                const ctx = program.getCtx();
+                const dotenv = ctx.dotenv;
+                const sources2 = await resolveGetDotenvConfigSources(import.meta.url);
+                const issues = validateEnvAgainstSources(dotenv, sources2);
+                if (Array.isArray(issues) && issues.length > 0) {
+                    const logger = merged.logger;
+                    issues.forEach((m) => {
+                        logger.error(m);
+                    });
+                    if (merged.strict)
+                        process.exit(1);
+                }
+            }
+            catch {
+                /* tolerate non-strict flows */
+            }
+        }
+    });
+    return program;
+}
+
+/**
+ * Merge visibility maps left-to-right; later maps override earlier keys.
+ * @param layers - zero or more partial visibility maps (undefined ignored)
+ * @returns a new merged visibility map
+ */
+function mergeRootVisibility(...layers) {
+    const out = {};
+    for (const m of layers) {
+        if (!m)
+            continue;
+        for (const [k, v] of Object.entries(m)) {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+/**
+ * Hide a set of long flags (if present) on the provided root program.
+ * @param program - the GetDotenvCli root instance
+ * @param names - array of long option names (e.g., "--capture")
+ */
+function hideByLong(program, names) {
+    for (const opt of program.options) {
+        const long = opt.long ?? '';
+        if (names.includes(long))
+            opt.hideHelp(true);
+    }
+}
+/**
+ * Apply root option visibility to the provided program instance.
+ * Flags set to false in the visibility map are hidden via hideHelp(true).
+ *
+ * Help-time only:
+ * - This affects rendering of top-level help; it does not alter parsing or runtime semantics.
+ *
+ * Families vs singles:
+ * - Families (e.g., "shell") hide both ON and OFF flags.
+ * - Singles (e.g., "capture") hide the named long flag only.
+ *
+ * @param program - the GetDotenvCli root instance
+ * @param visibility - effective visibility map (false hides; true/undefined shows)
+ */
+function applyRootVisibility(program, visibility) {
+    if (!visibility)
+        return;
+    if (Object.keys(visibility).length === 0)
+        return;
+    const fam = (key, longs) => {
+        if (visibility[key] === false)
+            hideByLong(program, longs);
+    };
+    // Families: hide both members when false
+    fam('shell', ['--shell', '--shell-off']);
+    fam('loadProcess', ['--load-process', '--load-process-off']);
+    fam('log', ['--log', '--log-off']);
+    fam('excludeDynamic', ['--exclude-dynamic', '--exclude-dynamic-off']);
+    fam('excludeEnv', ['--exclude-env', '--exclude-env-off']);
+    fam('excludeGlobal', ['--exclude-global', '--exclude-global-off']);
+    fam('excludePrivate', ['--exclude-private', '--exclude-private-off']);
+    fam('excludePublic', ['--exclude-public', '--exclude-public-off']);
+    fam('warnEntropy', ['--entropy-warn', '--entropy-warn-off']);
+    // Redact pair (new)
+    fam('redact', ['--redact', '--redact-off']);
+    // Singles: hide individual long flags
+    const singles = [
+        ['capture', '--capture'],
+        ['strict', '--strict'],
+        ['trace', '--trace'],
+        ['defaultEnv', '--default-env'],
+        ['dotenvToken', '--dotenv-token'],
+        ['privateToken', '--private-token'],
+        ['dynamicPath', '--dynamic-path'],
+        ['paths', '--paths'],
+        ['pathsDelimiter', '--paths-delimiter'],
+        ['pathsDelimiterPattern', '--paths-delimiter-pattern'],
+        ['vars', '--vars'],
+        ['varsDelimiter', '--vars-delimiter'],
+        ['varsDelimiterPattern', '--vars-delimiter-pattern'],
+        ['varsAssignor', '--vars-assignor'],
+        ['varsAssignorPattern', '--vars-assignor-pattern'],
+        // diagnostics thresholds and whitelist/patterns
+        ['entropyThreshold', '--entropy-threshold'],
+        ['entropyMinLength', '--entropy-min-length'],
+        ['entropyWhitelist', '--entropy-whitelist'],
+        ['redactPatterns', '--redact-pattern'],
+    ];
+    for (const [key, long] of singles) {
+        if (visibility[key] === false)
+            hideByLong(program, [long]);
+    }
+}
+
+/**
+ * Create a configured get-dotenv CLI host.
+ * Applies defaults, installs root hooks, and composes plugins.
+ * Returns a runner function that accepts an argv array.
+ */
+function createCli(opts = {}) {
+    // Pre-compose aws parent/child to avoid nested call-site typing/lint issues
+    const alias = typeof opts.alias === 'string' && opts.alias.length > 0
+        ? opts.alias
+        : 'getdotenv';
+    const program = new GetDotenvCli(alias);
+    // Default output: normalize help prints so they always end with a blank line.
+    // This keeps E2E assertions (CRLF and >=2 trailing newlines) portable across
+    // runtimes and capture modes without altering Commander internals.
+    const outputCfg = {
+        writeOut(str) {
+            const txt = typeof str === 'string' ? str : '';
+            const hasTwo = /(?:\r?\n){2,}$/.test(txt);
+            const hasOne = /\r?\n$/.test(txt);
+            const out = hasTwo ? txt : hasOne ? txt + '\n' : txt + '\n\n';
+            try {
+                process.stdout.write(out);
+            }
+            catch {
+                /* ignore */
+            }
+        },
+        writeErr(str) {
+            process.stderr.write(str);
+        },
+    };
+    // Apply default output on root BEFORE composition so subcommands inherit.
+    program.configureOutput(outputCfg);
+    // Root defaults/visibility for this host (applied once, pre-compose).
+    const rootDefaults = opts.rootOptionDefaults ?? {};
+    const visibility = opts.rootOptionVisibility ?? {};
+    // Tests-only: avoid process.exit during help/version flows under Vitest.
+    const underTests = process.env.GETDOTENV_TEST === '1' ||
+        typeof process.env.VITEST_WORKER_ID === 'string';
+    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:run] ${line}\n`);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    };
+    // Pre-install tests-only exitOverride BEFORE composition so compose may override if desired.
+    if (underTests) {
+        program.exitOverride((err) => {
+            const code = err?.code;
+            // Commander printed help already; ensure a trailing blank line for tests/CI capture.
+            if (code === 'commander.helpDisplayed') {
+                try {
+                    process.stdout.write('\n');
+                }
+                catch {
+                    /* ignore */
+                }
+                return;
+            }
+            if (code === 'commander.version') {
+                return;
+            }
+            throw err;
+        });
+    }
+    // Root no-op action BEFORE composition so root-only flows trigger hooks;
+    // compose() may replace this with its own action.
+    program.action(() => {
+        /* no-op */
+    });
+    // Declare root flags and resolution hooks once, pre-compose.
+    // 1) Declare flags using the internal builder (no public helper).
+    attachRootOptions(program, rootDefaults);
+    // 2) Install resolution hooks (preSubcommand/preAction).
+    installRootHooks(program, rootDefaults);
+    // Apply visibility (hide selected options) after flags are declared.
+    if (Object.keys(visibility).length > 0) {
+        applyRootVisibility(program, visibility);
+    }
+    // Compose wiring: user-provided composer wins; otherwise apply shipped defaults.
+    if (typeof opts.compose === 'function') {
+        opts.compose(program);
+    }
+    else {
+        program
+            .use(cmdPlugin({ optionAlias: '-c, --cmd <command...>' }))
+            .use(batchPlugin())
+            .use(awsPlugin().use(awsWhoamiPlugin()))
+            .use(initPlugin());
+    }
+    // Runner function: accepts full argv or args-only; defaults to process.argv.
+    return async function run(argvInput) {
+        const argvAll = Array.isArray(argvInput) ? argvInput : process.argv;
+        // Derive args-only from a possible full process argv
+        const deriveArgsOnly = (v) => {
+            if (v.length >= 2) {
+                // Common Node/Electron convention: [node, script, ...args]
+                return v.slice(2);
+            }
+            return v.slice();
+        };
+        const argv = deriveArgsOnly(argvAll);
+        // Ensure plugin commands/options are installed before inspecting argv for
+        // help-time routing (subcommand vs root help).
+        dbg('argv', argv);
+        await program.install();
+        // Help handling:
+        // - Short-circuit ONLY for true top-level -h/--help (no subcommand before flag).
+        // - If a subcommand token appears before -h/--help, defer to Commander
+        //   to render that subcommand's help.
+        const helpIdx = argv.findIndex((a) => a === '-h' || a === '--help');
+        if (helpIdx >= 0) {
+            // Build a set of known subcommand names/aliases on the root.
+            const subs = new Set();
+            for (const c of program.commands) {
+                subs.add(c.name());
+                for (const a of c.aliases())
+                    subs.add(a);
+            }
+            dbg('helpIdx', helpIdx, 'knownSubs', Array.from(subs.values()));
+            const hasSubBeforeHelp = argv
+                .slice(0, helpIdx)
+                .some((tok) => subs.has(tok));
+            if (!hasSubBeforeHelp) {
+                await program.brand({
+                    name: alias,
+                    importMetaUrl: import.meta.url,
+                    description: 'Base CLI.',
+                    ...(typeof opts.branding === 'string' && opts.branding.length > 0
+                        ? { helpHeader: opts.branding }
+                        : {}),
+                });
+                dbg('top-level -h, render root help');
+                // Resolve context once without side effects for help rendering.
+                const ctx = await program.resolveAndLoad({
+                    loadProcess: false,
+                    log: false,
+                }, { runAfterResolve: false });
+                // Build a help-time defaults bag using the unified stack:
+                // baseRootOptionDefaults < createCli rootOptionDefaults < config.rootOptionDefaults
+                let cfgDefaults = {};
+                try {
+                    const sources = await resolveGetDotenvConfigSources(import.meta.url);
+                    cfgDefaults = defaultsDeep({}, sources.packaged?.rootOptionDefaults ?? {}, sources.project?.public?.rootOptionDefaults ?? {}, sources.project?.local?.rootOptionDefaults ?? {});
+                }
+                catch {
+                    /* tolerate missing config */
+                }
+                const mergedDefaultsForHelp = defaultsDeep(baseRootOptionDefaults, rootDefaults, cfgDefaults);
+                const { merged: defaultsMerged } = resolveCliOptions({}, mergedDefaultsForHelp, undefined);
+                // Use unified defaults directly for help labels (no ctx overlays).
+                const helpMerged = { ...defaultsMerged };
+                const helpCfg = toHelpConfig(helpMerged, ctx.pluginConfigs);
+                // Evaluate dynamic labels
+                program.evaluateDynamicOptions(helpCfg);
+                // Suppress output only during unit tests; allow E2E to capture.
+                const piping = process.env.GETDOTENV_STDIO === 'pipe' ||
+                    process.env.GETDOTENV_STDOUT === 'pipe';
+                if (!(underTests && !piping)) {
+                    dbg('outputHelp()');
+                    // Merge visibility for help-time using precedence:
+                    // createCli(rootOptionVisibility) < packaged/public < project/public < project/local
+                    try {
+                        const sources = await resolveGetDotenvConfigSources(import.meta.url);
+                        const mergedVis = mergeRootVisibility(visibility, sources.packaged?.rootOptionVisibility ?? undefined, sources.project?.public?.rootOptionVisibility ?? undefined, sources.project?.local?.rootOptionVisibility ?? undefined);
+                        if (Object.keys(mergedVis).length > 0) {
+                            applyRootVisibility(program, mergedVis);
+                        }
+                    }
+                    catch {
+                        // best-effort; do not block help
+                    }
+                    program.outputHelp();
+                }
+                return;
+            }
+            // Subcommand token exists before -h: fall through to normal parsing,
+            // letting Commander print that subcommand's help.
+        }
+        dbg('parseAsync start');
+        await program.brand({
+            name: alias,
+            importMetaUrl: import.meta.url,
+            description: 'Base CLI.',
+            ...(typeof opts.branding === 'string' && opts.branding.length > 0
+                ? { helpHeader: opts.branding }
+                : {}),
+        });
+        await program.parseAsync(['node', alias, ...argv]);
+    };
+}
+
+export { createCli as c };

package/dist/chunks/externalDataInterceptor-CbsdEYa-.mjs

@@ -0,0 +1,19 @@
+import { t as tokenIntercept } from './getSSOTokenFromFile-hUSpR7Wf.mjs';
+import { h as fileIntercept } from './index-CeCufHlm.mjs';
+
+const externalDataInterceptor = {
+    getFileRecord() {
+        return fileIntercept;
+    },
+    interceptFile(path, contents) {
+        fileIntercept[path] = Promise.resolve(contents);
+    },
+    getTokenRecord() {
+        return tokenIntercept;
+    },
+    interceptToken(id, contents) {
+        tokenIntercept[id] = contents;
+    },
+};
+
+export { externalDataInterceptor as e };

package/dist/chunks/getSSOTokenFromFile-hUSpR7Wf.mjs

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { j as getHomeDir } from './index-CeCufHlm.mjs';
+
+const getSSOTokenFilepath = (id) => {
+    const hasher = createHash("sha1");
+    const cacheName = hasher.update(id).digest("hex");
+    return join(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
+};
+
+const tokenIntercept = {};
+const getSSOTokenFromFile = async (id) => {
+    if (tokenIntercept[id]) {
+        return tokenIntercept[id];
+    }
+    const ssoTokenFilepath = getSSOTokenFilepath(id);
+    const ssoTokenText = await readFile(ssoTokenFilepath, "utf8");
+    return JSON.parse(ssoTokenText);
+};
+
+export { getSSOTokenFromFile as a, getSSOTokenFilepath as g, tokenIntercept as t };

package/dist/chunks/helpConfig-CGejgwWW.mjs

@@ -0,0 +1,12 @@
+/**
+ * Build a help-time configuration bag for dynamic option descriptions.
+ * Centralizes construction and reduces inline casts at call sites.
+ */
+const toHelpConfig = (merged, plugins) => {
+    return {
+        ...merged,
+        plugins: plugins ?? {},
+    };
+};
+
+export { toHelpConfig as t };