@kubb/agent 4.28.0 → 4.29.0

package/.output/server/node_modules/execa/lib/resolve/stdio.js

@@ -1,47 +0,0 @@
-import {getStreamOutput} from '../io/contents.js';
-import {waitForStream, isInputFileDescriptor} from './wait-stream.js';
-
-// Read the contents of `subprocess.std*` and|or wait for its completion
-export const waitForStdioStreams = ({subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline, verboseInfo, streamInfo}) => subprocess.stdio.map((stream, fdNumber) => waitForSubprocessStream({
-	stream,
-	fdNumber,
-	encoding,
-	buffer: buffer[fdNumber],
-	maxBuffer: maxBuffer[fdNumber],
-	lines: lines[fdNumber],
-	allMixed: false,
-	stripFinalNewline,
-	verboseInfo,
-	streamInfo,
-}));
-
-// Read the contents of `subprocess.std*` or `subprocess.all` and|or wait for its completion
-export const waitForSubprocessStream = async ({stream, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline, verboseInfo, streamInfo}) => {
-	if (!stream) {
-		return;
-	}
-
-	const onStreamEnd = waitForStream(stream, fdNumber, streamInfo);
-	if (isInputFileDescriptor(streamInfo, fdNumber)) {
-		await onStreamEnd;
-		return;
-	}
-
-	const [output] = await Promise.all([
-		getStreamOutput({
-			stream,
-			onStreamEnd,
-			fdNumber,
-			encoding,
-			buffer,
-			maxBuffer,
-			lines,
-			allMixed,
-			stripFinalNewline,
-			verboseInfo,
-			streamInfo,
-		}),
-		onStreamEnd,
-	]);
-	return output;
-};

package/.output/server/node_modules/execa/lib/resolve/wait-stream.js

