@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/execa/lib/ipc/reference.js

@@ -0,0 +1,48 @@
+// By default, Node.js keeps the subprocess alive while it has a `message` or `disconnect` listener.
+// We replicate the same logic for the events that we proxy.
+// This ensures the subprocess is kept alive while `getOneMessage()` and `getEachMessage()` are ongoing.
+// This is not a problem with `sendMessage()` since Node.js handles that method automatically.
+// We do not use `anyProcess.channel.ref()` since this would prevent the automatic `.channel.refCounted()` Node.js is doing.
+// We keep a reference to `anyProcess.channel` since it might be `null` while `getOneMessage()` or `getEachMessage()` is still processing debounced messages.
+// See https://github.com/nodejs/node/blob/2aaeaa863c35befa2ebaa98fb7737ec84df4d8e9/lib/internal/child_process.js#L547
+export const addReference = (channel, reference) => {
+	if (reference) {
+		addReferenceCount(channel);
+	}
+};
+
+const addReferenceCount = channel => {
+	channel.refCounted();
+};
+
+export const removeReference = (channel, reference) => {
+	if (reference) {
+		removeReferenceCount(channel);
+	}
+};
+
+const removeReferenceCount = channel => {
+	channel.unrefCounted();
+};
+
+// To proxy events, we setup some global listeners on the `message` and `disconnect` events.
+// Those should not keep the subprocess alive, so we remove the automatic counting that Node.js is doing.
+// See https://github.com/nodejs/node/blob/1b965270a9c273d4cf70e8808e9d28b9ada7844f/lib/child_process.js#L180
+export const undoAddedReferences = (channel, isSubprocess) => {
+	if (!isSubprocess) {
+		return;
+	}
+
+	removeReferenceCount(channel);
+	removeReferenceCount(channel);
+};
+
+// Reverse it during `disconnect`
+export const redoAddedReferences = (channel, isSubprocess) => {
+	if (!isSubprocess) {
+		return;
+	}
+
+	addReferenceCount(channel);
+	addReferenceCount(channel);
+};

package/node_modules/execa/lib/ipc/send.js

@@ -0,0 +1,91 @@
+import {promisify} from 'node:util';
+import {
+	validateIpcMethod,
+	handleEpipeError,
+	handleSerializationError,
+	disconnect,
+} from './validation.js';
+import {startSendMessage, endSendMessage} from './outgoing.js';
+import {handleSendStrict, waitForStrictResponse} from './strict.js';
+
+// Like `[sub]process.send()` but promise-based.
+// We do not `await subprocess` during `.sendMessage()` nor `.getOneMessage()` since those methods are transient.
+// Users would still need to `await subprocess` after the method is done.
+// Also, this would prevent `unhandledRejection` event from being emitted, making it silent.
+export const sendMessage = ({anyProcess, channel, isSubprocess, ipc}, message, {strict = false} = {}) => {
+	const methodName = 'sendMessage';
+	validateIpcMethod({
+		methodName,
+		isSubprocess,
+		ipc,
+		isConnected: anyProcess.connected,
+	});
+
+	return sendMessageAsync({
+		anyProcess,
+		channel,
+		methodName,
+		isSubprocess,
+		message,
+		strict,
+	});
+};
+
+const sendMessageAsync = async ({anyProcess, channel, methodName, isSubprocess, message, strict}) => {
+	const wrappedMessage = handleSendStrict({
+		anyProcess,
+		channel,
+		isSubprocess,
+		message,
+		strict,
+	});
+	const outgoingMessagesState = startSendMessage(anyProcess, wrappedMessage, strict);
+	try {
+		await sendOneMessage({
+			anyProcess,
+			methodName,
+			isSubprocess,
+			wrappedMessage,
+			message,
+		});
+	} catch (error) {
+		disconnect(anyProcess);
+		throw error;
+	} finally {
+		endSendMessage(outgoingMessagesState);
+	}
+};
+
+// Used internally by `cancelSignal`
+export const sendOneMessage = async ({anyProcess, methodName, isSubprocess, wrappedMessage, message}) => {
+	const sendMethod = getSendMethod(anyProcess);
+
+	try {
+		await Promise.all([
+			waitForStrictResponse(wrappedMessage, anyProcess, isSubprocess),
+			sendMethod(wrappedMessage),
+		]);
+	} catch (error) {
+		handleEpipeError({error, methodName, isSubprocess});
+		handleSerializationError({
+			error,
+			methodName,
+			isSubprocess,
+			message,
+		});
+		throw error;
+	}
+};
+
+// [sub]process.send() promisified, memoized
+const getSendMethod = anyProcess => {
+	if (PROCESS_SEND_METHODS.has(anyProcess)) {
+		return PROCESS_SEND_METHODS.get(anyProcess);
+	}
+
+	const sendMethod = promisify(anyProcess.send.bind(anyProcess));
+	PROCESS_SEND_METHODS.set(anyProcess, sendMethod);
+	return sendMethod;
+};
+
+const PROCESS_SEND_METHODS = new WeakMap();

