@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/utils/consume-messages-from-socket.js

@@ -1,291 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageFramingError = exports.DEFAULT_MAX_MESSAGE_SIZE = exports.MESSAGE_HEADER_PREFIX = void 0;
-exports.getMaxMessageSize = getMaxMessageSize;
-exports.frameHeader = frameHeader;
-exports.writeMessage = writeMessage;
-exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
-exports.isJsonMessage = isJsonMessage;
-exports.describeMessage = describeMessage;
-exports.parseMessage = parseMessage;
-const v8_1 = require("v8");
-exports.MESSAGE_HEADER_PREFIX = 'NX_MSG_';
-const MESSAGE_HEADER_TERMINATOR = ':'.charCodeAt(0);
-const MESSAGE_HEADER_PREFIX_BYTES = Buffer.from(exports.MESSAGE_HEADER_PREFIX, 'ascii');
-// `Number.MAX_SAFE_INTEGER` is 16 digits, so a longer run of digits than that
-// is a desynchronized stream rather than a very large message.
-const MAX_HEADER_LENGTH = exports.MESSAGE_HEADER_PREFIX.length + 16 + 1;
-/**
- * Ceiling on a single message, in bytes. Payloads are buffered outside the V8
- * heap, so `--max-old-space-size` does not bound them and a peer that declares
- * a huge length would otherwise be allowed to stream until the machine gives
- * out. The default is four times the ~0.5GiB string ceiling that used to cap
- * every message, so it clears any payload that previously worked or was meant
- * to. Set `NX_MAX_MESSAGE_SIZE` to another byte count to change it, or to 0 to
- * remove the ceiling. The daemon reads it from the env it was spawned with —
- * clients do not reflect it (see DAEMON_ENV_VARS_EXCLUSIONS) — so changing it
- * needs a daemon restart (`nx reset`).
- */
-exports.DEFAULT_MAX_MESSAGE_SIZE = 2 * 1024 * 1024 * 1024;
-function getMaxMessageSize() {
-    const configured = process.env.NX_MAX_MESSAGE_SIZE;
-    if (configured === undefined || configured === '') {
-        return exports.DEFAULT_MAX_MESSAGE_SIZE;
-    }
-    const parsed = Number(configured);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        console.warn(`NX_MAX_MESSAGE_SIZE must be a non-negative number of bytes, but was "${configured}". Using the default of ${exports.DEFAULT_MAX_MESSAGE_SIZE}.`);
-        return exports.DEFAULT_MAX_MESSAGE_SIZE;
-    }
-    return parsed;
-}
-/**
- * `nx reset` only helps while a daemon is enabled: it and its plugin workers keep the
- * limit they were spawned with, and the var is excluded from the daemon env hash so
- * changing it restarts nothing. Every other reader re-reads the env per invocation.
- * Required lazily because the daemon client imports this module.
- */
-function daemonHoldsItsOwnLimit() {
-    try {
-        return require('../daemon/client/client').daemonClient.enabled();
-    }
-    catch {
-        return true;
-    }
-}
-const ZERO = '0'.charCodeAt(0);
-const NINE = '9'.charCodeAt(0);
-function frameHeader(payloadLength) {
-    return Buffer.from(`${exports.MESSAGE_HEADER_PREFIX}${payloadLength}:`, 'ascii');
-}
-/**
- * Writes a length-prefixed message. The header and payload are written
- * separately so a large payload is never copied to prepend its header.
- */
-function writeMessage(socket, payload, callback) {
-    socket.write(frameHeader(payload.length));
-    socket.write(payload, callback);
-}
-class MessageFramingError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'MessageFramingError';
-        Object.setPrototypeOf(this, MessageFramingError.prototype);
-    }
-}
-exports.MessageFramingError = MessageFramingError;
-function consumeMessagesFromSocket(callback, onError = (error) => {
-    console.error(error.message);
-}) {
-    let chunks = [];
-    let buffered = 0;
-    let expectedPayloadLength = null;
-    let broken = false;
-    // Read once per socket so a test or a caller can change it between
-    // connections without paying the lookup on every frame.
-    const maxMessageSize = getMaxMessageSize();
-    const fail = (message) => {
-        broken = true;
-        chunks = [];
-        buffered = 0;
-        expectedPayloadLength = null;
-        onError(new MessageFramingError(message));
-    };
-    // Copies at most `length` leading bytes without collapsing the chunk list.
-    const peek = (length) => {
-        const size = Math.min(length, buffered);
-        if (chunks.length === 1) {
-            return chunks[0].subarray(0, size);
-        }
-        const out = Buffer.allocUnsafe(size);
-        let offset = 0;
-        for (const chunk of chunks) {
-            if (offset >= size)
-                break;
-            offset += chunk.copy(out, offset, 0, Math.min(chunk.length, size - offset));
-        }
-        return out;
-    };
-    const take = (length) => {
-        if (length === 0) {
-            return Buffer.alloc(0);
-        }
-        // A socket chunk usually carries several whole messages, so slice the
-        // leading one out in place rather than allocating and copying for each.
-        // The payload is parsed by the callback before the next read, so sharing
-        // the chunk's memory does not retain it.
-        if (chunks[0].length === length) {
-            buffered -= length;
-            return chunks.shift();
-        }
-        if (chunks[0].length > length) {
-            const out = chunks[0].subarray(0, length);
-            chunks[0] = chunks[0].subarray(length);
-            buffered -= length;
-            return out;
-        }
-        const out = Buffer.allocUnsafe(length);
-        let offset = 0;
-        while (offset < length) {
-            const chunk = chunks[0];
-            const needed = length - offset;
-            if (chunk.length <= needed) {
-                chunk.copy(out, offset);
-                offset += chunk.length;
-                chunks.shift();
-            }
-            else {
-                chunk.copy(out, offset, 0, needed);
-                chunks[0] = chunk.subarray(needed);
-                offset = length;
-            }
-        }
-        buffered -= length;
-        return out;
-    };
-    const discard = (length) => {
-        let remaining = length;
-        while (remaining > 0) {
-            const chunk = chunks[0];
-            if (chunk.length <= remaining) {
-                remaining -= chunk.length;
-                chunks.shift();
-            }
-            else {
-                chunks[0] = chunk.subarray(remaining);
-                remaining = 0;
-            }
-        }
-        buffered -= length;
-    };
-    // Returns the payload length, or null when the header is still incomplete.
-    const readHeader = () => {
-        const head = peek(MAX_HEADER_LENGTH);
-        for (let i = 0; i < MESSAGE_HEADER_PREFIX_BYTES.length; i++) {
-            if (i >= head.length)
-                return null;
-            if (head[i] !== MESSAGE_HEADER_PREFIX_BYTES[i]) {
-                fail(`Expected a message to begin with '${exports.MESSAGE_HEADER_PREFIX}' but received ` +
-                    `${JSON.stringify(head.toString('utf8', 0, 32))}. The stream is out of sync.`);
-                return null;
-            }
-        }
-        let digits = 0;
-        let value = 0;
-        for (let i = MESSAGE_HEADER_PREFIX_BYTES.length; i < head.length; i++) {
-            const byte = head[i];
-            if (byte === MESSAGE_HEADER_TERMINATOR) {
-                if (digits === 0) {
-                    fail(`Message header carried no length.`);
-                    return null;
-                }
-                if (maxMessageSize > 0 && value > maxMessageSize) {
-                    fail(`Message of ${value} bytes exceeds the ${maxMessageSize} byte limit. ` +
-                        `Set NX_MAX_MESSAGE_SIZE to raise it, or to 0 to remove it.` +
-                        (daemonHoldsItsOwnLimit()
-                            ? ` Then run \`nx reset\`, since a running daemon and the plugin workers it spawns keep the limit they started with.`
-                            : ''));
-                    return null;
-                }
-                discard(i + 1);
-                return value;
-            }
-            if (byte < ZERO || byte > NINE) {
-                fail(`Message header contained a non-digit length. The stream is out of sync.`);
-                return null;
-            }
-            value = value * 10 + (byte - ZERO);
-            digits++;
-        }
-        if (head.length >= MAX_HEADER_LENGTH) {
-            fail(`Message header exceeded ${MAX_HEADER_LENGTH} bytes without a ':'.`);
-        }
-        return null;
-    };
-    return (data) => {
-        if (broken) {
-            return;
-        }
-        chunks.push(data);
-        buffered += data.length;
-        while (!broken) {
-            if (expectedPayloadLength === null) {
-                const length = readHeader();
-                if (length === null)
-                    break;
-                expectedPayloadLength = length;
-            }
-            if (expectedPayloadLength === 0) {
-                fail('Message header declared a zero-length payload.');
-                break;
-            }
-            if (buffered < expectedPayloadLength)
-                break;
-            const payload = take(expectedPayloadLength);
-            expectedPayloadLength = null;
-            callback(payload);
-        }
-    };
-}
-/**
- * v8-serialized payloads always begin with the 0xFF version header, which no
- * JSON document can start with.
- */
-function isJsonMessage(message) {
-    return message.length === 0 || message[0] !== 0xff;
-}
-/**
- * Widest slice of `window` that holds only whole utf8 characters. Cutting at an
- * arbitrary byte leaves a partial sequence, and a partial sequence decodes to
- * U+FFFD, which is the corruption `describeMessage` exists to avoid. A slice
- * taken from the end can also begin mid-character, so both edges are trimmed.
- */
-function trimToCharBoundary(window, from) {
-    const isContinuation = (byte) => (byte & 0xc0) === 0x80;
-    if (from === 'end') {
-        let offset = 0;
-        while (offset < window.length && isContinuation(window[offset])) {
-            offset++;
-        }
-        return window.subarray(offset);
-    }
-    let lead = window.length - 1;
-    while (lead >= 0 && isContinuation(window[lead])) {
-        lead--;
-    }
-    if (lead < 0) {
-        return window.subarray(0, 0);
-    }
-    const byte = window[lead];
-    const width = byte >= 0xf0 ? 4 : byte >= 0xe0 ? 3 : byte >= 0xc0 ? 2 : 1;
-    // Keep the trailing sequence only when the cut did not land inside it.
-    return lead + width <= window.length ? window : window.subarray(0, lead);
-}
-/**
- * Render part of a message for an error message. A v8 payload is binary rather
- * than utf8 text — its 0xFF header alone can never decode — so it is rendered
- * as hex instead of as U+FFFD-riddled mojibake.
- */
-function describeMessage(message, { maxBytes = 300, from = 'start' } = {}) {
-    const json = isJsonMessage(message);
-    const window = from === 'end'
-        ? message.subarray(Math.max(0, message.length - maxBytes))
-        : message.subarray(0, maxBytes);
-    const slice = json ? trimToCharBoundary(window, from) : window;
-    const elided = message.length - slice.length;
-    return [
-        `${json ? 'json' : 'v8'}, ${message.length} bytes` +
-            (elided > 0
-                ? `, ${from === 'end' ? 'last' : 'first'} ${slice.length} shown`
-                : ''),
-        json ? slice.toString('utf8') : slice.toString('hex'),
-    ].join('\n');
-}
-/**
- * Parse a message produced by `serialize()` in `daemon/socket-utils.ts`.
- */
-function parseMessage(message) {
-    return isJsonMessage(message)
-        ? JSON.parse(message.toString('utf8'))
-        : (0, v8_1.deserialize)(message);
-}

