@mikeyt23/node-cli-utils 1.4.1 → 2.0.0-beta.1

package/dist/esm/generalUtilsInternal.js

@@ -0,0 +1,185 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { config } from './NodeCliUtilsConfig.js';
+import { SpawnError, isPlatformWindows, log, requireValidPath, sortDictionaryByKeyAsc, spawnAsync, stringToNonEmptyLines, trace } from './generalUtils.js';
+const isCommonJS = typeof require === "function" && typeof module === "object" && module.exports;
+const isEsm = !isCommonJS;
+const spawnWorkaroundScriptName = 'runWhileParentAlive.js';
+const currentModuleDir = ''; // Lazy loaded in getCurrentModuleDir
+export async function copyEnv(sourcePath, destinationPath, overrideExistingDestinationValues = true, suppressAddKeysMessages = false) {
+    requireValidPath('sourcePath', sourcePath);
+    // If the destination .env file doesn't exist, just copy it and return
+    if (!fs.existsSync(destinationPath)) {
+        log(`creating ${destinationPath} from ${sourcePath}`);
+        await fsp.copyFile(sourcePath, destinationPath);
+        return;
+    }
+    const sourceDict = getEnvAsDictionary(sourcePath);
+    const destinationDict = getEnvAsDictionary(destinationPath);
+    // Determine what keys are missing from destinationPath .env that are in sourcePath .env or .env.template
+    const templateKeys = Object.keys(sourceDict);
+    const destinationKeysBeforeChanging = Object.keys(destinationDict);
+    const keysMissingInDestination = templateKeys.filter(envKey => !destinationKeysBeforeChanging.includes(envKey));
+    if (keysMissingInDestination.length > 0) {
+        if (!suppressAddKeysMessages) {
+            log(`adding missing keys in ${destinationPath}: ${keysMissingInDestination.join(', ')}`);
+        }
+    }
+    // For instances where both .env files have the same key, use the value from the source if
+    // overrideExistingDestinationValues param is true, otherwise leave the value from the destination intact.
+    const newDict = {};
+    for (const [key, value] of Object.entries(overrideExistingDestinationValues ? sourceDict : destinationDict)) {
+        newDict[key] = value;
+    }
+    // Add entries that the destination doesn't have yet
+    for (const key of keysMissingInDestination) {
+        newDict[key] = sourceDict[key];
+    }
+    const newSortedDict = sortDictionaryByKeyAsc(newDict);
+    const newEnvFileContent = dictionaryToEnvFileString(newSortedDict);
+    await fsp.writeFile(destinationPath, newEnvFileContent);
+}
+export function getEnvAsDictionary(envPath) {
+    const dict = {};
+    const lines = stringToNonEmptyLines(fs.readFileSync(envPath).toString());
+    for (const line of lines) {
+        if (line && line.indexOf('=') !== -1) {
+            const parts = line.split('=');
+            dict[parts[0].trim()] = parts[1].trim();
+        }
+    }
+    return dict;
+}
+export function dictionaryToEnvFileString(dict) {
+    return Object.entries(dict).map(kvp => `${kvp[0]}=${kvp[1]}`).join('\n') + '\n';
+}
+export async function spawnAsyncInternal(command, args, options) {
+    const moduleDir = await getCurrentModuleDir();
+    return new Promise((resolve, reject) => {
+        try {
+            const defaultSpawnOptions = { stdio: 'inherit' };
+            const argsForChildProcess = args ?? [];
+            const logPrefix = `[${command} ${argsForChildProcess.join(' ')}] `;
+            const mergedOptions = { ...defaultSpawnOptions, ...options };
+            const result = {
+                code: 1,
+                stdout: '',
+                stderr: '',
+                cwd: mergedOptions.cwd?.toString() ?? process.cwd()
+            };
+            // Windows has an issue where child processes are orphaned when using the shell option. This workaround will spawn
+            // a "middle" process using the shell option to check whether parent process is still running at intervals and if not, kill the child process tree.
+            const workaroundCommand = 'node';
+            const workaroundScriptPath = path.join(moduleDir, spawnWorkaroundScriptName);
+            // First check if this is the request for the workaround process itself
+            if (options?.isLongRunning && isPlatformWindows() && command !== workaroundCommand && (!argsForChildProcess[0] || !argsForChildProcess[0].endsWith(spawnWorkaroundScriptName))) {
+                trace(`${logPrefix}Running on Windows with shell option - using middle process hack to prevent orphaned processes`);
+                const loggingEnabledString = config.orphanProtectionLoggingEnabled.toString();
+                const traceEnabledString = config.traceEnabled.toString();
+                const pollingMillisString = config.orphanProtectionPollingIntervalMillis.toString();
+                trace(`${logPrefix}Orphan protection logging enabled: ${loggingEnabledString}`);
+                trace(`${logPrefix}Orphan protection trace enabled: ${traceEnabledString}`);
+                trace(`${logPrefix}Orphan protection polling interval: ${pollingMillisString}ms`);
+                if (config.orphanProtectionLoggingEnabled) {
+                    trace(`${logPrefix}Orphan protection logging path: ${config.orphanProtectionLoggingPath}`);
+                }
+                const workaroundArgs = [
+                    workaroundScriptPath,
+                    loggingEnabledString,
+                    traceEnabledString,
+                    pollingMillisString,
+                    command,
+                    ...(args ?? [])
+                ];
+                spawnAsync(workaroundCommand, workaroundArgs, { ...mergedOptions, stdio: 'inherit', shell: true })
+                    .then((workaroundResult) => {
+                    result.code = workaroundResult.code;
+                    if (options?.throwOnNonZero && result.code !== 0) {
+                        reject(getSpawnError(result.code, result, options));
+                        return;
+                    }
+                    resolve(result);
+                }).catch((err) => {
+                    reject(err);
+                });
+                return;
+            }
+            const child = spawn(command, argsForChildProcess, mergedOptions);
+            const childId = child.pid;
+            if (childId === undefined) {
+                throw new Error(`${logPrefix}ChildProcess pid is undefined - spawn failed`);
+            }
+            // This event will only be emitted when stdio is NOT set to 'inherit'
+            child.stdout?.on('data', (data) => {
+                process.stdout.write(data);
+                result.stdout += data.toString();
+            });
+            // This event will only be emitted when stdio is NOT set to 'inherit'
+            child.stderr?.on('data', (data) => {
+                process.stdout.write(data);
+                result.stderr += data.toString();
+            });
+            const listener = new SignalListener(child, logPrefix);
+            child.on('exit', (code, signal) => {
+                const signalMessage = signal ? ` with signal ${signal}` : '';
+                trace(`${logPrefix}ChildProcess exited with code ${code}${signalMessage}`);
+                // If long running, ctrl+c will cause null, which we don't necessarily want to consider an error
+                result.code = (code === null && options?.isLongRunning) ? 0 : code ?? 1;
+                child.removeAllListeners();
+                listener.detach();
+                if (options?.throwOnNonZero && result.code !== 0) {
+                    reject(getSpawnError(result.code, result, mergedOptions));
+                    return;
+                }
+                resolve(result);
+            });
+            child.on('error', (error) => {
+                trace(`${logPrefix}ChildProcess emitted an error event: `, error);
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+function getSpawnError(code, result, options) {
+    const additional = options.throwOnNonZero && options.stdio === 'inherit' ? `. See above for more details (stdio is 'inherit').` : '';
+    return new SpawnError(`Spawning child process failed with code ${code}${additional}`, result);
+}
+class SignalListener {
+    signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    child;
+    logPrefix;
+    constructor(child, logPrefix) {
+        this.child = child;
+        this.logPrefix = logPrefix;
+        this.attach();
+    }
+    // Arrow function provides unique handler function for each instance of SignalListener
+    handler = (signal) => {
+        trace(`${this.logPrefix}Process received ${signal} - killing ChildProcess with ID ${this.child.pid}`);
+        this.child.kill(signal);
+        this.detach();
+    };
+    attach() {
+        this.signals.forEach(signal => process.on(signal, this.handler));
+    }
+    detach() {
+        this.signals.forEach(signal => process.removeListener(signal, this.handler));
+    }
+}
+async function getCurrentModuleDir() {
+    if (currentModuleDir) {
+        return currentModuleDir;
+    }
+    if (isEsm) {
+        const module = await import('./esmSpecific.mjs');
+        const metaUrlFilePath = module.getImportMetaUrlFilePath();
+        const directory = path.dirname(metaUrlFilePath);
+        return path.normalize(directory);
+    }
+    return __dirname;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generalUtilsInternal.js","sourceRoot":"","sources":["../../src/generalUtilsInternal.ts"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './generalUtils.js';
+export { config } from './NodeCliUtilsConfig.js';
+export { createTarball, unpackTarball, unpackTarballContents } from './TarballUtility.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from './generalUtils.js';
+export { config } from './NodeCliUtilsConfig.js';
+export { createTarball, unpackTarball, unpackTarballContents } from './TarballUtility.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFDaEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxhQUFhLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQSJ9

package/dist/esm/runWhileParentAlive.d.ts

@@ -0,0 +1,2 @@
+export declare function trace(message?: unknown, ...optionalParams: unknown[]): void;
+//# sourceMappingURL=runWhileParentAlive.d.ts.map

package/dist/esm/runWhileParentAlive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runWhileParentAlive.d.ts","sourceRoot":"","sources":["../../src/runWhileParentAlive.ts"],"names":[],"mappings":"AAqBA,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,QAGpE"}

package/dist/esm/runWhileParentAlive.js

@@ -0,0 +1,153 @@
+// runWhileParentAlive.ts
+// Also referred to as "orphan protection" or "long running windows process workaround script"
+import { spawn, execSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import { config } from './NodeCliUtilsConfig.js';
+const DEV_LOGGING = false; // Set to true while developing this script to see more logging in the console
+let loggingEnabled = true; // Will be set below by process.argv[2] === 'true' from spawnAsync in generalUtils.js
+let traceEnabled = true; // Will be set below by process.argv[3] === 'true' from spawnAsync in generalUtils.js
+let pollingMillis = config.orphanProtectionPollingIntervalMillis; // Will be set by process.argv[4] from spawnAsync in generalUtils.js
+function getLogPrefix() {
+    const now = new Date();
+    const hours = now.getHours().toString().padStart(2, '0');
+    const minutes = now.getMinutes().toString().padStart(2, '0');
+    const seconds = now.getSeconds().toString().padStart(2, '0');
+    const milliseconds = now.getMilliseconds().toString().padStart(3, '0');
+    return `[${hours}:${minutes}:${seconds}:${milliseconds}] `;
+}
+// Using this trace method instead of importing from generalUtils.js since config is not shared between processes
+export function trace(message, ...optionalParams) {
+    const prefix = `[TRACE]`;
+    console.log(prefix, message, ...optionalParams);
+}
+function logToFile(message) {
+    fs.appendFileSync(config.orphanProtectionLoggingPath, `${getLogPrefix()}${message}` + ((message && message.length && message[message.length - 1] !== '\n') ? '\n' : ''));
+}
+function traceAndLog(message, isDevTrace = false) {
+    if (isDevTrace && !DEV_LOGGING) {
+        return;
+    }
+    if (isDevTrace && DEV_LOGGING) {
+        trace(getLogPrefix() + message);
+        logToFile(message);
+        return;
+    }
+    if (traceEnabled) {
+        trace(getLogPrefix() + message);
+    }
+    if (loggingEnabled) {
+        logToFile(message);
+    }
+}
+function isParentProcessAlive(parentId) {
+    try {
+        const result = spawnSync('tasklist', { shell: true });
+        const resultToLog = {
+            status: result.status,
+            stderr: result.stderr?.toString(),
+            stdoutIncludesParentId: result.stdout?.toString().includes(parentId.toString()) ?? false
+        };
+        traceAndLog('tasklist result: ' + JSON.stringify(resultToLog), true);
+        return resultToLog.stdoutIncludesParentId;
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.log(err.message);
+            console.log(err.stack);
+        }
+        else {
+            console.error(err);
+        }
+        traceAndLog(`Error attempting to fetch task list using 'tasklist' - returning false for isParentAlive(): ${err instanceof Error ? err.toString() : err}`);
+        return false;
+    }
+}
+function killTree(pid) {
+    try {
+        execSync(`taskkill /pid ${pid} /T /F`);
+        traceAndLog(`No errors running killTree`);
+    }
+    catch (err) {
+        traceAndLog(`Error running taskkill with PID ${pid}: ${err instanceof Error ? err.toString() : err}`);
+    }
+}
+try {
+    loggingEnabled = process.argv[2] === 'true';
+    traceEnabled = process.argv[3] === 'true';
+    pollingMillis = Number(process.argv[4]);
+    if (Number.isNaN(pollingMillis) || pollingMillis < 0 || pollingMillis > (3600 * 1000)) {
+        pollingMillis = config.orphanProtectionPollingIntervalMillis;
+    }
+    const passthroughArgs = process.argv.slice(5);
+    if (loggingEnabled) {
+        traceAndLog(`Logging enabled with polling rate set to: ${pollingMillis}ms`);
+        traceAndLog(`Trace enabled: ${traceEnabled}`);
+    }
+    if (DEV_LOGGING) {
+        const argvString = JSON.stringify(process.argv);
+        console.log(argvString);
+        logToFile(argvString);
+        traceAndLog(`process.argv[2] (logging enabled): ${process.argv[2]}`, true);
+        traceAndLog(`process.argv[3]   (trace enabled): ${process.argv[3]}`, true);
+        traceAndLog(`process.argv[4]  (polling millis): ${process.argv[4]}`, true);
+        traceAndLog(`rest of process.argv: ${JSON.stringify(passthroughArgs)}`, true);
+    }
+    const parentId = process.ppid;
+    if (!parentId) {
+        const noParentIdMessage = `Middle process cannot continue - parent process id not found`;
+        console.error(noParentIdMessage);
+        traceAndLog(noParentIdMessage);
+        process.exit(1);
+    }
+    const [command, ...args] = passthroughArgs;
+    const child = spawn(command, args, { stdio: 'inherit', shell: true });
+    const childId = child.pid;
+    if (!childId) {
+        const noChildIdMessage = 'spawning ChildProcess failed - no pid on returned handle';
+        console.error(noChildIdMessage);
+        traceAndLog(noChildIdMessage);
+        process.exit(1);
+    }
+    const interval = setInterval(() => {
+        if (!isParentProcessAlive(parentId)) {
+            traceAndLog('Parent process is not alive. Shutting down.');
+            killTree(childId);
+            clearInterval(interval);
+            traceAndLog('Used taskkill and cleared interval - exiting...');
+            process.exit(0);
+        }
+        else {
+            if (DEV_LOGGING) {
+                traceAndLog('Parent is alive, keep running.');
+            }
+        }
+    }, pollingMillis);
+    child.on('exit', (code, signal) => {
+        const andSignal = signal ? ` and signal ${signal}` : '';
+        traceAndLog(`ChildProcess exit event emitted with code ${code}${andSignal} - exiting`);
+        clearInterval(interval);
+        process.exit(code ?? 1);
+    });
+    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    signals.forEach((signal) => {
+        process.on(signal, () => {
+            traceAndLog(`Middle process received signal ${signal} - will attempt to kill child process tree, clear interval and exit`);
+            try {
+                clearInterval(interval);
+                traceAndLog(`Ran clearInterval in signal event ${signal} - exiting`);
+                process.exit(0);
+            }
+            catch (err) {
+                traceAndLog(`Error attempting to run clearInterval during signal event ${signal}: ${err instanceof Error ? err.toString() : err}`);
+                process.exit(1);
+            }
+        });
+    });
+}
+catch (err) {
+    const msg = `Unexpected error in runWhileParentAlive: ${err instanceof Error ? err.toString() : err}`;
+    console.error(msg);
+    logToFile(msg);
+    process.exit(1);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,22 +1,79 @@
 {
   "name": "@mikeyt23/node-cli-utils",
-  "version": "1.4.1",
+  "version": "2.0.0-beta.1",
   "description": "Some node cli utility functions",
   "author": "Mike Thompson",
   "license": "MIT",
-  "private": false,
-  "files": [
-    "index.js"
-  ],
   "homepage": "https://github.com/mikey-t/node-cli-utils",
   "repository": {
     "type": "git",
     "url": "https://github.com/mikey-t/node-cli-utils.git"
   },
-  "main": "index.js",
-  "dependencies": {
-    "fs-extra": "^11.1.1",
-    "tar": "^6.1.15",
-    "which": "^3.0.1"
+  "type": "module",
+  "scripts": {
+    "watch": "tsc -w --p tsconfig.esm.json",
+    "watch:cjs": "tsc -w --p tsconfig.cjs.json"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./certUtils": {
+      "import": {
+        "default": "./dist/esm/certUtils.js"
+      },
+      "require": {
+        "default": "./dist/cjs/certUtils.js"
+      }
+    },
+    "./dotnetUtils": {
+      "import": {
+        "default": "./dist/esm/dotnetUtils.js"
+      },
+      "require": {
+        "default": "./dist/cjs/dotnetUtils.js"
+      }
+    },
+    "./dbMigrationUtils": {
+      "import": {
+        "default": "./dist/esm/dbMigrationUtils.js"
+      },
+      "require": {
+        "default": "./dist/cjs/dbMigrationUtils.js"
+      }
+    }
+  },
+  "main": "./dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "files": [
+    "package.json",
+    "dist/",
+    "readme.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "volta": {
+    "node": "18.17.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.17.15",
+    "@typescript-eslint/eslint-plugin": "^6.6.0",
+    "@typescript-eslint/parser": "^6.6.0",
+    "eslint": "^8.49.0",
+    "swig-cli": "^0.0.9",
+    "ts-node": "^10.9.1",
+    "tsx": "^3.12.10",
+    "typedoc": "^0.25.1",
+    "typedoc-plugin-missing-exports": "^2.1.0",
+    "typescript": "^5.2.2"
   }
 }