package/node_modules/execa/lib/ipc/strict.js

@@ -0,0 +1,113 @@
+import {once} from 'node:events';
+import {createDeferred} from '../utils/deferred.js';
+import {incrementMaxListeners} from '../utils/max-listeners.js';
+import {sendMessage} from './send.js';
+import {throwOnMissingStrict, throwOnStrictDisconnect, throwOnStrictDeadlockError} from './validation.js';
+import {getIpcEmitter} from './forward.js';
+import {hasMessageListeners} from './outgoing.js';
+
+// When using the `strict` option, wrap the message with metadata during `sendMessage()`
+export const handleSendStrict = ({anyProcess, channel, isSubprocess, message, strict}) => {
+	if (!strict) {
+		return message;
+	}
+
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
+	return {
+		id: count++,
+		type: REQUEST_TYPE,
+		message,
+		hasListeners,
+	};
+};
+
+let count = 0n;
+
+// Handles when both processes are calling `sendMessage()` with `strict` at the same time.
+// If neither process is listening, this would create a deadlock. We detect it and throw.
+export const validateStrictDeadlock = (outgoingMessages, wrappedMessage) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE || wrappedMessage.hasListeners) {
+		return;
+	}
+
+	for (const {id} of outgoingMessages) {
+		if (id !== undefined) {
+			STRICT_RESPONSES[id].resolve({isDeadlock: true, hasListeners: false});
+		}
+	}
+};
+
+// The other process then sends the acknowledgment back as a response
+export const handleStrictRequest = async ({wrappedMessage, anyProcess, channel, isSubprocess, ipcEmitter}) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE || !anyProcess.connected) {
+		return wrappedMessage;
+	}
+
+	const {id, message} = wrappedMessage;
+	const response = {id, type: RESPONSE_TYPE, message: hasMessageListeners(anyProcess, ipcEmitter)};
+
+	try {
+		await sendMessage({
+			anyProcess,
+			channel,
+			isSubprocess,
+			ipc: true,
+		}, response);
+	} catch (error) {
+		ipcEmitter.emit('strict:error', error);
+	}
+
+	return message;
+};
+
+// Reception of the acknowledgment response
+export const handleStrictResponse = wrappedMessage => {
+	if (wrappedMessage?.type !== RESPONSE_TYPE) {
+		return false;
+	}
+
+	const {id, message: hasListeners} = wrappedMessage;
+	STRICT_RESPONSES[id]?.resolve({isDeadlock: false, hasListeners});
+	return true;
+};
+
+// Wait for the other process to receive the message from `sendMessage()`
+export const waitForStrictResponse = async (wrappedMessage, anyProcess, isSubprocess) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE) {
+		return;
+	}
+
+	const deferred = createDeferred();
+	STRICT_RESPONSES[wrappedMessage.id] = deferred;
+	const controller = new AbortController();
+
+	try {
+		const {isDeadlock, hasListeners} = await Promise.race([
+			deferred,
+			throwOnDisconnect(anyProcess, isSubprocess, controller),
+		]);
+
+		if (isDeadlock) {
+			throwOnStrictDeadlockError(isSubprocess);
+		}
+
+		if (!hasListeners) {
+			throwOnMissingStrict(isSubprocess);
+		}
+	} finally {
+		controller.abort();
+		delete STRICT_RESPONSES[wrappedMessage.id];
+	}
+};
+
+const STRICT_RESPONSES = {};
+
+const throwOnDisconnect = async (anyProcess, isSubprocess, {signal}) => {
+	incrementMaxListeners(anyProcess, 1, signal);
+	await once(anyProcess, 'disconnect', {signal});
+	throwOnStrictDisconnect(isSubprocess);
+};
+
+const REQUEST_TYPE = 'execa:ipc:request';
+const RESPONSE_TYPE = 'execa:ipc:response';

package/node_modules/execa/lib/ipc/validation.js

