@karmaniverous/get-dotenv 6.0.0-1 → 6.1.0

package/dist/plugins-demo.mjs

@@ -1,496 +0,0 @@
-import { execa, execaCommand } from 'execa';
-import { z } from 'zod';
-import 'fs-extra';
-import 'path';
-import 'package-directory';
-import 'url';
-import 'yaml';
-import 'nanoid';
-import 'dotenv';
-import 'crypto';
-
-// Minimal tokenizer for shell-off execution:
-// Splits by whitespace while preserving quoted segments (single or double quotes).
-// Optionally preserve doubled quotes inside quoted segments:
-// - default: "" => " (Windows/PowerShell style literal-quote escape)
-// - preserveDoubledQuotes: true => "" stays "" (needed for Node -e payloads)
-const tokenize = (command, opts) => {
-    const out = [];
-    let cur = '';
-    let quote = null;
-    for (let i = 0; i < command.length; i++) {
-        const c = command.charAt(i);
-        if (quote) {
-            if (c === quote) {
-                // Support doubled quotes inside a quoted segment:
-                // default: "" -> " and '' -> ' (Windows/PowerShell style)
-                // preserve: keep as "" to allow empty string literals in Node -e payloads
-                const next = command.charAt(i + 1);
-                if (next === quote) {
-                    {
-                        // Collapse to a single literal quote
-                        cur += quote;
-                        i += 1; // skip the second quote
-                    }
-                }
-                else {
-                    // end of quoted segment
-                    quote = null;
-                }
-            }
-            else {
-                cur += c;
-            }
-        }
-        else {
-            if (c === '"' || c === "'") {
-                quote = c;
-            }
-            else if (/\s/.test(c)) {
-                if (cur) {
-                    out.push(cur);
-                    cur = '';
-                }
-            }
-            else {
-                cur += c;
-            }
-        }
-    }
-    if (cur)
-        out.push(cur);
-    return out;
-};
-
-const dbg = (...args) => {
-    if (process.env.GETDOTENV_DEBUG) {
-        // Use stderr to avoid interfering with stdout assertions
-        console.error('[getdotenv:run]', ...args);
-    }
-};
-// Strip repeated symmetric outer quotes (single or double) until stable.
-// This is safe for argv arrays passed to execa (no quoting needed) and avoids
-// passing quote characters through to Node (e.g., for `node -e "<code>"`).
-// Handles stacked quotes from shells like PowerShell: """code""" -> code.
-const stripOuterQuotes = (s) => {
-    let out = s;
-    // Repeatedly trim only when the entire string is wrapped in matching quotes.
-    // Stop as soon as the ends are asymmetric or no quotes remain.
-    while (out.length >= 2) {
-        const a = out.charAt(0);
-        const b = out.charAt(out.length - 1);
-        const symmetric = (a === '"' && b === '"') || (a === "'" && b === "'");
-        if (!symmetric)
-            break;
-        out = out.slice(1, -1);
-    }
-    return out;
-};
-// Extract exitCode/stdout/stderr from execa result or error in a tolerant way.
-const pickResult = (r) => {
-    const exit = r.exitCode;
-    const stdoutVal = r.stdout;
-    const stderrVal = r.stderr;
-    return {
-        exitCode: typeof exit === 'number' ? exit : Number.NaN,
-        stdout: typeof stdoutVal === 'string' ? stdoutVal : '',
-        stderr: typeof stderrVal === 'string' ? stderrVal : '',
-    };
-};
-// Convert NodeJS.ProcessEnv (string | undefined values) to the shape execa
-// expects (Readonly<Partial<Record<string, string>>>), dropping undefineds.
-const sanitizeEnv = (env) => {
-    if (!env)
-        return undefined;
-    const entries = Object.entries(env).filter((e) => typeof e[1] === 'string');
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-async function runCommand(command, shell, opts) {
-    if (shell === false) {
-        let file;
-        let args = [];
-        if (typeof command === 'string') {
-            const tokens = tokenize(command);
-            file = tokens[0];
-            args = tokens.slice(1);
-        }
-        else {
-            file = command[0];
-            args = command.slice(1).map(stripOuterQuotes);
-        }
-        if (!file)
-            return 0;
-        dbg('exec (plain)', { file, args, stdio: opts.stdio });
-        // Build options without injecting undefined properties (exactOptionalPropertyTypes).
-        const envSan = sanitizeEnv(opts.env);
-        const plainOpts = {};
-        if (opts.cwd !== undefined)
-            plainOpts.cwd = opts.cwd;
-        if (envSan !== undefined)
-            plainOpts.env = envSan;
-        if (opts.stdio !== undefined)
-            plainOpts.stdio = opts.stdio;
-        const ok = pickResult((await execa(file, args, plainOpts)));
-        if (opts.stdio === 'pipe' && ok.stdout) {
-            process.stdout.write(ok.stdout + (ok.stdout.endsWith('\n') ? '' : '\n'));
-        }
-        dbg('exit (plain)', { exitCode: ok.exitCode });
-        return typeof ok.exitCode === 'number' ? ok.exitCode : Number.NaN;
-    }
-    else {
-        const commandStr = typeof command === 'string' ? command : command.join(' ');
-        dbg('exec (shell)', {
-            shell: typeof shell === 'string' ? shell : 'custom',
-            stdio: opts.stdio,
-            command: commandStr,
-        });
-        const envSan = sanitizeEnv(opts.env);
-        const shellOpts = { shell };
-        if (opts.cwd !== undefined)
-            shellOpts.cwd = opts.cwd;
-        if (envSan !== undefined)
-            shellOpts.env = envSan;
-        if (opts.stdio !== undefined)
-            shellOpts.stdio = opts.stdio;
-        const ok = pickResult((await execaCommand(commandStr, shellOpts)));
-        if (opts.stdio === 'pipe' && ok.stdout) {
-            process.stdout.write(ok.stdout + (ok.stdout.endsWith('\n') ? '' : '\n'));
-        }
-        dbg('exit (shell)', { exitCode: ok.exitCode });
-        return typeof ok.exitCode === 'number' ? ok.exitCode : Number.NaN;
-    }
-}
-
-/** src/cliCore/spawnEnv.ts
- * Build a sanitized environment bag for child processes.
- *
- * Requirements addressed:
- * - Provide a single helper (buildSpawnEnv) to normalize/dedupe child env.
- * - Drop undefined values (exactOptional semantics).
- * - On Windows, dedupe keys case-insensitively and prefer the last value,
- *   preserving the latest key's casing. Ensure HOME fallback from USERPROFILE.
- *   Normalize TMP/TEMP consistency when either is present.
- * - On POSIX, keep keys as-is; when a temp dir key is present (TMPDIR/TMP/TEMP),
- *   ensure TMPDIR exists for downstream consumers that expect it.
- *
- * Adapter responsibility: pure mapping; no business logic.
- */
-const dropUndefined = (bag) => Object.fromEntries(Object.entries(bag).filter((e) => typeof e[1] === 'string'));
-/** Build a sanitized env for child processes from base + overlay. */
-const buildSpawnEnv = (base, overlay) => {
-    const raw = {
-        ...(base ?? {}),
-        ...(overlay ?? {}),
-    };
-    // Drop undefined first
-    const entries = Object.entries(dropUndefined(raw));
-    if (process.platform === 'win32') {
-        // Windows: keys are case-insensitive; collapse duplicates
-        const byLower = new Map();
-        for (const [k, v] of entries) {
-            byLower.set(k.toLowerCase(), [k, v]); // last wins; preserve latest casing
-        }
-        const out = {};
-        for (const [, [k, v]] of byLower)
-            out[k] = v;
-        // HOME fallback from USERPROFILE (common expectation)
-        if (!Object.prototype.hasOwnProperty.call(out, 'HOME')) {
-            const up = out['USERPROFILE'];
-            if (typeof up === 'string' && up.length > 0)
-                out['HOME'] = up;
-        }
-        // Normalize TMP/TEMP coherence (pick any present; reflect to both)
-        const tmp = out['TMP'] ?? out['TEMP'];
-        if (typeof tmp === 'string' && tmp.length > 0) {
-            out['TMP'] = tmp;
-            out['TEMP'] = tmp;
-        }
-        return out;
-    }
-    // POSIX: keep keys as-is
-    const out = Object.fromEntries(entries);
-    // Ensure TMPDIR exists when any temp key is present (best-effort)
-    const tmpdir = out['TMPDIR'] ?? out['TMP'] ?? out['TEMP'];
-    if (typeof tmpdir === 'string' && tmpdir.length > 0) {
-        out['TMPDIR'] = tmpdir;
-    }
-    return out;
-};
-
-/**
- * Zod schemas for configuration files discovered by the new loader.
- *
- * Notes:
- * - RAW: all fields optional; shapes are stringly-friendly (paths may be string[] or string).
- * - RESOLVED: normalized shapes (paths always string[]).
- * - For JSON/YAML configs, the loader rejects "dynamic" and "schema" (JS/TS-only).
- */
-// String-only env value map
-const stringMap = z.record(z.string(), z.string());
-const envStringMap = z.record(z.string(), stringMap);
-// Allow string[] or single string for "paths" in RAW; normalize later.
-const rawPathsSchema = z.union([z.array(z.string()), z.string()]).optional();
-const getDotenvConfigSchemaRaw = z.object({
-    dotenvToken: z.string().optional(),
-    privateToken: z.string().optional(),
-    paths: rawPathsSchema,
-    loadProcess: z.boolean().optional(),
-    log: z.boolean().optional(),
-    shell: z.union([z.string(), z.boolean()]).optional(),
-    scripts: z.record(z.string(), z.unknown()).optional(), // Scripts validation left wide; generator validates elsewhere
-    requiredKeys: z.array(z.string()).optional(),
-    schema: z.unknown().optional(), // JS/TS-only; loader rejects in JSON/YAML
-    vars: stringMap.optional(), // public, global
-    envVars: envStringMap.optional(), // public, per-env
-    // Dynamic in config (JS/TS only). JSON/YAML loader will reject if set.
-    dynamic: z.unknown().optional(),
-    // Per-plugin config bag; validated by plugins/host when used.
-    plugins: z.record(z.string(), z.unknown()).optional(),
-});
-// Normalize paths to string[]
-const normalizePaths = (p) => p === undefined ? undefined : Array.isArray(p) ? p : [p];
-getDotenvConfigSchemaRaw.transform((raw) => ({
-    ...raw,
-    paths: normalizePaths(raw.paths),
-}));
-
-/**
- * Zod schemas for programmatic GetDotenv options.
- *
- * Canonical source of truth for options shape. Public types are derived
- * from these schemas (see consumers via z.output\<\>).
- */
-// Minimal process env representation: string values or undefined to indicate "unset".
-const processEnvSchema = z.record(z.string(), z.string().optional());
-// RAW: all fields optional — undefined means "inherit" from lower layers.
-z.object({
-    defaultEnv: z.string().optional(),
-    dotenvToken: z.string().optional(),
-    dynamicPath: z.string().optional(),
-    // Dynamic map is intentionally wide for now; refine once sources are normalized.
-    dynamic: z.record(z.string(), z.unknown()).optional(),
-    env: z.string().optional(),
-    excludeDynamic: z.boolean().optional(),
-    excludeEnv: z.boolean().optional(),
-    excludeGlobal: z.boolean().optional(),
-    excludePrivate: z.boolean().optional(),
-    excludePublic: z.boolean().optional(),
-    loadProcess: z.boolean().optional(),
-    log: z.boolean().optional(),
-    logger: z.unknown().optional(),
-    outputPath: z.string().optional(),
-    paths: z.array(z.string()).optional(),
-    privateToken: z.string().optional(),
-    vars: processEnvSchema.optional(),
-});
-
-/**
- * Instance-bound plugin config store.
- * Host stores the validated/interpolated slice per plugin instance.
- * The store is intentionally private to this module; definePlugin()
- * provides a typed accessor that reads from this store for the calling
- * plugin instance.
- */
-const PLUGIN_CONFIG_STORE = new WeakMap();
-const _getPluginConfigForInstance = (plugin) => PLUGIN_CONFIG_STORE.get(plugin);
-
-/** src/cliHost/definePlugin.ts
- * Plugin contracts for the GetDotenv CLI host.
- *
- * This module exposes a structural public interface for the host that plugins
- * should use (GetDotenvCliPublic). Using a structural type at the seam avoids
- * nominal class identity issues (private fields) in downstream consumers.
- */
-/* eslint-disable tsdoc/syntax */
-function definePlugin(spec) {
-    const { children = [], ...rest } = spec;
-    // Default to a strict empty-object schema so “no-config” plugins fail fast
-    // on unknown keys and provide a concrete {} at runtime.
-    const effectiveSchema = spec.configSchema ?? z.object({}).strict();
-    // Build base plugin first, then extend with instance-bound helpers.
-    const base = {
-        ...rest,
-        // Always carry a schema (strict empty by default) to simplify host logic
-        // and improve inference/ergonomics for plugin authors.
-        configSchema: effectiveSchema,
-        children: [...children],
-        use(child) {
-            this.children.push(child);
-            return this;
-        },
-    };
-    // Attach instance-bound helpers on the returned plugin object.
-    const extended = base;
-    extended.readConfig = function (_cli) {
-        // Config is stored per-plugin-instance by the host (WeakMap in computeContext).
-        const value = _getPluginConfigForInstance(extended);
-        if (value === undefined) {
-            // Guard: host has not resolved config yet (incorrect lifecycle usage).
-            throw new Error('Plugin config not available. Ensure resolveAndLoad() has been called before readConfig().');
-        }
-        return value;
-    };
-    // Plugin-bound dynamic option factory
-    extended.createPluginDynamicOption = function (cli, flags, desc, parser, defaultValue) {
-        return cli.createDynamicOption(flags, (cfg) => {
-            // Prefer the validated slice stored per instance; fallback to help-bag
-            // (by-id) so top-level `-h` can render effective defaults before resolve.
-            const fromStore = _getPluginConfigForInstance(extended);
-            const id = extended.id;
-            let fromBag;
-            if (!fromStore && id) {
-                const maybe = cfg.plugins[id];
-                if (maybe && typeof maybe === 'object') {
-                    fromBag = maybe;
-                }
-            }
-            // Always provide a concrete object to dynamic callbacks:
-            // - With a schema: computeContext stores the parsed object.
-            // - Without a schema: computeContext stores {}.
-            // - Help-time fallback: coalesce to {} when only a by-id bag exists.
-            const cfgVal = (fromStore ?? fromBag ?? {});
-            return desc(cfg, cfgVal);
-        }, parser, defaultValue);
-    };
-    return extended;
-}
-
-/**
- * Batch services (neutral): resolve command and shell settings.
- * Shared by the generator path and the batch plugin to avoid circular deps.
- */
-/**
- * Resolve a command string from the {@link Scripts} table.
- * A script may be expressed as a string or an object with a `cmd` property.
- *
- * @param scripts - Optional scripts table.
- * @param command - User-provided command name or string.
- * @returns Resolved command string (falls back to the provided command).
- */
-const resolveCommand = (scripts, command) => scripts && typeof scripts[command] === 'object'
-    ? scripts[command].cmd
-    : (scripts?.[command] ?? command);
-/**
- * Resolve the shell setting for a given command:
- * - If the script entry is an object, prefer its `shell` override.
- * - Otherwise use the provided `shell` (string | boolean).
- *
- * @param scripts - Optional scripts table.
- * @param command - User-provided command name or string.
- * @param shell - Global shell preference (string | boolean).
- */
-const resolveShell = (scripts, command, shell) => scripts && typeof scripts[command] === 'object'
-    ? (scripts[command].shell ?? false)
-    : (shell ?? false);
-
-const demoPlugin = () => definePlugin({
-    id: 'demo',
-    setup(cli) {
-        const logger = console;
-        const ns = cli
-            .ns('demo')
-            .description('Educational demo of host/plugin features (context, child exec, scripts/shell)');
-        /**
-         * demo ctx
-         * Print a summary of the current dotenv context.
-         *
-         * Notes:
-         * - The host resolves context once per invocation in a preSubcommand hook
-         *   (added by enhanceGetDotenvCli.passOptions() in the shipped CLI).
-         * - ctx.dotenv contains the final merged values after overlays/dynamics.
-         */
-        ns.command('ctx')
-            .description('Print a summary of the current dotenv context')
-            .action(() => {
-            const ctx = cli.getCtx();
-            const dotenv = ctx?.dotenv ?? {};
-            const keys = Object.keys(dotenv).sort();
-            const sample = keys.slice(0, 5);
-            logger.log('[demo] Context summary:');
-            logger.log(`- keys: ${keys.length.toString()}`);
-            logger.log(`- sample keys: ${sample.join(', ') || '(none)'}`);
-            logger.log('- tip: use "--trace [keys...]" for per-key diagnostics');
-        });
-        /**
-         * demo run [--print KEY]
-         * Execute a small child process that prints a dotenv value.
-         *
-         * Design:
-         * - Use shell-off + argv array to avoid cross-platform quoting pitfalls.
-         * - Inject ctx.dotenv explicitly into the child env.
-         * - Inherit stdio so output streams live (works well outside CI).
-         *
-         * Tip:
-         * - For deterministic capture in CI, run with "--capture" (or set
-         *   GETDOTENV_STDIO=pipe). The shipped CLI honors both.
-         */
-        ns.command('run')
-            .description('Run a small child process under the current dotenv (shell-off)')
-            .option('--print <key>', 'dotenv key to print', 'APP_SETTING')
-            .action(async (opts) => {
-            const key = typeof opts.print === 'string' && opts.print.length > 0
-                ? opts.print
-                : 'APP_SETTING';
-            // Build a minimal node -e payload via argv array (avoid quoting issues).
-            const code = `console.log(process.env.${key} ?? "")`;
-            const ctx = cli.getCtx();
-            // Inherit stdio for an interactive demo. Use --capture for CI.
-            await runCommand(['node', '-e', code], false, {
-                env: buildSpawnEnv(process.env, ctx?.dotenv),
-                stdio: 'inherit',
-            });
-        });
-        /**
-         * demo script [command...]
-         * Resolve and execute a command using the current scripts table and
-         * shell preference (with per-script overrides).
-         *
-         * How it works:
-         * - We read the merged CLI options persisted by the shipped CLI’s
-         *   passOptions() hook on the current command instance’s parent.
-         * - resolveCommand resolves a script name → cmd or passes through a raw
-         *   command string.
-         * - resolveShell chooses the appropriate shell:
-         *    scripts[name].shell ?? global shell (string|boolean).
-         */
-        ns.command('script')
-            .description('Resolve a command via scripts and execute it with the proper shell')
-            .argument('[command...]')
-            .action(async (commandParts, _opts, thisCommand) => {
-            // Safely access the parent’s merged options (installed by passOptions()).
-            const parent = thisCommand.parent;
-            const bag = (parent?.getDotenvCliOptions ?? {});
-            const input = Array.isArray(commandParts)
-                ? commandParts.map(String).join(' ')
-                : '';
-            if (!input) {
-                logger.log('[demo] Please provide a command or script name, e.g. "echo OK" or "git-status".');
-                return;
-            }
-            const resolved = resolveCommand(bag?.scripts, input);
-            const shell = resolveShell(bag?.scripts, input, bag?.shell);
-            // Compose child env (parent + ctx.dotenv). This mirrors cmd/batch behavior.
-            const ctx = cli.getCtx();
-            await runCommand(resolved, shell, {
-                env: buildSpawnEnv(process.env, ctx?.dotenv),
-                stdio: 'inherit',
-            });
-        });
-    },
-    /**
-     * Optional: afterResolve can initialize per-plugin state using ctx.dotenv.
-     * For the demo we emit a single breadcrumb only when GETDOTENV_DEBUG is set,
-     * keeping default runs (tests/CI/smoke) quiet.
-     */
-    afterResolve(_cli, ctx) {
-        if (process.env.GETDOTENV_DEBUG) {
-            const keys = Object.keys(ctx.dotenv);
-            if (keys.length > 0) {
-                // Keep noise low; a single-line breadcrumb is sufficient for the demo.
-                console.error('[demo] afterResolve: dotenv keys loaded:', keys.length);
-            }
-        }
-    },
-});
-
-export { demoPlugin };

package/templates/cli/ts/index.ts

@@ -1,9 +0,0 @@
-import { GetDotenvCli } from '@karmaniverous/get-dotenv/cliHost';
-import type { Command } from 'commander';
-
-import { helloPlugin } from './plugins/hello';
-
-const program: Command = new GetDotenvCli('__CLI_NAME__').use(helloPlugin());
-
-await (program as unknown as GetDotenvCli).resolveAndLoad();
-await program.parseAsync();