@@ -1,96 +0,0 @@
-import {finished} from 'node:stream/promises';
-
-// Wraps `finished(stream)` to handle the following case:
-//  - When the subprocess exits, Node.js automatically calls `subprocess.stdin.destroy()`, which we need to ignore.
-//  - However, we still need to throw if `subprocess.stdin.destroy()` is called before subprocess exit.
-export const waitForStream = async (stream, fdNumber, streamInfo, {isSameDirection, stopOnExit = false} = {}) => {
-	const state = handleStdinDestroy(stream, streamInfo);
-	const abortController = new AbortController();
-	try {
-		await Promise.race([
-			...(stopOnExit ? [streamInfo.exitPromise] : []),
-			finished(stream, {cleanup: true, signal: abortController.signal}),
-		]);
-	} catch (error) {
-		if (!state.stdinCleanedUp) {
-			handleStreamError(error, fdNumber, streamInfo, isSameDirection);
-		}
-	} finally {
-		abortController.abort();
-	}
-};
-
-// If `subprocess.stdin` is destroyed before being fully written to, it is considered aborted and should throw an error.
-// This can happen for example when user called `subprocess.stdin.destroy()` before `subprocess.stdin.end()`.
-// However, Node.js calls `subprocess.stdin.destroy()` on exit for cleanup purposes.
-// https://github.com/nodejs/node/blob/0b4cdb4b42956cbd7019058e409e06700a199e11/lib/internal/child_process.js#L278
-// This is normal and should not throw an error.
-// Therefore, we need to differentiate between both situations to know whether to throw an error.
-// Unfortunately, events (`close`, `error`, `end`, `exit`) cannot be used because `.destroy()` can take an arbitrary amount of time.
-// For example, `stdin: 'pipe'` is implemented as a TCP socket, and its `.destroy()` method waits for TCP disconnection.
-// Therefore `.destroy()` might end before or after subprocess exit, based on OS speed and load.
-// The only way to detect this is to spy on `subprocess.stdin._destroy()` by wrapping it.
-// If `subprocess.exitCode` or `subprocess.signalCode` is set, it means `.destroy()` is being called by Node.js itself.
-const handleStdinDestroy = (stream, {originalStreams: [originalStdin], subprocess}) => {
-	const state = {stdinCleanedUp: false};
-	if (stream === originalStdin) {
-		spyOnStdinDestroy(stream, subprocess, state);
-	}
-
-	return state;
-};
-
-const spyOnStdinDestroy = (subprocessStdin, subprocess, state) => {
-	const {_destroy} = subprocessStdin;
-	subprocessStdin._destroy = (...destroyArguments) => {
-		setStdinCleanedUp(subprocess, state);
-		_destroy.call(subprocessStdin, ...destroyArguments);
-	};
-};
-
-const setStdinCleanedUp = ({exitCode, signalCode}, state) => {
-	if (exitCode !== null || signalCode !== null) {
-		state.stdinCleanedUp = true;
-	}
-};
-
-// We ignore EPIPEs on writable streams and aborts on readable streams since those can happen normally.
-// When one stream errors, the error is propagated to the other streams on the same file descriptor.
-// Those other streams might have a different direction due to the above.
-// When this happens, the direction of both the initial stream and the others should then be taken into account.
-// Therefore, we keep track of whether a stream error is currently propagating.
-const handleStreamError = (error, fdNumber, streamInfo, isSameDirection) => {
-	if (!shouldIgnoreStreamError(error, fdNumber, streamInfo, isSameDirection)) {
-		throw error;
-	}
-};
-
-const shouldIgnoreStreamError = (error, fdNumber, streamInfo, isSameDirection = true) => {
-	if (streamInfo.propagating) {
-		return isStreamEpipe(error) || isStreamAbort(error);
-	}
-
-	streamInfo.propagating = true;
-	return isInputFileDescriptor(streamInfo, fdNumber) === isSameDirection
-		? isStreamEpipe(error)
-		: isStreamAbort(error);
-};
-
-// Unfortunately, we cannot use the stream's class or properties to know whether it is readable or writable.
-// For example, `subprocess.stdin` is technically a Duplex, but can only be used as a writable.
-// Therefore, we need to use the file descriptor's direction (`stdin` is input, `stdout` is output, etc.).
-// However, while `subprocess.std*` and transforms follow that direction, any stream passed the `std*` option has the opposite direction.
-// For example, `subprocess.stdin` is a writable, but the `stdin` option is a readable.
-export const isInputFileDescriptor = ({fileDescriptors}, fdNumber) => fdNumber !== 'all' && fileDescriptors[fdNumber].direction === 'input';
-
-// When `stream.destroy()` is called without an `error` argument, stream is aborted.
-// This is the only way to abort a readable stream, which can be useful in some instances.
-// Therefore, we ignore this error on readable streams.
-export const isStreamAbort = error => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
-
-// When `stream.write()` is called but the underlying source has been closed, `EPIPE` is emitted.
-// When piping subprocesses, the source subprocess usually decides when to stop piping.
-// However, there are some instances when the destination does instead, such as `... | head -n1`.
-// It notifies the source by using `EPIPE`.
-// Therefore, we ignore this error on writable streams.
-const isStreamEpipe = error => error?.code === 'EPIPE';

package/.output/server/node_modules/execa/lib/resolve/wait-subprocess.js