@@ -0,0 +1,111 @@
+// Validate the IPC channel is connected before receiving/sending messages
+export const validateIpcMethod = ({methodName, isSubprocess, ipc, isConnected}) => {
+	validateIpcOption(methodName, isSubprocess, ipc);
+	validateConnection(methodName, isSubprocess, isConnected);
+};
+
+// Better error message when forgetting to set `ipc: true` and using the IPC methods
+const validateIpcOption = (methodName, isSubprocess, ipc) => {
+	if (!ipc) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} can only be used if the \`ipc\` option is \`true\`.`);
+	}
+};
+
+// Better error message when one process does not send/receive messages once the other process has disconnected.
+// This also makes it clear that any buffered messages are lost once either process has disconnected.
+// Also when aborting `cancelSignal` after disconnecting the IPC.
+export const validateConnection = (methodName, isSubprocess, isConnected) => {
+	if (!isConnected) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} has already exited or disconnected.`);
+	}
+};
+
+// When `getOneMessage()` could not complete due to an early disconnection
+export const throwOnEarlyDisconnect = isSubprocess => {
+	throw new Error(`${getMethodName('getOneMessage', isSubprocess)} could not complete: the ${getOtherProcessName(isSubprocess)} exited or disconnected.`);
+};
+
+// When both processes use `sendMessage()` with `strict` at the same time
+export const throwOnStrictDeadlockError = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is sending a message too, instead of listening to incoming messages.
+This can be fixed by both sending a message and listening to incoming messages at the same time:
+
+const [receivedMessage] = await Promise.all([
+	${getMethodName('getOneMessage', isSubprocess)},
+	${getMethodName('sendMessage', isSubprocess, 'message, {strict: true}')},
+]);`);
+};
+
+// When the other process used `strict` but the current process had I/O error calling `sendMessage()` for the response
+export const getStrictResponseError = (error, isSubprocess) => new Error(`${getMethodName('sendMessage', isSubprocess)} failed when sending an acknowledgment response to the ${getOtherProcessName(isSubprocess)}.`, {cause: error});
+
+// When using `strict` but the other process was not listening for messages
+export const throwOnMissingStrict = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is not listening to incoming messages.`);
+};
+
+// When using `strict` but the other process disconnected before receiving the message
+export const throwOnStrictDisconnect = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} exited without listening to incoming messages.`);
+};
+
+// When the current process disconnects while the subprocess is listening to `cancelSignal`
+export const getAbortDisconnectError = () => new Error(`\`cancelSignal\` aborted: the ${getOtherProcessName(true)} disconnected.`);
+
+// When the subprocess uses `cancelSignal` but not the current process
+export const throwOnMissingParent = () => {
+	throw new Error('`getCancelSignal()` cannot be used without setting the `cancelSignal` subprocess option.');
+};
+
+// EPIPE can happen when sending a message to a subprocess that is closing but has not disconnected yet
+export const handleEpipeError = ({error, methodName, isSubprocess}) => {
+	if (error.code === 'EPIPE') {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} is disconnecting.`, {cause: error});
+	}
+};
+
+// Better error message when sending messages which cannot be serialized.
+// Works with both `serialization: 'advanced'` and `serialization: 'json'`.
+export const handleSerializationError = ({error, methodName, isSubprocess, message}) => {
+	if (isSerializationError(error)) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)}'s argument type is invalid: the message cannot be serialized: ${String(message)}.`, {cause: error});
+	}
+};
+
+const isSerializationError = ({code, message}) => SERIALIZATION_ERROR_CODES.has(code)
+	|| SERIALIZATION_ERROR_MESSAGES.some(serializationErrorMessage => message.includes(serializationErrorMessage));
+
+// `error.code` set by Node.js when it failed to serialize the message
+const SERIALIZATION_ERROR_CODES = new Set([
+	// Message is `undefined`
+	'ERR_MISSING_ARGS',
+	// Message is a function, a bigint, a symbol
+	'ERR_INVALID_ARG_TYPE',
+]);
+
+// `error.message` set by Node.js when it failed to serialize the message
+const SERIALIZATION_ERROR_MESSAGES = [
+	// Message is a promise or a proxy, with `serialization: 'advanced'`
+	'could not be cloned',
+	// Message has cycles, with `serialization: 'json'`
+	'circular structure',
+	// Message has cycles inside toJSON(), with `serialization: 'json'`
+	'call stack size exceeded',
+];
+
+const getMethodName = (methodName, isSubprocess, parameters = '') => methodName === 'cancelSignal'
+	? '`cancelSignal`\'s `controller.abort()`'
+	: `${getNamespaceName(isSubprocess)}${methodName}(${parameters})`;
+
+const getNamespaceName = isSubprocess => isSubprocess ? '' : 'subprocess.';
+
+const getOtherProcessName = isSubprocess => isSubprocess ? 'parent process' : 'subprocess';
+
+// When any error arises, we disconnect the IPC.
+// Otherwise, it is likely that one of the processes will stop sending/receiving messages.
+// This would leave the other process hanging.
+export const disconnect = anyProcess => {
+	if (anyProcess.connected) {
+		anyProcess.disconnect();
+	}
+};

