@depup/env-cmd 11.0.0-depup.25

package/dist/parse-env-file.d.ts

@@ -0,0 +1,30 @@
+import type { Environment } from './types.ts';
+/**
+ * Gets the environment vars from an env file
+ */
+export declare function getEnvFileVars(envFilePath: string): Promise<Environment>;
+/**
+ * Parse out all env vars from a given env file string and return an object
+ */
+export declare function parseEnvString(envFileString: string): Environment;
+/**
+ * Parse out all env vars from an env file string
+ */
+export declare function parseEnvVars(envString: string): Environment;
+/**
+ * Strips out comments from env file string
+ */
+export declare function stripComments(envString: string): string;
+/**
+ * Strips out newlines from env file string
+ */
+export declare function stripEmptyLines(envString: string): string;
+/**
+ * If we load data from a file like .js, the user
+ * might export something which is not an object.
+ *
+ * This function ensures that the input is valid,
+ * and converts the object's values to strings, for
+ * consistincy. See issue #125 for details.
+ */
+export declare function normalizeEnvObject(input: unknown, absolutePath: string): Environment;

package/dist/parse-env-file.js

@@ -0,0 +1,119 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolveEnvFilePath, IMPORT_HOOK_EXTENSIONS, isPromise } from './utils.js';
+import { checkIfTypescriptSupported } from './loaders/typescript.js';
+/**
+ * Gets the environment vars from an env file
+ */
+export async function getEnvFileVars(envFilePath) {
+    const absolutePath = resolveEnvFilePath(envFilePath);
+    if (!existsSync(absolutePath)) {
+        const pathError = new Error(`Invalid env file path (${envFilePath}).`);
+        pathError.name = 'PathError';
+        throw pathError;
+    }
+    // Get the file extension
+    const ext = extname(absolutePath).toLowerCase();
+    let env;
+    if (IMPORT_HOOK_EXTENSIONS.includes(ext)) {
+        if (/tsx?$/.test(ext))
+            checkIfTypescriptSupported();
+        // For some reason in ES Modules, only JSON file types need to be specifically delinated when importing them
+        let attributeTypes = {};
+        if (ext === '.json') {
+            attributeTypes = { with: { type: 'json' } };
+        }
+        const res = await import(pathToFileURL(absolutePath).href, attributeTypes);
+        if (typeof res === 'object' && res && 'default' in res) {
+            env = res.default;
+        }
+        else {
+            env = res;
+        }
+        // Check to see if the imported value is a promise
+        if (isPromise(env)) {
+            env = await env;
+        }
+        return normalizeEnvObject(env, absolutePath);
+    }
+    const file = readFileSync(absolutePath, { encoding: 'utf8' });
+    switch (ext) {
+        // other loaders can be added here
+        default:
+            return parseEnvString(file);
+    }
+}
+/**
+ * Parse out all env vars from a given env file string and return an object
+ */
+export function parseEnvString(envFileString) {
+    // First thing we do is stripe out all comments
+    envFileString = stripComments(envFileString);
+    // Next we stripe out all the empty lines
+    envFileString = stripEmptyLines(envFileString);
+    // Merge the file env vars with the current process env vars (the file vars overwrite process vars)
+    return parseEnvVars(envFileString);
+}
+/**
+ * Parse out all env vars from an env file string
+ */
+export function parseEnvVars(envString) {
+    const envParseRegex = /^((.+?)[=](.*))$/gim;
+    const matches = {};
+    let match;
+    while ((match = envParseRegex.exec(envString)) !== null) {
+        // Note: match[1] is the full env=var line
+        const key = match[2].trim();
+        let value = match[3].trim();
+        // if the string is quoted, remove everything after the final
+        // quote. This implicitly removes inline comments.
+        if (value.startsWith("'") || value.startsWith('"')) {
+            value = value.slice(1, value.lastIndexOf(value[0]));
+        }
+        else {
+            // if the string is not quoted, we need to explicitly remove
+            // inline comments.
+            value = value.split('#')[0].trim();
+        }
+        value = value.replace(/\\n/g, '\n');
+        matches[key] = value;
+    }
+    return JSON.parse(JSON.stringify(matches));
+}
+/**
+ * Strips out comments from env file string
+ */
+export function stripComments(envString) {
+    const commentsRegex = /(^\s*#.*$)/gim;
+    return envString.replace(commentsRegex, '');
+}
+/**
+ * Strips out newlines from env file string
+ */
+export function stripEmptyLines(envString) {
+    const emptyLinesRegex = /(^\n)/gim;
+    return envString.replace(emptyLinesRegex, '');
+}
+/**
+ * If we load data from a file like .js, the user
+ * might export something which is not an object.
+ *
+ * This function ensures that the input is valid,
+ * and converts the object's values to strings, for
+ * consistincy. See issue #125 for details.
+ */
+export function normalizeEnvObject(input, absolutePath) {
+    if (typeof input !== 'object' || !input) {
+        throw new Error(`env-cmd cannot load “${absolutePath}” because it does not export an object.`);
+    }
+    const env = {};
+    for (const [key, value] of Object.entries(input)) {
+        // we're intentionally stringifying the value here, to
+        // match what `child_process.spawn` does when loading
+        // env variables.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        env[key] = `${value}`;
+    }
+    return env;
+}

package/dist/parse-rc-file.d.ts

@@ -0,0 +1,8 @@
+import type { Environment } from './types.ts';
+/**
+ * Gets the env vars from the rc file and rc environments
+ */
+export declare function getRCFileVars({ environments, filePath }: {
+    environments: string[];
+    filePath: string;
+}): Promise<Environment>;

package/dist/parse-rc-file.js

@@ -0,0 +1,78 @@
+import { stat, readFile } from 'node:fs';
+import { promisify } from 'node:util';
+import { extname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolveEnvFilePath, IMPORT_HOOK_EXTENSIONS, isPromise } from './utils.js';
+import { checkIfTypescriptSupported } from './loaders/typescript.js';
+const statAsync = promisify(stat);
+const readFileAsync = promisify(readFile);
+/**
+ * Gets the env vars from the rc file and rc environments
+ */
+export async function getRCFileVars({ environments, filePath }) {
+    const absolutePath = resolveEnvFilePath(filePath);
+    try {
+        await statAsync(absolutePath);
+    }
+    catch {
+        const pathError = new Error(`Failed to find .rc file at path: ${absolutePath}`);
+        pathError.name = 'PathError';
+        throw pathError;
+    }
+    // Get the file extension
+    const ext = extname(absolutePath).toLowerCase();
+    let parsedData = {};
+    try {
+        if (IMPORT_HOOK_EXTENSIONS.includes(ext)) {
+            if (/tsx?$/.test(ext))
+                checkIfTypescriptSupported();
+            // For some reason in ES Modules, only JSON file types need to be specifically delinated when importing them
+            let attributeTypes = {};
+            if (ext === '.json') {
+                attributeTypes = { with: { type: 'json' } };
+            }
+            const res = await import(pathToFileURL(absolutePath).href, attributeTypes);
+            if ('default' in res) {
+                parsedData = res.default;
+            }
+            else {
+                parsedData = res;
+            }
+            // Check to see if the imported value is a promise
+            if (isPromise(parsedData)) {
+                parsedData = await parsedData;
+            }
+        }
+        else {
+            const file = await readFileAsync(absolutePath, { encoding: 'utf8' });
+            parsedData = JSON.parse(file);
+        }
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+        const parseError = new Error(`Failed to parse .rc file at path: ${absolutePath}.\n${errorMessage}`);
+        parseError.name = 'ParseError';
+        throw parseError;
+    }
+    // Parse and merge multiple rc environments together
+    let result = {};
+    let environmentFound = false;
+    for (const name of environments) {
+        if (name in parsedData) {
+            const envVars = parsedData[name];
+            if (envVars != null && typeof envVars === 'object') {
+                environmentFound = true;
+                result = {
+                    ...result,
+                    ...envVars,
+                };
+            }
+        }
+    }
+    if (!environmentFound) {
+        const environmentError = new Error(`Failed to find environments [${environments.join(',')}] at .rc file location: ${absolutePath}`);
+        environmentError.name = 'EnvironmentError';
+        throw environmentError;
+    }
+    return result;
+}

package/dist/signal-termination.d.ts

@@ -0,0 +1,27 @@
+import { ChildProcess } from 'child_process';
+export declare class TermSignals {
+    private readonly terminateSpawnedProcessFuncHandlers;
+    private terminateSpawnedProcessFuncExitHandler?;
+    private readonly verbose;
+    _exitCalled: boolean;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    handleTermSignals(proc: ChildProcess): void;
+    /**
+     * Enables catching of unhandled exceptions
+     */
+    handleUncaughtExceptions(): void;
+    /**
+     * Terminate parent process helper
+     */
+    _terminateProcess(signal?: NodeJS.Signals | number): void;
+    /**
+     * Exit event listener clean up helper
+     */
+    _removeProcessListeners(): void;
+    /**
+    * General exception handler
+    */
+    _uncaughtExceptionHandler(e: Error): void;
+}

package/dist/signal-termination.js

@@ -0,0 +1,116 @@
+const SIGNALS_TO_HANDLE = [
+    'SIGINT', 'SIGTERM', 'SIGHUP',
+];
+export class TermSignals {
+    terminateSpawnedProcessFuncHandlers = {};
+    terminateSpawnedProcessFuncExitHandler;
+    verbose = false;
+    _exitCalled = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose === true;
+    }
+    handleTermSignals(proc) {
+        // Terminate child process if parent process receives termination events
+        const terminationFunc = (signal) => {
+            this._removeProcessListeners();
+            if (!this._exitCalled) {
+                if (this.verbose) {
+                    console.info('Parent process exited with signal: '
+                        + signal.toString()
+                        + '. Terminating child process...');
+                }
+                // Mark shared state so we do not run into a signal/exit loop
+                this._exitCalled = true;
+                // Use the signal code if it is an error code
+                // let correctSignal: NodeJS.Signals | undefined
+                if (typeof signal === 'number') {
+                    if (signal > 0) {
+                        // code = signal
+                        signal = 'SIGINT';
+                    }
+                }
+                // else {
+                //   correctSignal = signal
+                // }
+                // Kill the child process
+                proc.kill(signal);
+                // Terminate the parent process
+                this._terminateProcess(signal);
+            }
+        };
+        for (const signal of SIGNALS_TO_HANDLE) {
+            this.terminateSpawnedProcessFuncHandlers[signal] = terminationFunc;
+            process.once(signal, this.terminateSpawnedProcessFuncHandlers[signal]);
+        }
+        this.terminateSpawnedProcessFuncExitHandler = terminationFunc;
+        process.once('exit', this.terminateSpawnedProcessFuncExitHandler);
+        // Terminate parent process if child process receives termination events
+        proc.on('exit', (code, signal) => {
+            this._removeProcessListeners();
+            if (!this._exitCalled) {
+                if (this.verbose) {
+                    console.info(`Child process exited with code: ${(code ?? '').toString()} and signal:`
+                        + (signal ?? '').toString()
+                        + '. Terminating parent process...');
+                }
+                // Mark shared state so we do not run into a signal/exit loop
+                this._exitCalled = true;
+                // Use the signal code if it is an error code
+                let correctSignal;
+                if (typeof signal === 'number') {
+                    if (signal > (code ?? 0)) {
+                        code = signal;
+                        correctSignal = 'SIGINT';
+                    }
+                }
+                else {
+                    correctSignal = signal ?? undefined;
+                }
+                // Terminate the parent process
+                this._terminateProcess(correctSignal ?? code);
+            }
+        });
+    }
+    /**
+     * Enables catching of unhandled exceptions
+     */
+    handleUncaughtExceptions() {
+        process.on('uncaughtException', (e) => {
+            this._uncaughtExceptionHandler(e);
+        });
+    }
+    /**
+     * Terminate parent process helper
+     */
+    _terminateProcess(signal) {
+        if (signal != null) {
+            if (typeof signal === 'string') {
+                process.kill(process.pid, signal);
+                return;
+            }
+            if (typeof signal === 'number') {
+                process.exit(signal);
+                return;
+            }
+        }
+        throw new Error('Unable to terminate parent process successfully');
+    }
+    /**
+     * Exit event listener clean up helper
+     */
+    _removeProcessListeners() {
+        SIGNALS_TO_HANDLE.forEach((signal) => {
+            process.removeListener(signal, this.terminateSpawnedProcessFuncHandlers[signal]);
+        });
+        if (this.terminateSpawnedProcessFuncExitHandler != null) {
+            process.removeListener('exit', this.terminateSpawnedProcessFuncExitHandler);
+        }
+    }
+    /**
+    * General exception handler
+    */
+    _uncaughtExceptionHandler(e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+import type { Command } from '@commander-js/extra-typings';
+export type Environment = Partial<Record<string, string>>;
+export type RCEnvironment = Partial<Record<string, Environment>>;
+export type CommanderOptions = Command<[], {
+    environments?: true | string[];
+    expandEnvs?: boolean;
+    recursive?: boolean;
+    fallback?: boolean;
+    file?: true | string;
+    override?: boolean;
+    silent?: boolean;
+    useShell?: boolean;
+    verbose?: boolean;
+}>;
+export interface RCFileOptions {
+    environments: string[];
+    filePath?: string;
+}
+export interface EnvFileOptions {
+    filePath?: string;
+    fallback?: boolean;
+}
+export interface GetEnvVarOptions {
+    envFile?: EnvFileOptions;
+    rc?: RCFileOptions;
+    verbose?: boolean;
+}
+export interface EnvCmdOptions extends GetEnvVarOptions {
+    command: string;
+    commandArgs: string[];
+    options?: {
+        expandEnvs?: boolean;
+        recursive?: boolean;
+        noOverride?: boolean;
+        silent?: boolean;
+        useShell?: boolean;
+        verbose?: boolean;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const IMPORT_HOOK_EXTENSIONS: string[];
+/**
+ * A simple function for resolving the path the user entered
+ */
+export declare function resolveEnvFilePath(userPath: string): string;
+/**
+ * A simple function that parses a comma separated string into an array of strings
+ */
+export declare function parseArgList(list: string): string[];
+/**
+ * A simple function to test if the value is a promise/thenable
+ */
+export declare function isPromise<T>(value?: T | PromiseLike<T>): value is PromiseLike<T>;
+/** @returns true if the error is `ERR_UNKNOWN_FILE_EXTENSION` */
+export declare function isLoaderError(error: unknown): error is Error;

package/dist/utils.js

@@ -0,0 +1,46 @@
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { cwd } from 'node:process';
+// Special file extensions that node can natively import
+export const IMPORT_HOOK_EXTENSIONS = [
+    '.json',
+    '.js',
+    '.cjs',
+    '.mjs',
+    '.ts',
+    '.mts',
+    '.cts',
+    '.tsx',
+];
+/**
+ * A simple function for resolving the path the user entered
+ */
+export function resolveEnvFilePath(userPath) {
+    // Make sure a home directory exist
+    const home = homedir();
+    if (home != null) {
+        userPath = userPath.replace(/^~($|\/|\\)/, `${home}$1`);
+    }
+    return resolve(cwd(), userPath);
+}
+/**
+ * A simple function that parses a comma separated string into an array of strings
+ */
+export function parseArgList(list) {
+    return list.split(',');
+}
+/**
+ * A simple function to test if the value is a promise/thenable
+ */
+export function isPromise(value) {
+    return value != null
+        && typeof value === 'object'
+        && 'then' in value
+        && typeof value.then === 'function';
+}
+/** @returns true if the error is `ERR_UNKNOWN_FILE_EXTENSION` */
+export function isLoaderError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ERR_UNKNOWN_FILE_EXTENSION');
+}

package/eslint.config.js

@@ -0,0 +1,38 @@
+import { default as tseslint } from 'typescript-eslint'
+import { default as globals } from 'globals'
+import { default as eslint } from '@eslint/js'
+
+export default tseslint.config(
+  {
+    // Ignore build folder
+    ignores: ['dist/*'],
+  },
+  eslint.configs.recommended,
+  tseslint.configs.strictTypeChecked,
+  tseslint.configs.stylisticTypeChecked,
+  {
+    // Enable Type generation
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        project: ['./tsconfig.json', './test/tsconfig.json'],
+      },
+    }
+  },
+  {
+    // For test files ignore some rules
+    files: ['test/**/*'],
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-unsafe-member-access': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 'off'
+    },
+  },
+  // Disable Type Checking JS/CJS/MJS files
+  {
+    files: ['**/*.js', '**/*.cjs', '**/*.mjs'],
+    extends: [tseslint.configs.disableTypeChecked],
+  },
+)

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@depup/env-cmd",
+  "version": "11.0.0-depup.25",
+  "description": "Executes a command using the environment variables in an env file (with updated dependencies)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "bin": {
+    "env-cmd": "bin/env-cmd.js"
+  },
+  "scripts": {
+    "test": "mocha",
+    "test-cover": "c8 npm test",
+    "coveralls": "coveralls < coverage/lcov.info",
+    "lint": "npx eslint .",
+    "build": "tsc",
+    "watch": "tsc -w"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/toddbluhm/env-cmd.git"
+  },
+  "keywords": [
+    "env-cmd",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "env",
+    "environment",
+    "cli",
+    "command",
+    "cmd",
+    "execute",
+    "run",
+    "file",
+    "variables",
+    "config"
+  ],
+  "author": "Todd Bluhm",
+  "contributors": [
+    "Anton Versal <ant.ver@gmail.com>",
+    "Eric Lanehart <eric@pushred.co>",
+    "Jon Scheiding <jonscheiding@gmail.com>",
+    "Kyle Hensel <me@kyle.kiwi>",
+    "Nicholas Krul <nicholas.krul@gmail.com>",
+    "serapath (Alexander Praetorius) <dev@serapath.de>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/toddbluhm/env-cmd/issues"
+  },
+  "homepage": "https://github.com/toddbluhm/env-cmd#readme",
+  "dependencies": {
+    "@commander-js/extra-typings": "^15.0.0",
+    "commander": "^15.0.0",
+    "cross-spawn": "^7.0.6"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.6.0",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@eslint/js": "^9.16.0",
+    "@types/chai": "^5.0.1",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.10",
+    "@types/sinon": "^17.0.3",
+    "c8": "^10.1.2",
+    "chai": "^5.1.2",
+    "coveralls": "^3.0.0",
+    "esmock": "^2.6.9",
+    "globals": "^16.0.0",
+    "husky": "^9.1.7",
+    "mocha": "^11.0.0",
+    "sinon": "^21.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.15.0"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "lcov"
+    ]
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "tagFormat": "${version}"
+  },
+  "depup": {
+    "changes": {
+      "@commander-js/extra-typings": {
+        "from": "^13.1.0",
+        "to": "^15.0.0"
+      },
+      "commander": {
+        "from": "^13.1.0",
+        "to": "^15.0.0"
+      }
+    },
+    "depsUpdated": 2,
+    "originalPackage": "env-cmd",
+    "originalVersion": "11.0.0",
+    "processedAt": "2026-07-21T17:22:46.794Z",
+    "smokeTest": "passed"
+  }
+}