package/dist/src/utils/db-connection.d.ts

@@ -1,14 +0,0 @@
-import { ExternalObject } from '../native';
-export declare function getDbConnection(opts?: {
-    directory?: string;
-    dbName?: string;
-}): ExternalObject<any>;
-/**
- * Returns a DB connection scoped to the local worktree (not shared).
- * Use this for data that is inherently local to a worktree, such as
- * running task tracking, where sharing across worktrees would cause
- * false conflicts.
- */
-export declare function getLocalDbConnection(opts?: {
-    dbName?: string;
-}): ExternalObject<any>;

package/dist/src/utils/db-connection.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDbConnection = getDbConnection;
-exports.getLocalDbConnection = getLocalDbConnection;
-const native_1 = require("../native");
-const cache_directory_1 = require("./cache-directory");
-const workspace_root_1 = require("./workspace-root");
-const dbConnectionMap = new Map();
-/**
- * Where the shared DB lives, resolved once per process.
- *
- * The DB is the only thing that uses the shared `workspace-data` directory --
- * daemon logs and the `disabled` marker stay in the checkout's own, because
- * they describe that checkout. Sharing is not decided here: this DB indexes the
- * cache directory's contents, so the two have to land in the same scope or a
- * cache hit resolves to artifacts that were never written here.
- */
-let _sharedDir;
-function sharedWorkspaceDataDirectory(root) {
-    _sharedDir ??= (0, cache_directory_1.sharedDataDirectory)(root, 'workspace-data');
-    return _sharedDir;
-}
-function getDbConnection(opts = {}) {
-    opts.directory ??= sharedWorkspaceDataDirectory(workspace_root_1.workspaceRoot);
-    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
-    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, opts.dbName));
-    return connection;
-}
-/**
- * Returns a DB connection scoped to the local worktree (not shared).
- * Use this for data that is inherently local to a worktree, such as
- * running task tracking, where sharing across worktrees would cause
- * false conflicts.
- */
-function getLocalDbConnection(opts = {}) {
-    const directory = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspace_root_1.workspaceRoot);
-    const key = `${directory}:${opts.dbName ?? 'default'}`;
-    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(directory, opts.dbName));
-    return connection;
-}
-function removeDbConnections() {
-    for (const connection of dbConnectionMap.values()) {
-        (0, native_1.closeDbConnection)(connection);
-    }
-    dbConnectionMap.clear();
-}
-process.on('exit', removeDbConnections);
-function getEntryOrSet(map, key, defaultValue) {
-    const existing = map.get(key);
-    if (existing) {
-        return existing;
-    }
-    const val = defaultValue();
-    map.set(key, val);
-    return val;
-}

