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

package/dist/esm/generalUtilsInternal.d.ts

@@ -0,0 +1,15 @@
+import { SimpleSpawnResult, SpawnOptionsWithThrow, SpawnResult, StringKeyedDictionary, WhichResult } from './generalUtils.js';
+export declare function copyEnv(sourcePath: string, destinationPath: string, overrideExistingDestinationValues?: boolean, suppressAddKeysMessages?: boolean): Promise<void>;
+export declare function getEnvAsDictionary(envPath: string): StringKeyedDictionary;
+export declare function dictionaryToEnvFileString(dict: StringKeyedDictionary): string;
+export interface SpawnOptionsInternal extends SpawnOptionsWithThrow {
+    isLongRunning: boolean;
+}
+export declare function spawnAsyncInternal(command: string, args: string[], options?: Partial<SpawnOptionsInternal>): Promise<SpawnResult>;
+export declare function validateFindFilesRecursivelyParams(dir: string, filenamePattern: string): void;
+export declare function simpleSpawnSyncInternal(command: string, args?: string[], throwOnNonZero?: boolean, useCmd?: boolean): SimpleSpawnResult;
+export declare function simpleSpawnAsyncInternal(command: string, args?: string[], throwOnNonZero?: boolean, useCmd?: boolean): Promise<SimpleSpawnResult>;
+type SimpleSpawnFunction = (cmd: string, args: string[]) => Promise<SimpleSpawnResult> | SimpleSpawnResult;
+export declare function whichInternal(commandName: string, simpleCmd: SimpleSpawnFunction, simpleSpawn: SimpleSpawnFunction): Promise<WhichResult> | WhichResult;
+export {};
+//# sourceMappingURL=generalUtilsInternal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generalUtilsInternal.d.ts","sourceRoot":"","sources":["../../src/generalUtilsInternal.ts"],"names":[],"mappings":"AAKA,OAAO,EAAoB,iBAAiB,EAAc,qBAAqB,EAAE,WAAW,EAAE,qBAAqB,EAAE,WAAW,EAAuJ,MAAM,mBAAmB,CAAA;AAOhT,wBAAsB,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,iCAAiC,UAAO,EAAE,uBAAuB,UAAQ,iBAuCnJ;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAUzE;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAE7E;AAED,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAqDvI;AAiHD,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAgBtF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,GAAE,OAAc,EAAE,MAAM,GAAE,OAAe,GAAG,iBAAiB,CAmBpJ;AAED,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,GAAE,OAAc,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAmBpK;AAED,KAAK,mBAAmB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,iBAAiB,CAAC,GAAG,iBAAiB,CAAA;AAE1G,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,EAAE,WAAW,EAAE,mBAAmB,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAsCvJ"}

package/dist/esm/generalUtilsInternal.js