@@ -1,146 +0,0 @@
-import {once} from 'node:events';
-import {isStream as isNodeStream} from 'is-stream';
-import {throwOnTimeout} from '../terminate/timeout.js';
-import {throwOnCancel} from '../terminate/cancel.js';
-import {throwOnGracefulCancel} from '../terminate/graceful.js';
-import {isStandardStream} from '../utils/standard-stream.js';
-import {TRANSFORM_TYPES} from '../stdio/type.js';
-import {getBufferedData} from '../io/contents.js';
-import {waitForIpcOutput, getBufferedIpcOutput} from '../ipc/buffer-messages.js';
-import {sendIpcInput} from '../ipc/ipc-input.js';
-import {waitForAllStream} from './all-async.js';
-import {waitForStdioStreams} from './stdio.js';
-import {waitForExit, waitForSuccessfulExit} from './exit-async.js';
-import {waitForStream} from './wait-stream.js';
-
-// Retrieve result of subprocess: exit code, signal, error, streams (stdout/stderr/all)
-export const waitForSubprocessResult = async ({
-	subprocess,
-	options: {
-		encoding,
-		buffer,
-		maxBuffer,
-		lines,
-		timeoutDuration: timeout,
-		cancelSignal,
-		gracefulCancel,
-		forceKillAfterDelay,
-		stripFinalNewline,
-		ipc,
-		ipcInput,
-	},
-	context,
-	verboseInfo,
-	fileDescriptors,
-	originalStreams,
-	onInternalError,
-	controller,
-}) => {
-	const exitPromise = waitForExit(subprocess, context);
-	const streamInfo = {
-		originalStreams,
-		fileDescriptors,
-		subprocess,
-		exitPromise,
-		propagating: false,
-	};
-
-	const stdioPromises = waitForStdioStreams({
-		subprocess,
-		encoding,
-		buffer,
-		maxBuffer,
-		lines,
-		stripFinalNewline,
-		verboseInfo,
-		streamInfo,
-	});
-	const allPromise = waitForAllStream({
-		subprocess,
-		encoding,
-		buffer,
-		maxBuffer,
-		lines,
-		stripFinalNewline,
-		verboseInfo,
-		streamInfo,
-	});
-	const ipcOutput = [];
-	const ipcOutputPromise = waitForIpcOutput({
-		subprocess,
-		buffer,
-		maxBuffer,
-		ipc,
-		ipcOutput,
-		verboseInfo,
-	});
-	const originalPromises = waitForOriginalStreams(originalStreams, subprocess, streamInfo);
-	const customStreamsEndPromises = waitForCustomStreamsEnd(fileDescriptors, streamInfo);
-
-	try {
-		return await Promise.race([
-			Promise.all([
-				{},
-				waitForSuccessfulExit(exitPromise),
-				Promise.all(stdioPromises),
-				allPromise,
-				ipcOutputPromise,
-				sendIpcInput(subprocess, ipcInput),
-				...originalPromises,
-				...customStreamsEndPromises,
-			]),
-			onInternalError,
-			throwOnSubprocessError(subprocess, controller),
-			...throwOnTimeout(subprocess, timeout, context, controller),
-			...throwOnCancel({
-				subprocess,
-				cancelSignal,
-				gracefulCancel,
-				context,
-				controller,
-			}),
-			...throwOnGracefulCancel({
-				subprocess,
-				cancelSignal,
-				gracefulCancel,
-				forceKillAfterDelay,
-				context,
-				controller,
-			}),
-		]);
-	} catch (error) {
-		context.terminationReason ??= 'other';
-		return Promise.all([
-			{error},
-			exitPromise,
-			Promise.all(stdioPromises.map(stdioPromise => getBufferedData(stdioPromise))),
-			getBufferedData(allPromise),
-			getBufferedIpcOutput(ipcOutputPromise, ipcOutput),
-			Promise.allSettled(originalPromises),
-			Promise.allSettled(customStreamsEndPromises),
-		]);
-	}
-};
-
-// Transforms replace `subprocess.std*`, which means they are not exposed to users.
-// However, we still want to wait for their completion.
-const waitForOriginalStreams = (originalStreams, subprocess, streamInfo) =>
-	originalStreams.map((stream, fdNumber) => stream === subprocess.stdio[fdNumber]
-		? undefined
-		: waitForStream(stream, fdNumber, streamInfo));
-
-// Some `stdin`/`stdout`/`stderr` options create a stream, e.g. when passing a file path.
-// The `.pipe()` method automatically ends that stream when `subprocess` ends.
-// This makes sure we wait for the completion of those streams, in order to catch any error.
-const waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors.flatMap(({stdioItems}, fdNumber) => stdioItems
-	.filter(({value, stream = value}) => isNodeStream(stream, {checkOpen: false}) && !isStandardStream(stream))
-	.map(({type, value, stream = value}) => waitForStream(stream, fdNumber, streamInfo, {
-		isSameDirection: TRANSFORM_TYPES.has(type),
-		stopOnExit: type === 'native',
-	})));
-
-// Fails when the subprocess emits an `error` event
-const throwOnSubprocessError = async (subprocess, {signal}) => {
-	const [error] = await once(subprocess, 'error', {signal});
-	throw error;
-};

package/.output/server/node_modules/execa/lib/return/duration.js

@@ -1,8 +0,0 @@
-import {hrtime} from 'node:process';
-
-// Start counting time before spawning the subprocess
-export const getStartTime = () => hrtime.bigint();
-
-// Compute duration after the subprocess ended.
-// Printed by the `verbose` option.
-export const getDurationMs = startTime => Number(hrtime.bigint() - startTime) / 1e6;

package/.output/server/node_modules/execa/lib/return/early-error.js