package/dist/src/utils/default-base.d.ts

@@ -1 +0,0 @@
-export declare function deduceDefaultBase(): string;

package/dist/src/utils/default-base.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deduceDefaultBase = deduceDefaultBase;
-const child_process_1 = require("child_process");
-function deduceDefaultBase() {
-    const nxDefaultBase = 'main';
-    try {
-        return ((0, child_process_1.execSync)('git config --get init.defaultBranch', {
-            windowsHide: true,
-        })
-            .toString()
-            .trim() || nxDefaultBase);
-    }
-    catch {
-        return nxDefaultBase;
-    }
-}

package/dist/src/utils/delayed-spinner.d.ts

@@ -1,51 +0,0 @@
-import { ProgressTopic } from './progress-topics';
-import { globalSpinner } from './spinner';
-export type DelayedSpinnerOptions = {
-    delay?: number;
-    ciDelay?: number;
-    /**
-     * When set and running inside the Nx daemon, spinner messages are
-     * broadcast to every client currently subscribed to this topic so
-     * their own spinners stay in sync with daemon-side progress.
-     */
-    progressTopic?: ProgressTopic;
-};
-/**
- * A class that allows to delay the creation of a spinner, as well
- * as schedule updates to the message of the spinner. Useful for
- * scenarios where one wants to only show a spinner if an operation
- * takes longer than a certain amount of time.
- */
-export declare class DelayedSpinner {
-    spinner: typeof globalSpinner;
-    timeouts: NodeJS.Timeout[];
-    private lastMessage;
-    private ready;
-    private readonly progressTopic;
-    /**
-     * Constructs a new {@link DelayedSpinner} instance.
-     *
-     * @param opts The options for the spinner
-     */
-    constructor(message: string, opts?: DelayedSpinnerOptions);
-    /**
-     * Sets the message to display in the spinner.
-     *
-     * @param message The message to display in the spinner
-     * @returns The {@link DelayedSpinner} instance
-     */
-    setMessage(message: string): this;
-    /**
-     * Schedules an update to the message of the spinner. Useful for
-     * changing the message after a certain amount of time has passed.
-     *
-     * @param opts The options for the update
-     * @returns The {@link DelayedSpinner} instance
-     */
-    scheduleMessageUpdate(message: string, opts?: DelayedSpinnerOptions): this;
-    /**
-     * Stops the spinner and cleans up any scheduled timeouts.
-     */
-    cleanup(): void;
-    private broadcastProgress;
-}