@@ -0,0 +1,278 @@
+import { spawn, spawnSync } 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 { SimpleSpawnError, SpawnError, isPlatformWindows, log, requireString, requireValidPath, sortDictionaryByKeyAsc, spawnAsync, stringToNonEmptyLines, stripShellMetaCharacters, 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 mergedOptions = setDefaultsAndMergeOptions(options);
+    const logPrefix = `[${command} ${args.join(' ')}] `;
+    // 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 workaroundScriptPath = await getWorkaroundScriptPath(command, args, options);
+    if (workaroundScriptPath) {
+        return await spawnWithKeepaliveWorkaround(logPrefix, workaroundScriptPath, command, args, mergedOptions);
+    }
+    return new Promise((resolve, reject) => {
+        try {
+            const result = getInitialSpawnResult();
+            const child = spawn(command, args, 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) => {
+                result.stdout += data.toString();
+            });
+            // This event will only be emitted when stdio is NOT set to 'inherit'
+            child.stderr?.on('data', (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}`);
+                result.code = getResultCode(code, mergedOptions.isLongRunning);
+                child.removeAllListeners();
+                listener.detach();
+                if (mergedOptions.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);
+        }
+    });
+}
+// If long running, ctrl+c will cause a null code, which we don't necessarily want to consider an error
+function getResultCode(code, isLongRunning) {
+    return (code === null && isLongRunning) ? 0 : code ?? 1;
+}
+const setDefaultsAndMergeOptions = (options) => {
+    const defaultSpawnOptions = { stdio: 'inherit', isLongRunning: false, throwOnNonZero: false };
+    return { ...defaultSpawnOptions, ...options };
+};
+// Return workaroundScriptPath if:
+// - Long running option set to true
+// - OS is Windows
+// - It's not the long running workaround call itself (avoid an infinite loop)
+// Otherwise return undefined
+async function getWorkaroundScriptPath(command, args, options) {
+    const moduleDir = await getCurrentModuleDir();
+    let workaroundScriptPath = path.join(moduleDir, spawnWorkaroundScriptName);
+    // This allows use of spawnAsyncLongRunning within this project (i.e. swigfile.ts)
+    if (!fs.existsSync(workaroundScriptPath) && workaroundScriptPath.includes('node-cli-utils')) {
+        workaroundScriptPath = path.resolve('dist/esm', spawnWorkaroundScriptName);
+    }
+    if (options?.isLongRunning && isPlatformWindows() && !(command === 'node' && args && args[0]?.endsWith(spawnWorkaroundScriptName))) {
+        return workaroundScriptPath;
+    }
+    return undefined;
+}
+async function spawnWithKeepaliveWorkaround(logPrefix, workaroundScriptPath, command, args, options) {
+    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 ?? [])
+    ];
+    return await spawnAsync('node', workaroundArgs, { ...options, stdio: 'inherit', shell: true });
+}
+function getInitialSpawnResult(options) {
+    return {
+        code: 1,
+        stdout: '',
+        stderr: '',
+        cwd: options?.cwd?.toString() ?? process.cwd()
+    };
+}
+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;
+}
+export function validateFindFilesRecursivelyParams(dir, filenamePattern) {
+    requireValidPath('dir', dir);
+    requireString('pattern', filenamePattern);
+    if (filenamePattern.length > 50) {
+        throw new Error(`filenamePattern param must have fewer than 50 characters`);
+    }
+    const numWildcards = filenamePattern.replace(/\*+/g, '*').split('*').length - 1;
+    if (numWildcards > 5) {
+        throw new Error(`filenamePattern param must contain 5 or fewer wildcards`);
+    }
+    if (filenamePattern.includes('/') || filenamePattern.includes('\\')) {
+        throw new Error('filenamePattern param must not contain slashes');
+    }
+}
+export function simpleSpawnSyncInternal(command, args, throwOnNonZero = true, useCmd = false) {
+    requireString('command', command);
+    const result = spawnSync(command, args ?? [], { encoding: 'utf-8', shell: useCmd ? 'cmd.exe' : false });
+    const spawnResult = {
+        code: result.status ?? 1,
+        stdout: result.stdout.toString(),
+        stderr: result.stdout.toString(),
+        stdoutLines: stringToNonEmptyLines(result.stdout.toString()),
+        error: result.error,
+        cwd: process.cwd()
+    };
+    if (spawnResult.code !== 0 && throwOnNonZero) {
+        throw new SimpleSpawnError(`spawned process failed with code ${spawnResult.code}`, spawnResult);
+    }
+    return spawnResult;
+}
+export async function simpleSpawnAsyncInternal(command, args, throwOnNonZero = true, useCmd = false) {
+    requireString('command', command);
+    const result = await spawnAsync(command, args, { stdio: 'pipe', shell: useCmd ? 'cmd.exe' : false });
+    const spawnResult = {
+        code: result.code,
+        stdout: result.stdout,
+        stderr: result.stdout,
+        stdoutLines: stringToNonEmptyLines(result.stdout),
+        error: result.error,
+        cwd: process.cwd()
+    };
+    if (spawnResult.code !== 0 && throwOnNonZero) {
+        throw new SimpleSpawnError(`spawned process failed with code ${spawnResult.code}`, spawnResult);
+    }
+    return spawnResult;
+}
+export function whichInternal(commandName, simpleCmd, simpleSpawn) {
+    requireString('commandName', commandName);
+    if (stripShellMetaCharacters(commandName) !== commandName) {
+        throw new Error(`commandName cannot contain shell meta characters: ${commandName}`);
+    }
+    const execFunc = isPlatformWindows() ? simpleCmd : simpleSpawn;
+    const cmd = isPlatformWindows() ? 'where' : 'which';
+    const args = isPlatformWindows() ? [commandName] : ['-a', commandName];
+    try {
+        const result = execFunc(cmd, args);
+        if (result instanceof Promise) {
+            return result.then(parsedResult => ({
+                location: parsedResult.stdoutLines[0],
+                additionalLocations: parsedResult.stdoutLines.slice(1),
+                error: parsedResult.error
+            })).catch(err => ({
+                location: undefined,
+                additionalLocations: undefined,
+                error: err
+            }));
+        }
+        return {
+            location: result.stdoutLines[0],
+            additionalLocations: result.stdoutLines.slice(1),
+            error: result.error
+        };
+    }
+    catch (err) {
+        return {
+            location: undefined,
+            additionalLocations: undefined,
+            error: err
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generalUtilsInternal.js","sourceRoot":"","sources":["../../src/generalUtilsInternal.ts"],"names":[],"mappings":"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"}

package/dist/esm/hostsUtils.d.ts

@@ -0,0 +1,16 @@
+export declare function ensureHostsEntry(url: string): Promise<void>;
+export declare function removeHostsEntry(url: string): Promise<void>;
+export declare function getHostsPath(): string;
+export declare function getHostsFileString(): Promise<string>;
+export declare function hostsFileStringHasEntry(hostsFileString: string, entry: string): boolean;
+export declare function changeHostsFile(hostname: string, operation: 'add' | 'remove'): Promise<void>;
+/**
+ * The `initialString` will have line endings normalized to use os.EOL and lines with `omitLine` will be removed.
+ * Comparisons for which lines should be removed are normalizing whitespace (multiple spaces collapsed into single
+ * spaces for the comparison). This is useful to remove instances of a hosts entry, for example.
+ * @param initialString The string to normalize remove instances of omitLine from
+ * @param omitLine All instance of this string will be omitted from the result
+ * @returns A string that has instances of the omitLine removed and all line endings changed to match the os.EOL
+ */
+export declare function getEolNormalizedWithoutLine(initialString: string, omitLine: string): string;
+//# sourceMappingURL=hostsUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hostsUtils.d.ts","sourceRoot":"","sources":["../../src/hostsUtils.ts"],"names":[],"mappings":"AAIA,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAE1D;AAGD,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAKvF;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlG;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM3F"}

package/dist/esm/hostsUtils.js

@@ -0,0 +1,69 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import { getHostname, isPlatformWindows, log, requireString, stringToNonEmptyLines } from './generalUtils.js';
+export async function ensureHostsEntry(url) {
+    const hostname = getHostname(url);
+    await changeHostsFile(hostname, 'add');
+}
+export async function removeHostsEntry(url) {
+    const hostname = getHostname(url);
+    await changeHostsFile(hostname, 'remove');
+}
+export function getHostsPath() {
+    return isPlatformWindows() ? 'C:/Windows/System32/drivers/etc/hosts' : '/etc/hosts';
+}
+export async function getHostsFileString() {
+    return await fsp.readFile(getHostsPath(), { encoding: 'utf-8' });
+}
+// Check by normalizing whitespace (collapse consecutive spaces to single spaces) in entry and on each line checked
+export function hostsFileStringHasEntry(hostsFileString, entry) {
+    const normalizedEntry = entry.replace(/\s+/g, ' ');
+    const hostsLines = stringToNonEmptyLines(hostsFileString).map(l => l.replace(/\s+/g, ' ')).filter(l => !l.startsWith('#'));
+    const hasLine = hostsLines.includes(normalizedEntry);
+    return hasLine;
+}
+export async function changeHostsFile(hostname, operation) {
+    requireString('hostname', hostname);
+    const isAddition = operation === 'add';
+    const isRemoval = operation === 'remove';
+    const hostsPath = getHostsPath();
+    const entry = getNewHostsEntryString(hostname);
+    log(`checking hosts file: ${hostsPath} for entry ${entry}`);
+    const hostsFileString = await getHostsFileString();
+    const hasLine = hostsFileStringHasEntry(hostsFileString, entry);
+    if (isAddition && hasLine) {
+        log(`there is an existing entry in the hosts file (${entry}), skipping`);
+        return;
+    }
+    if (isRemoval && !hasLine) {
+        log(`there is no hosts entry to remove (${entry}), skipping`);
+    }
+    if (isAddition && !hasLine) {
+        log('existing entry not found - appending entry to the hosts file');
+        await fsp.appendFile(hostsPath, `\n${entry}`);
+    }
+    if (isRemoval && hasLine) {
+        log(`existing entry found - removing entry`);
+        const hostsWithoutEntry = getEolNormalizedWithoutLine(hostsFileString, entry);
+        await fsp.writeFile(hostsPath, hostsWithoutEntry);
+    }
+}
+/**
+ * The `initialString` will have line endings normalized to use os.EOL and lines with `omitLine` will be removed.
+ * Comparisons for which lines should be removed are normalizing whitespace (multiple spaces collapsed into single
+ * spaces for the comparison). This is useful to remove instances of a hosts entry, for example.
+ * @param initialString The string to normalize remove instances of omitLine from
+ * @param omitLine All instance of this string will be omitted from the result
+ * @returns A string that has instances of the omitLine removed and all line endings changed to match the os.EOL
+ */
+export function getEolNormalizedWithoutLine(initialString, omitLine) {
+    const normalizedOmitLine = omitLine.replace(/\s+/g, ' ');
+    const lines = initialString.split('\n')
+        .map(l => l.replace(/\r/g, ''))
+        .filter(l => l.replace(/\s+/g, ' ') !== normalizedOmitLine);
+    return lines.join(os.EOL);
+}
+function getNewHostsEntryString(hostname) {
+    return `127.0.0.1 ${hostname}`;
+}
+//# sourceMappingURL=data:application/json;base64,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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,151 @@
+// runWhileParentAlive.ts
+// Also referred to as "orphan protection" or "long running windows process workaround script"
+import { spawn, 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?.endsWith('\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('C:\\Windows\\system32\\tasklist.exe');
+        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 {
+        spawnSync(`C:\\Windows\\system32\\taskkill.exe /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: 'cmd.exe' });
+    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);
+        }
+        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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