@@ -1,60 +0,0 @@
-import {ChildProcess} from 'node:child_process';
-import {
-	PassThrough,
-	Readable,
-	Writable,
-	Duplex,
-} from 'node:stream';
-import {cleanupCustomStreams} from '../stdio/handle.js';
-import {makeEarlyError} from './result.js';
-import {handleResult} from './reject.js';
-
-// When the subprocess fails to spawn.
-// We ensure the returned error is always both a promise and a subprocess.
-export const handleEarlyError = ({error, command, escapedCommand, fileDescriptors, options, startTime, verboseInfo}) => {
-	cleanupCustomStreams(fileDescriptors);
-
-	const subprocess = new ChildProcess();
-	createDummyStreams(subprocess, fileDescriptors);
-	Object.assign(subprocess, {readable, writable, duplex});
-
-	const earlyError = makeEarlyError({
-		error,
-		command,
-		escapedCommand,
-		fileDescriptors,
-		options,
-		startTime,
-		isSync: false,
-	});
-	const promise = handleDummyPromise(earlyError, verboseInfo, options);
-	return {subprocess, promise};
-};
-
-const createDummyStreams = (subprocess, fileDescriptors) => {
-	const stdin = createDummyStream();
-	const stdout = createDummyStream();
-	const stderr = createDummyStream();
-	const extraStdio = Array.from({length: fileDescriptors.length - 3}, createDummyStream);
-	const all = createDummyStream();
-	const stdio = [stdin, stdout, stderr, ...extraStdio];
-	Object.assign(subprocess, {
-		stdin,
-		stdout,
-		stderr,
-		all,
-		stdio,
-	});
-};
-
-const createDummyStream = () => {
-	const stream = new PassThrough();
-	stream.end();
-	return stream;
-};
-
-const readable = () => new Readable({read() {}});
-const writable = () => new Writable({write() {}});
-const duplex = () => new Duplex({read() {}, write() {}});
-
-const handleDummyPromise = async (error, verboseInfo, options) => handleResult(error, verboseInfo, options);

package/.output/server/node_modules/execa/lib/return/final-error.js

@@ -1,40 +0,0 @@
-// When the subprocess fails, this is the error instance being returned.
-// If another error instance is being thrown, it is kept as `error.cause`.
-export const getFinalError = (originalError, message, isSync) => {
-	const ErrorClass = isSync ? ExecaSyncError : ExecaError;
-	const options = originalError instanceof DiscardedError ? {} : {cause: originalError};
-	return new ErrorClass(message, options);
-};
-
-// Indicates that the error is used only to interrupt control flow, but not in the return value
-export class DiscardedError extends Error {}
-
-// Proper way to set `error.name`: it should be inherited and non-enumerable
-const setErrorName = (ErrorClass, value) => {
-	Object.defineProperty(ErrorClass.prototype, 'name', {
-		value,
-		writable: true,
-		enumerable: false,
-		configurable: true,
-	});
-	Object.defineProperty(ErrorClass.prototype, execaErrorSymbol, {
-		value: true,
-		writable: false,
-		enumerable: false,
-		configurable: false,
-	});
-};
-
-// Unlike `instanceof`, this works across realms
-export const isExecaError = error => isErrorInstance(error) && execaErrorSymbol in error;
-
-const execaErrorSymbol = Symbol('isExecaError');
-
-export const isErrorInstance = value => Object.prototype.toString.call(value) === '[object Error]';
-
-// We use two different Error classes for async/sync methods since they have slightly different shape and types
-export class ExecaError extends Error {}
-setErrorName(ExecaError, ExecaError.name);
-
-export class ExecaSyncError extends Error {}
-setErrorName(ExecaSyncError, ExecaSyncError.name);

package/.output/server/node_modules/execa/lib/return/message.js