package/dist/src/utils/delayed-spinner.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DelayedSpinner = void 0;
-const is_on_daemon_1 = require("../daemon/is-on-daemon");
-const client_socket_context_1 = require("../daemon/server/client-socket-context");
-const spinner_1 = require("./spinner");
-/**
- * A class that allows to delay the creation of a spinner, as well
- * as schedule updates to the message of the spinner. Useful for
- * scenarios where one wants to only show a spinner if an operation
- * takes longer than a certain amount of time.
- */
-class DelayedSpinner {
-    /**
-     * Constructs a new {@link DelayedSpinner} instance.
-     *
-     * @param opts The options for the spinner
-     */
-    constructor(message, opts) {
-        this.timeouts = [];
-        opts = normalizeDelayedSpinnerOpts(opts);
-        this.progressTopic = opts.progressTopic;
-        const delay = spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay;
-        this.lastMessage = message;
-        this.broadcastProgress(message);
-        this.timeouts.push(setTimeout(() => {
-            this.ready = true;
-            if (!spinner_1.SHOULD_SHOW_SPINNERS) {
-                console.warn(this.lastMessage);
-            }
-            else if (!spinner_1.globalSpinner.isSpinning()) {
-                this.spinner = spinner_1.globalSpinner.start(this.lastMessage);
-            }
-        }, delay).unref());
-    }
-    /**
-     * Sets the message to display in the spinner.
-     *
-     * @param message The message to display in the spinner
-     * @returns The {@link DelayedSpinner} instance
-     */
-    setMessage(message) {
-        if (spinner_1.SHOULD_SHOW_SPINNERS) {
-            if (this.spinner && this.ready) {
-                this.spinner.updateText(message);
-            }
-        }
-        else if (this.ready && this.lastMessage && this.lastMessage !== message) {
-            console.warn(message);
-        }
-        this.broadcastProgress(message);
-        this.lastMessage = message;
-        return this;
-    }
-    /**
-     * Schedules an update to the message of the spinner. Useful for
-     * changing the message after a certain amount of time has passed.
-     *
-     * @param opts The options for the update
-     * @returns The {@link DelayedSpinner} instance
-     */
-    scheduleMessageUpdate(message, opts) {
-        opts = normalizeDelayedSpinnerOpts(opts);
-        this.timeouts.push(setTimeout(() => {
-            this.setMessage(message);
-        }, spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay).unref());
-        return this;
-    }
-    /**
-     * Stops the spinner and cleans up any scheduled timeouts.
-     */
-    cleanup() {
-        this.spinner?.stop();
-        this.timeouts.forEach((t) => clearTimeout(t));
-    }
-    broadcastProgress(message) {
-        if (this.progressTopic && (0, is_on_daemon_1.isOnDaemon)()) {
-            (0, client_socket_context_1.sendProgressMessageToTopic)(this.progressTopic, message);
-        }
-    }
-}
-exports.DelayedSpinner = DelayedSpinner;
-function normalizeDelayedSpinnerOpts(opts) {
-    opts ??= {};
-    opts.delay ??= 500;
-    opts.ciDelay ??= 30_000;
-    return opts;
-}