package/node_modules/execa/lib/methods/bind.js

@@ -0,0 +1,23 @@
+import isPlainObject from 'is-plain-obj';
+import {FD_SPECIFIC_OPTIONS} from '../arguments/specific.js';
+
+// Deep merge specific options like `env`. Shallow merge the other ones.
+// Use spread (which only copies own properties) to safely read from boundOptions without prototype pollution
+export const mergeOptions = (boundOptions, options) => {
+	const safeBoundOptions = {__proto__: null, ...boundOptions};
+	const mergedOptions = Object.fromEntries(Object.entries(options).map(([optionName, optionValue]) => [
+		optionName,
+		mergeOption(optionName, safeBoundOptions[optionName], optionValue),
+	]));
+	return {...safeBoundOptions, ...mergedOptions};
+};
+
+const mergeOption = (optionName, boundOptionValue, optionValue) => {
+	if (DEEP_OPTIONS.has(optionName) && isPlainObject(boundOptionValue) && isPlainObject(optionValue)) {
+		return {...boundOptionValue, ...optionValue};
+	}
+
+	return optionValue;
+};
+
+const DEEP_OPTIONS = new Set(['env', ...FD_SPECIFIC_OPTIONS]);

package/node_modules/execa/lib/methods/command.js

@@ -0,0 +1,27 @@
+// Convert `command` string into an array of file or arguments to pass to $`${...fileOrCommandArguments}`
+export const parseCommandString = command => {
+	if (typeof command !== 'string') {
+		throw new TypeError(`The command must be a string: ${String(command)}.`);
+	}
+
+	const trimmedCommand = command.trim();
+	if (trimmedCommand === '') {
+		return [];
+	}
+
+	const tokens = [];
+	for (const token of trimmedCommand.split(SPACES_REGEXP)) {
+		// Allow spaces to be escaped by a backslash if not meant as a delimiter
+		const previousToken = tokens.at(-1);
+		if (previousToken && previousToken.endsWith('\\')) {
+			// Merge previous token with current one
+			tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+		} else {
+			tokens.push(token);
+		}
+	}
+
+	return tokens;
+};
+
+const SPACES_REGEXP = / +/g;

package/node_modules/execa/lib/methods/create.js

@@ -0,0 +1,63 @@
+import isPlainObject from 'is-plain-obj';
+import {normalizeParameters} from './parameters.js';
+import {isTemplateString, parseTemplates} from './template.js';
+import {execaCoreSync} from './main-sync.js';
+import {execaCoreAsync} from './main-async.js';
+import {mergeOptions} from './bind.js';
+
+// Wraps every exported methods to provide the following features:
+//  - template string syntax: execa`command argument`
+//  - options binding: boundExeca = execa(options)
+//  - optional argument/options: execa(file), execa(file, args), execa(file, options), execa(file, args, options)
+// `mapArguments()` and `setBoundExeca()` allows for method-specific logic.
+export const createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
+	const createNested = (mapArguments, boundOptions, setBoundExeca) => createExeca(mapArguments, boundOptions, deepOptions, setBoundExeca);
+	const boundExeca = (...execaArguments) => callBoundExeca({
+		mapArguments,
+		deepOptions,
+		boundOptions,
+		setBoundExeca,
+		createNested,
+	}, ...execaArguments);
+
+	if (setBoundExeca !== undefined) {
+		setBoundExeca(boundExeca, createNested, boundOptions);
+	}
+
+	return boundExeca;
+};
+
+const callBoundExeca = ({mapArguments, deepOptions = {}, boundOptions = {}, setBoundExeca, createNested}, firstArgument, ...nextArguments) => {
+	if (isPlainObject(firstArgument)) {
+		return createNested(mapArguments, mergeOptions(boundOptions, firstArgument), setBoundExeca);
+	}
+
+	const {file, commandArguments, options, isSync} = parseArguments({
+		mapArguments,
+		firstArgument,
+		nextArguments,
+		deepOptions,
+		boundOptions,
+	});
+	return isSync
+		? execaCoreSync(file, commandArguments, options)
+		: execaCoreAsync(file, commandArguments, options, createNested);
+};
+
+const parseArguments = ({mapArguments, firstArgument, nextArguments, deepOptions, boundOptions}) => {
+	const callArguments = isTemplateString(firstArgument)
+		? parseTemplates(firstArgument, nextArguments)
+		: [firstArgument, ...nextArguments];
+	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
+	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
+	const {
+		options = mergedOptions,
+		isSync = false,
+	} = mapArguments({options: mergedOptions});
+	return {
+		file: initialFile,
+		commandArguments: initialArguments,
+		options,
+		isSync,
+	};
+};