@@ -1,157 +0,0 @@
-import {inspect} from 'node:util';
-import stripFinalNewline from 'strip-final-newline';
-import {isUint8Array, uint8ArrayToString} from '../utils/uint-array.js';
-import {fixCwdError} from '../arguments/cwd.js';
-import {escapeLines} from '../arguments/escape.js';
-import {getMaxBufferMessage} from '../io/max-buffer.js';
-import {getSignalDescription} from '../terminate/signal.js';
-import {DiscardedError, isExecaError} from './final-error.js';
-
-// Computes `error.message`, `error.shortMessage` and `error.originalMessage`
-export const createMessages = ({
-	stdio,
-	all,
-	ipcOutput,
-	originalError,
-	signal,
-	signalDescription,
-	exitCode,
-	escapedCommand,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	forceKillAfterDelay,
-	killSignal,
-	maxBuffer,
-	timeout,
-	cwd,
-}) => {
-	const errorCode = originalError?.code;
-	const prefix = getErrorPrefix({
-		originalError,
-		timedOut,
-		timeout,
-		isMaxBuffer,
-		maxBuffer,
-		errorCode,
-		signal,
-		signalDescription,
-		exitCode,
-		isCanceled,
-		isGracefullyCanceled,
-		isForcefullyTerminated,
-		forceKillAfterDelay,
-		killSignal,
-	});
-	const originalMessage = getOriginalMessage(originalError, cwd);
-	const suffix = originalMessage === undefined ? '' : `\n${originalMessage}`;
-	const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
-	const messageStdio = all === undefined ? [stdio[2], stdio[1]] : [all];
-	const message = [
-		shortMessage,
-		...messageStdio,
-		...stdio.slice(3),
-		ipcOutput.map(ipcMessage => serializeIpcMessage(ipcMessage)).join('\n'),
-	]
-		.map(messagePart => escapeLines(stripFinalNewline(serializeMessagePart(messagePart))))
-		.filter(Boolean)
-		.join('\n\n');
-	return {originalMessage, shortMessage, message};
-};
-
-const getErrorPrefix = ({
-	originalError,
-	timedOut,
-	timeout,
-	isMaxBuffer,
-	maxBuffer,
-	errorCode,
-	signal,
-	signalDescription,
-	exitCode,
-	isCanceled,
-	isGracefullyCanceled,
-	isForcefullyTerminated,
-	forceKillAfterDelay,
-	killSignal,
-}) => {
-	const forcefulSuffix = getForcefulSuffix(isForcefullyTerminated, forceKillAfterDelay);
-
-	if (timedOut) {
-		return `Command timed out after ${timeout} milliseconds${forcefulSuffix}`;
-	}
-
-	if (isGracefullyCanceled) {
-		if (signal === undefined) {
-			return `Command was gracefully canceled with exit code ${exitCode}`;
-		}
-
-		return isForcefullyTerminated
-			? `Command was gracefully canceled${forcefulSuffix}`
-			: `Command was gracefully canceled with ${signal} (${signalDescription})`;
-	}
-
-	if (isCanceled) {
-		return `Command was canceled${forcefulSuffix}`;
-	}
-
-	if (isMaxBuffer) {
-		return `${getMaxBufferMessage(originalError, maxBuffer)}${forcefulSuffix}`;
-	}
-
-	if (errorCode !== undefined) {
-		return `Command failed with ${errorCode}${forcefulSuffix}`;
-	}
-
-	if (isForcefullyTerminated) {
-		return `Command was killed with ${killSignal} (${getSignalDescription(killSignal)})${forcefulSuffix}`;
-	}
-
-	if (signal !== undefined) {
-		return `Command was killed with ${signal} (${signalDescription})`;
-	}
-
-	if (exitCode !== undefined) {
-		return `Command failed with exit code ${exitCode}`;
-	}
-
-	return 'Command failed';
-};
-
-const getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated
-	? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds`
-	: '';
-
-const getOriginalMessage = (originalError, cwd) => {
-	if (originalError instanceof DiscardedError) {
-		return;
-	}
-
-	const originalMessage = isExecaError(originalError)
-		? originalError.originalMessage
-		: String(originalError?.message ?? originalError);
-	const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
-	return escapedOriginalMessage === '' ? undefined : escapedOriginalMessage;
-};
-
-const serializeIpcMessage = ipcMessage => typeof ipcMessage === 'string'
-	? ipcMessage
-	: inspect(ipcMessage);
-
-const serializeMessagePart = messagePart => Array.isArray(messagePart)
-	? messagePart.map(messageItem => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join('\n')
-	: serializeMessageItem(messagePart);
-
-const serializeMessageItem = messageItem => {
-	if (typeof messageItem === 'string') {
-		return messageItem;
-	}
-
-	if (isUint8Array(messageItem)) {
-		return uint8ArrayToString(messageItem);
-	}
-
-	return '';
-};

package/.output/server/node_modules/execa/lib/return/reject.js

@@ -1,13 +0,0 @@
-import {logResult} from '../verbose/complete.js';
-
-// Applies the `reject` option.
-// Also print the final log line with `verbose`.
-export const handleResult = (result, verboseInfo, {reject}) => {
-	logResult(result, verboseInfo);
-
-	if (result.failed && reject) {
-		throw result;
-	}
-
-	return result;
-};