package/dist/src/utils/dotenv.d.ts

@@ -1,7 +0,0 @@
-/**
- * This loads dotenv files from:
- * - .env
- * - .local.env
- * - .env.local
- */
-export declare function loadRootEnvFiles(root?: string): void;

package/dist/src/utils/dotenv.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRootEnvFiles = loadRootEnvFiles;
-const dotenv_1 = require("dotenv");
-const dotenv_expand_1 = require("dotenv-expand");
-const workspace_root_1 = require("./workspace-root");
-const path_1 = require("path");
-/**
- * This loads dotenv files from:
- * - .env
- * - .local.env
- * - .env.local
- */
-function loadRootEnvFiles(root = workspace_root_1.workspaceRoot) {
-    const myEnv = (0, dotenv_1.config)({
-        path: ['.local.env', '.env.local', '.env'].map((file) => (0, path_1.join)(root, file)),
-    });
-    (0, dotenv_expand_1.expand)(myEnv);
-}

package/dist/src/utils/enable-compile-cache.d.ts

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

package/dist/src/utils/enable-compile-cache.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Side-effect-only module: import this as the *first* import in any nx
-// process entry point so V8's compile cache is enabled before the rest of
-// the import chain (which is what we actually want to cache) starts loading.
-const compile_cache_1 = require("./compile-cache");
-(0, compile_cache_1.enableCompileCache)();

package/dist/src/utils/exit-codes.d.ts

@@ -1,24 +0,0 @@
-/**
- * Translates NodeJS signals to numeric exit code
- * @param signal
- */
-export declare function signalToCode(signal: NodeJS.Signals | null): number;
-/**
- * Translates numeric exit codes to NodeJS signals
- */
-export declare function codeToSignal(code: number): NodeJS.Signals;
-export declare const EXPECTED_TERMINATION_SIGNALS: Set<number>;
-/**
- * Translates a pty exit message (e.g. "Terminated by Interrupt") to a numeric exit code.
- * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
- */
-export declare function messageToCode(message: string): number;
-/**
- * Ends the process the way an interrupted process ends: by SIGINT, not by
- * exiting with its conventional code.
- *
- * A shell reports 130 either way, but a parent using waitpid sees
- * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
- * check to tell "the user pressed Ctrl+C" from "the command failed".
- */
-export declare function exitAsInterrupted(): never;

package/dist/src/utils/exit-codes.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXPECTED_TERMINATION_SIGNALS = void 0;
-exports.signalToCode = signalToCode;
-exports.codeToSignal = codeToSignal;
-exports.messageToCode = messageToCode;
-exports.exitAsInterrupted = exitAsInterrupted;
-/**
- * Translates NodeJS signals to numeric exit code
- * @param signal
- */
-function signalToCode(signal) {
-    switch (signal) {
-        case 'SIGHUP':
-            return 128 + 1;
-        case 'SIGINT':
-            return 128 + 2;
-        case 'SIGTERM':
-            return 128 + 15;
-        case 'SIGQUIT':
-            return 128 + 3;
-        default:
-            return 128;
-    }
-}
-/**
- * Translates numeric exit codes to NodeJS signals
- */
-function codeToSignal(code) {
-    switch (code) {
-        case 128 + 1:
-            return 'SIGHUP';
-        case 128 + 2:
-            return 'SIGINT';
-        case 128 + 15:
-            return 'SIGTERM';
-        case 128 + 3:
-            return 'SIGQUIT';
-        default:
-            return 'SIGTERM';
-    }
-}
-// Exit codes from signals that indicate intentional termination (SIGHUP, SIGINT, SIGQUIT, SIGTERM).
-// Excludes SIGKILL (137) and SIGABRT (134) as those indicate abnormal termination.
-exports.EXPECTED_TERMINATION_SIGNALS = new Set([129, 130, 131, 143]);
-/**
- * Translates a pty exit message (e.g. "Terminated by Interrupt") to a numeric exit code.
- * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
- */
-function messageToCode(message) {
-    if (message.startsWith('Terminated by ')) {
-        const signalDescription = message.replace('Terminated by ', '').trim();
-        if (signalDescription.startsWith('Hangup'))
-            return 129;
-        if (signalDescription.startsWith('Interrupt'))
-            return 130;
-        if (signalDescription.startsWith('Quit'))
-            return 131;
-        if (signalDescription.startsWith('Abort'))
-            return 134;
-        if (signalDescription.startsWith('Killed'))
-            return 137;
-        if (signalDescription.startsWith('Terminated'))
-            return 143;
-        return 128;
-    }
-    else if (message.startsWith('Exited with code ')) {
-        return parseInt(message.replace('Exited with code ', '').trim());
-    }
-    else if (message === 'Success') {
-        return 0;
-    }
-    else {
-        return 1;
-    }
-}
-/**
- * Ends the process the way an interrupted process ends: by SIGINT, not by
- * exiting with its conventional code.
- *
- * A shell reports 130 either way, but a parent using waitpid sees
- * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
- * check to tell "the user pressed Ctrl+C" from "the command failed".
- */
-function exitAsInterrupted() {
-    // Windows has no signal disposition to inherit - `process.kill` there
-    // terminates with an arbitrary code - so keep the 128+SIGINT convention.
-    if (process.platform !== 'win32') {
-        // Any listener would swallow this; the default action is what terminates.
-        process.removeAllListeners('SIGINT');
-        process.kill(process.pid, 'SIGINT');
-    }
-    process.exit(130);
-}