@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

package/dist/src/tasks-runner/readiness/ready-signal-server.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadySignalServer = void 0;
+const socket_utils_1 = require("../../daemon/socket-utils");
+const pseudo_ipc_1 = require("../pseudo-ipc");
+const ready_signal_1 = require("./ready-signal");
+let id = 0;
+/**
+ * Receives the readiness signals of the producers this process starts. It
+ * does not depend on the pseudo terminal, which Windows and non-TTY runs lack.
+ */
+class ReadySignalServer {
+    constructor() {
+        this.path = (0, socket_utils_1.getForkedProcessOsSocketPath)(`${process.pid}-ready-${id++}`);
+        this.server = new pseudo_ipc_1.PseudoIPCServer(this.path);
+        this.listeners = new Map();
+        // A producer can signal before its probe subscribes. Only tasks given the
+        // socket are buffered for, until their probe subscribes.
+        this.early = new Map();
+        this.issued = new Set();
+    }
+    async env(taskId) {
+        this.started ??= this.server.init().then(() => {
+            this.server.onMessageFromChildren((message) => {
+                if (isReadySignalMessage(message))
+                    this.dispatch(message);
+            });
+        });
+        await this.started;
+        this.issued.add(taskId);
+        return {
+            [ready_signal_1.READY_SIGNAL_SOCKET_ENV]: this.path,
+            [ready_signal_1.READY_SIGNAL_TASK_ENV]: taskId,
+        };
+    }
+    subscribe(taskId, listener) {
+        this.listeners.set(taskId, listener);
+        this.issued.delete(taskId);
+        for (const message of this.early.get(taskId) ?? []) {
+            listener(message);
+        }
+        this.early.delete(taskId);
+        return () => {
+            if (this.listeners.get(taskId) === listener) {
+                this.listeners.delete(taskId);
+            }
+        };
+    }
+    close() {
+        if (this.started) {
+            this.server.close();
+        }
+    }
+    dispatch(message) {
+        const listener = this.listeners.get(message.taskId);
+        if (listener) {
+            listener(message);
+        }
+        else if (this.issued.has(message.taskId)) {
+            const early = this.early.get(message.taskId) ?? [];
+            early.push(message);
+            this.early.set(message.taskId, early);
+        }
+    }
+}
+exports.ReadySignalServer = ReadySignalServer;
+function isReadySignalMessage(message) {
+    if (typeof message !== 'object' || message === null)
+        return false;
+    const { type, taskId } = message;
+    return type === 'nx-ready-signal:ready' && typeof taskId === 'string';
+}

package/dist/src/tasks-runner/readiness/ready-signal.d.ts

@@ -0,0 +1,33 @@
+export declare const READY_SIGNAL_SOCKET_ENV = "NX_READY_SIGNAL_SOCKET";
+export declare const READY_SIGNAL_TASK_ENV = "NX_READY_SIGNAL_TASK";
+export declare const READY_URL_ENV = "NX_READY_URL";
+export type ReadySignalMessage = {
+    type: 'nx-ready-signal:ready';
+    taskId: string;
+    url?: string;
+};
+type ListeningServer = {
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | string | null;
+};
+/**
+ * Tells Nx that the task running this process is ready, for a target whose
+ * readyWhen is `signal`. Only the first call counts, so call it once the server
+ * listens. A server that isn't listening reports nothing. Pass the listening
+ * server or its url to have it passed on to the tasks that waited, as
+ * NX_READY_URL.
+ */
+export declare function emitReadySignal(server?: ListeningServer | string): boolean;
+/**
+ * `configured` moved to the address the server reported, for a task that
+ * waited for a signal: its protocol and port, and its host unless `configured`
+ * names localhost and the server listens on loopback. Keeps the path and
+ * query. Returns `configured` when no address was reported, and the reported
+ * address when `configured` is missing or not a URL.
+ */
+export declare function getReadyUrl(configured: string): string;
+export declare function getReadyUrl(configured?: string): string | undefined;
+export {};

package/dist/src/tasks-runner/readiness/ready-signal.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READY_URL_ENV = exports.READY_SIGNAL_TASK_ENV = exports.READY_SIGNAL_SOCKET_ENV = void 0;
+exports.emitReadySignal = emitReadySignal;
+exports.getReadyUrl = getReadyUrl;
+// Set on the env of a producer whose readyWhen is `signal`
+exports.READY_SIGNAL_SOCKET_ENV = 'NX_READY_SIGNAL_SOCKET';
+exports.READY_SIGNAL_TASK_ENV = 'NX_READY_SIGNAL_TASK';
+// Set on the env of a task that waited for a producer that signalled its url
+exports.READY_URL_ENV = 'NX_READY_URL';
+let client;
+let readySent = false;
+function connect() {
+    const path = process.env[exports.READY_SIGNAL_SOCKET_ENV];
+    const taskId = process.env[exports.READY_SIGNAL_TASK_ENV];
+    if (!path || !taskId) {
+        return null;
+    }
+    // Required lazily to keep this module light for the task env code
+    const { PseudoIPCClient } = require('../pseudo-ipc');
+    // A failed connection must not crash the server it reports on, nor keep
+    // its process alive
+    client ??= new PseudoIPCClient(path)
+        .onMessageFromParent(taskId, () => { }, () => { }, () => { })
+        .unref();
+    return { client, taskId };
+}
+/**
+ * Tells Nx that the task running this process is ready, for a target whose
+ * readyWhen is `signal`. Only the first call counts, so call it once the server
+ * listens. A server that isn't listening reports nothing. Pass the listening
+ * server or its url to have it passed on to the tasks that waited, as
+ * NX_READY_URL.
+ */
+function emitReadySignal(server) {
+    const connection = connect();
+    if (!connection || readySent) {
+        return false;
+    }
+    // Express 5 calls the listen callback with the error when listening fails
+    if (server && typeof server !== 'string' && !server.address()) {
+        return false;
+    }
+    readySent = true;
+    const url = typeof server === 'string' ? server : getServerUrl(server);
+    connection.client.sendMessageToParent({
+        type: 'nx-ready-signal:ready',
+        taskId: connection.taskId,
+        ...(url ? { url } : {}),
+    });
+    return true;
+}
+// Mirrors getListeningUrl in @nx/devkit/internal, which nx can't import
+function getServerUrl(server) {
+    const address = server?.address();
+    if (!address || typeof address === 'string') {
+        return undefined;
+    }
+    const { Server: TlsServer } = require('tls');
+    const host = address.address === '::' || address.address === '0.0.0.0'
+        ? 'localhost'
+        : address.family === 'IPv6'
+            ? `[${address.address}]`
+            : address.address;
+    const protocol = server instanceof TlsServer ? 'https' : 'http';
+    return `${protocol}://${host}:${address.port}/`;
+}
+function getReadyUrl(configured) {
+    const ready = process.env[exports.READY_URL_ENV];
+    if (!ready || !URL.canParse(ready)) {
+        return configured;
+    }
+    if (!configured || !URL.canParse(configured)) {
+        return ready;
+    }
+    const url = new URL(configured);
+    const reported = new URL(ready);
+    url.protocol = reported.protocol;
+    url.port = reported.port;
+    // A localhost name reaches either loopback address; an IP literal only its own
+    if (!isLocalhostName(url.hostname) || !isLoopback(reported.hostname)) {
+        url.hostname = reported.hostname;
+    }
+    return url.toString();
+}
+function isLocalhostName(hostname) {
+    return hostname === 'localhost' || hostname.endsWith('.localhost');
+}
+function isLoopback(hostname) {
+    const host = hostname.replace(/^\[|\]$/g, '');
+    return isLocalhostName(host) || host === '::1' || /^127\./.test(host);
+}

package/dist/src/tasks-runner/readiness/ready-when.d.ts

@@ -0,0 +1,84 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import type { Task, TaskGraph } from '../../config/task-graph';
+import type { ProjectConfiguration, ReadyWhen } from '../../config/workspace-json-project-json';
+export declare const DEFAULT_READY_TIMEOUT = 600000;
+type ReadyWhenProbe<Deferred> = {
+    timeout: number;
+    interval?: number;
+} & ({
+    kind: 'url';
+    url: string | Deferred;
+} | {
+    kind: 'port';
+    port: number | Deferred;
+    host?: string | Deferred;
+} | {
+    kind: 'command';
+    command: string | Deferred;
+    env?: Record<string, string>;
+} | {
+    kind: 'logMatches';
+    logMatches: (string | Deferred)[];
+} | {
+    kind: 'signal';
+});
+export type NormalizedReadyWhen = ReadyWhenProbe<never>;
+export interface ReadyWhenWait {
+    timeout: number;
+    description: string;
+}
+export interface ReadyWhenData {
+    workspaceRoot: string;
+    projectRoot: string;
+    projectName: string;
+    options: Record<string, unknown>;
+    env: () => NodeJS.ProcessEnv;
+}
+export declare function normalizeReadyWhen(readyWhen: ReadyWhen, taskId: string, data: ReadyWhenData): NormalizedReadyWhen | null;
+/**
+ * Checks a producer's probe without the env the producer runs with. A value
+ * that reads that env is left to getReadyWhen in the process that runs the
+ * producer, and every other value is checked the way getReadyWhen checks it.
+ */
+export declare function checkReadyWhen(readyWhen: ReadyWhen, taskId: string, data: Omit<ReadyWhenData, 'env'>): ReadyWhenWait;
+export declare function readinessTimeoutError(taskId: string, readyWhen: NormalizedReadyWhen | ReadyWhenWait): Error;
+export declare class ProducerFailedError extends Error {
+    constructor(taskId: string);
+}
+export declare class NotReadyError extends Error {
+}
+export declare class InvalidReadyWhenError extends Error {
+}
+export declare function notReadyError(taskId: string, reason: 'exited' | 'was stopped' | 'failed'): Error;
+export declare function getReadyWhenConfig(task: Task, projectGraph: ProjectGraph): ReadyWhen | null | undefined;
+/**
+ * The probe of a producer this process starts with `taskEnv`. Env tokens read
+ * `taskEnv`, or for run-commands the env its command runs with
+ */
+export declare function getReadyWhen(task: Task, projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, workspaceRoot: string, taskEnv: NodeJS.ProcessEnv, inputs?: {
+    readyWhen: ReadyWhen;
+    executor: string;
+    data: {
+        workspaceRoot: string;
+        projectRoot: string;
+        projectName: string;
+        options: any;
+    };
+}): NormalizedReadyWhen | null;
+export declare const TASK_OPTIONS_ENV = "NX_TASK_OPTIONS";
+export declare function getReadyWhenWait(task: Task, projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, workspaceRoot: string): ReadyWhenWait | null;
+export type ReadyWhenInputs = ReturnType<typeof getReadyWhenInputs>;
+export declare function getReadyWhenInputs(task: Task, projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, workspaceRoot: string): {
+    readyWhen: ReadyWhen;
+    executor: string;
+    data: {
+        workspaceRoot: string;
+        projectRoot: string;
+        projectName: string;
+        options: any;
+    };
+};
+export declare function mayReportReadyUrl(task: Task, projectGraph: ProjectGraph): boolean;
+export declare function getReadyProducerIds(task: Task, taskGraph: TaskGraph): string[];
+export declare function getReadyDependencies(taskGraph: TaskGraph, projectGraph: ProjectGraph): Record<string, string[]>;
+export {};

package/dist/src/tasks-runner/readiness/ready-when.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_OPTIONS_ENV = exports.InvalidReadyWhenError = exports.NotReadyError = exports.ProducerFailedError = exports.DEFAULT_READY_TIMEOUT = void 0;
+exports.normalizeReadyWhen = normalizeReadyWhen;
+exports.checkReadyWhen = checkReadyWhen;
+exports.readinessTimeoutError = readinessTimeoutError;
+exports.notReadyError = notReadyError;
+exports.getReadyWhenConfig = getReadyWhenConfig;
+exports.getReadyWhen = getReadyWhen;
+exports.getReadyWhenWait = getReadyWhenWait;
+exports.getReadyWhenInputs = getReadyWhenInputs;
+exports.mayReportReadyUrl = mayReportReadyUrl;
+exports.getReadyProducerIds = getReadyProducerIds;
+exports.getReadyDependencies = getReadyDependencies;
+const path_1 = require("path");
+const params_1 = require("../../utils/params");
+const tokens_1 = require("../tokens");
+const utils_1 = require("../utils");
+const native_1 = require("../../native");
+exports.DEFAULT_READY_TIMEOUT = 600_000;
+// Node timers take at most a signed 32-bit count of milliseconds
+const MAX_DURATION = 2_147_483_647;
+const PROBE_KEYS = ['url', 'port', 'command', 'logMatches', 'signal'];
+class EnvUnknownHere extends Error {
+}
+// A value that reads the producer's env. It keeps its written form, and
+// getReadyWhen checks it in the process that runs the producer
+class EnvDeferred {
+    constructor(written) {
+        this.written = written;
+    }
+    toString() {
+        return this.written;
+    }
+}
+// `options` and `env` are tokens only with a path, so shell text such as
+// `${options}` stays as written
+const PATHLESS_TOKENS = new Set([
+    'workspaceRoot',
+    'projectRoot',
+    'projectName',
+]);
+function normalizeReadyWhen(readyWhen, taskId, data) {
+    const probe = resolveReadyWhen(readyWhen, taskId, data);
+    // Only checkReadyWhen's env throws EnvUnknownHere, so nothing is deferred
+    return probe.kind === 'serverPicksPort'
+        ? null
+        : probe;
+}
+function resolveReadyWhen(readyWhen, taskId, data) {
+    const invalid = (reason) => new InvalidReadyWhenError(`Task "${taskId}" has an invalid "readyWhen": ${reason}.`);
+    if (typeof readyWhen !== 'object' || readyWhen === null) {
+        throw invalid('expected an object');
+    }
+    const config = readyWhen;
+    const scope = {
+        isToken: (name, path) => path === undefined
+            ? PATHLESS_TOKENS.has(name)
+            : name === 'options' || name === 'env',
+        read: (name, path) => (0, tokens_1.readPath)(data[name], path),
+        env: { read: data.env },
+        noValue: (token) => {
+            throw invalid(`"${token}" has no value`);
+        },
+        toText: (value, token) => {
+            if (!['string', 'number', 'boolean'].includes(typeof value)) {
+                throw invalid(`"${token}" is not a string or a number`);
+            }
+            return String(value);
+        },
+    };
+    // A flag passed without a value parses as `true`, and no host or port is a
+    // boolean
+    const hostScope = {
+        ...scope,
+        isUnset: (value) => typeof value === 'boolean',
+    };
+    // The Rspack dev server reads an empty port option as 0. An empty env var
+    // stays unset.
+    const portScope = {
+        ...hostScope,
+        read: (name, path) => {
+            const value = scope.read(name, path);
+            return value === '' ? 0 : value;
+        },
+    };
+    const resolve = (value, tokenScope = scope) => {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        let nodes;
+        try {
+            nodes = (0, tokens_1.parseTokens)(value, tokenScope);
+        }
+        catch (e) {
+            throw invalid(e.message);
+        }
+        try {
+            return (0, tokens_1.renderTokens)(nodes, tokenScope);
+        }
+        catch (e) {
+            if (e instanceof EnvUnknownHere) {
+                return new EnvDeferred(value);
+            }
+            throw e;
+        }
+    };
+    // Braces are never valid in a host or port once resolved, so a leftover is
+    // a typo. A url keeps them: they are legal in its path and query.
+    const resolveWithoutBraces = (key, tokenScope) => {
+        const value = resolve(config[key], tokenScope);
+        if (typeof value === 'string' && /[{}]/.test(value)) {
+            throw invalid(`"${key}" contains an unknown placeholder`);
+        }
+        return value;
+    };
+    const present = PROBE_KEYS.filter((key) => config[key] != null);
+    if (present.length !== 1) {
+        throw invalid(`expected exactly one of ${PROBE_KEYS.map((k) => `"${k}"`).join(', ')}`);
+    }
+    const timeout = config.timeout ?? exports.DEFAULT_READY_TIMEOUT;
+    if (!isDuration(timeout)) {
+        throw invalid(`"timeout" must be an integer from 1 to ${MAX_DURATION}`);
+    }
+    const shared = { timeout };
+    if (config.interval != null) {
+        if (!isDuration(config.interval)) {
+            throw invalid(`"interval" must be an integer from 1 to ${MAX_DURATION}`);
+        }
+        shared.interval = config.interval;
+    }
+    switch (present[0]) {
+        case 'url': {
+            const url = resolve(config.url);
+            if (!(url instanceof EnvDeferred) &&
+                (typeof url !== 'string' || !isHttpUrl(url))) {
+                throw invalid('"url" must be an http or https URL');
+            }
+            return { kind: 'url', url, ...shared };
+        }
+        case 'port': {
+            let port = resolveWithoutBraces('port', portScope);
+            if (typeof port === 'string' && /^\d+$/.test(port)) {
+                port = Number(port);
+            }
+            if (port !== 0 &&
+                port !== 'auto' &&
+                !(port instanceof EnvDeferred) &&
+                (!isPositiveInteger(port) || port > 65535)) {
+                throw invalid('"port" must be an integer from 0 to 65535, or "auto"');
+            }
+            const host = resolveWithoutBraces('host', hostScope);
+            if (host == null) {
+                return port === 0 || port === 'auto'
+                    ? { kind: 'serverPicksPort', port, ...shared }
+                    : { kind: 'port', port, ...shared };
+            }
+            if (!(host instanceof EnvDeferred) &&
+                (typeof host !== 'string' || !host)) {
+                throw invalid('"host" must be a non-empty string');
+            }
+            return port === 0 || port === 'auto'
+                ? { kind: 'serverPicksPort', port, host, ...shared }
+                : { kind: 'port', port, host, ...shared };
+        }
+        case 'command': {
+            const command = resolve(config.command);
+            if (!(command instanceof EnvDeferred) &&
+                (typeof command !== 'string' || !command)) {
+                throw invalid('"command" must be a non-empty string');
+            }
+            return { kind: 'command', command, ...shared };
+        }
+        case 'logMatches': {
+            const logMatches = (Array.isArray(config.logMatches)
+                ? config.logMatches
+                : [config.logMatches]).map((match) => resolve(match));
+            if (logMatches.length === 0 ||
+                !logMatches.every((m) => m instanceof EnvDeferred || (typeof m === 'string' && !!m))) {
+                throw invalid('"logMatches" must be a non-empty string or an array of them');
+            }
+            return { kind: 'logMatches', logMatches, ...shared };
+        }
+        case 'signal': {
+            if (config.signal !== true) {
+                throw invalid('"signal" must be true');
+            }
+            if (config.interval != null) {
+                throw invalid('"interval" is not used by "signal"');
+            }
+            return { kind: 'signal', timeout };
+        }
+    }
+}
+/**
+ * Checks a producer's probe without the env the producer runs with. A value
+ * that reads that env is left to getReadyWhen in the process that runs the
+ * producer, and every other value is checked the way getReadyWhen checks it.
+ */
+function checkReadyWhen(readyWhen, taskId, data) {
+    const probe = resolveReadyWhen(readyWhen, taskId, {
+        ...data,
+        env: () => {
+            throw new EnvUnknownHere();
+        },
+    });
+    return {
+        timeout: probe.timeout,
+        description: describeReadyWhen(probe),
+    };
+}
+function readinessTimeoutError(taskId, readyWhen) {
+    const description = 'kind' in readyWhen ? describeReadyWhen(readyWhen) : readyWhen.description;
+    const longer = Math.min(readyWhen.timeout * 2, MAX_DURATION);
+    return new Error(`Task "${taskId}" did not become ready within ${(0, native_1.formatDuration)(readyWhen.timeout)} (readyWhen: ${description}). ` +
+        `If it needs longer, set "timeout": ${longer} in the target's "readyWhen", as { "...": true, "timeout": ${longer} } to keep an inferred check. ` +
+        'To change the check, set "readyWhen" on the target or in "targetDefaults" in nx.json, or set it to null to turn it off.');
+}
+// The row carries only the status; the owner reports the reason
+class ProducerFailedError extends Error {
+    constructor(taskId) {
+        super(`Task "${taskId}" failed its readiness check in the process that started it.`);
+    }
+}
+exports.ProducerFailedError = ProducerFailedError;
+// An exit or a stop is completed by its own handler, not as a verdict
+class NotReadyError extends Error {
+}
+exports.NotReadyError = NotReadyError;
+class InvalidReadyWhenError extends Error {
+}
+exports.InvalidReadyWhenError = InvalidReadyWhenError;
+function notReadyError(taskId, reason) {
+    return new NotReadyError(`Task "${taskId}" ${reason} before it became ready.`);
+}
+function describeReadyWhen(readyWhen) {
+    switch (readyWhen.kind) {
+        case 'url':
+            return `url ${readyWhen.url}`;
+        case 'port':
+        case 'serverPicksPort':
+            return readyWhen.host
+                ? `port ${readyWhen.host}:${readyWhen.port}`
+                : `port ${readyWhen.port}`;
+        case 'command':
+            return `command "${readyWhen.command}"`;
+        case 'logMatches':
+            return `logMatches ${readyWhen.logMatches.map((m) => `"${m}"`).join(', ')}`;
+        case 'signal':
+            return 'signal';
+    }
+}
+// Raw config: scheduling must not throw on an invalid value, the producer's
+// own start reports that
+function getReadyWhenConfig(task, projectGraph) {
+    if (!task.continuous) {
+        return undefined;
+    }
+    return projectGraph.nodes[task.target.project]?.data?.targets?.[task.target.target]?.readyWhen;
+}
+/**
+ * The probe of a producer this process starts with `taskEnv`. Env tokens read
+ * `taskEnv`, or for run-commands the env its command runs with
+ */
+function getReadyWhen(task, projectGraph, projects, workspaceRoot, taskEnv, inputs = getReadyWhenInputs(task, projectGraph, projects, workspaceRoot)) {
+    if (!inputs) {
+        return null;
+    }
+    const { readyWhen, executor, data } = inputs;
+    const { options } = data;
+    let commandEnv;
+    const env = () => {
+        if (executor !== 'nx:run-commands') {
+            return taskEnv;
+        }
+        if (commandEnv) {
+            return commandEnv;
+        }
+        // Required lazily, so loading run-command.ts doesn't also load the
+        // run-commands executor
+        const { calculateCwd, processEnv } = require('../../executors/run-commands/running-tasks');
+        commandEnv = processEnv(options.color, calculateCwd(options.cwd, {
+            root: workspaceRoot,
+        }), (options.env ?? {}), options.envFile, taskEnv);
+        return commandEnv;
+    };
+    const probe = normalizeReadyWhen(readyWhen, task.id, { ...data, env });
+    if (probe?.kind === 'command') {
+        probe.env = {
+            ...Object.fromEntries(Object.entries(env()).filter(([, value]) => value !== undefined)),
+            [exports.TASK_OPTIONS_ENV]: JSON.stringify(options),
+        };
+    }
+    return probe;
+}
+// A command check reads the options its producer runs with from this variable
+exports.TASK_OPTIONS_ENV = 'NX_TASK_OPTIONS';
+// The probe of a producer another process may run
+function getReadyWhenWait(task, projectGraph, projects, workspaceRoot) {
+    const inputs = getReadyWhenInputs(task, projectGraph, projects, workspaceRoot);
+    return inputs && checkReadyWhen(inputs.readyWhen, task.id, inputs.data);
+}
+// Placeholders resolve against the options the executor receives: aliases,
+// schema defaults and the spelling of command-line overrides applied
+function getReadyWhenInputs(task, projectGraph, projects, workspaceRoot) {
+    const readyWhen = getReadyWhenConfig(task, projectGraph);
+    if (readyWhen == null) {
+        return null;
+    }
+    const node = projectGraph.nodes[task.target.project];
+    const target = node.data.targets[task.target.target];
+    const { schema } = (0, utils_1.getExecutorForTask)(task, projects);
+    const options = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? target.defaultConfiguration, target, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
+    return {
+        readyWhen,
+        executor: target.executor,
+        data: {
+            workspaceRoot,
+            projectRoot: node.data.root,
+            projectName: node.name,
+            options,
+        },
+    };
+}
+// Only a signal check reports a URL, which its waiters get as NX_READY_URL
+function mayReportReadyUrl(task, projectGraph) {
+    const readyWhen = getReadyWhenConfig(task, projectGraph);
+    if (typeof readyWhen !== 'object' || readyWhen === null) {
+        return false;
+    }
+    const kind = PROBE_KEYS.find((key) => readyWhen[key] != null);
+    switch (kind) {
+        case 'signal':
+            return true;
+        case 'url':
+        case 'port':
+        case 'command':
+        case 'logMatches':
+        case undefined:
+            return false;
+        default: {
+            const unhandled = kind;
+            throw new Error(`Unhandled readyWhen check: ${unhandled}`);
+        }
+    }
+}
+function getReadyProducerIds(task, taskGraph) {
+    return (taskGraph.continuousDependencies[task.id] ?? [])
+        .filter((edge) => edge.waitFor === 'ready')
+        .map((edge) => edge.id);
+}
+// Producers with a probe that each task waits on; tasks with none are left out
+function getReadyDependencies(taskGraph, projectGraph) {
+    const readyDependencies = {};
+    for (const task of Object.values(taskGraph.tasks)) {
+        const producerIds = getReadyProducerIds(task, taskGraph).filter((id) => getReadyWhenConfig(taskGraph.tasks[id], projectGraph) != null);
+        if (producerIds.length > 0) {
+            readyDependencies[task.id] = producerIds;
+        }
+    }
+    return readyDependencies;
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function isDuration(value) {
+    return isPositiveInteger(value) && value <= MAX_DURATION;
+}
+function isHttpUrl(value) {
+    return (URL.canParse(value) && ['http:', 'https:'].includes(new URL(value).protocol));
+}

package/dist/src/tasks-runner/readiness/startup-host.d.ts

@@ -0,0 +1 @@
+export declare function resolveStartupHost(host: string | undefined): string | undefined;

package/dist/src/tasks-runner/readiness/startup-host.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStartupHost = resolveStartupHost;
+const net_1 = require("net");
+const os_1 = require("os");
+// webpack-dev-server and the Rspack dev server resolve these hosts when they
+// start (`Server.getHostname`). A wildcard fallback means loopback to the probe.
+function resolveStartupHost(host) {
+    switch (host) {
+        case 'local-ip':
+            return findIp('IPv4') ?? findIp('IPv6') ?? '0.0.0.0';
+        case 'local-ipv4':
+            return findIp('IPv4') ?? '0.0.0.0';
+        case 'local-ipv6':
+            return findIp('IPv6') ?? '::';
+        default:
+            return host;
+    }
+}
+// The IPv6 ranges `Server.findIp` accepts: unique local, IPv4-mapped, loopback
+const FIND_IP_V6_RANGES = new net_1.BlockList();
+FIND_IP_V6_RANGES.addSubnet('fc00::', 7, 'ipv6');
+FIND_IP_V6_RANGES.addSubnet('::ffff:0:0', 96, 'ipv6');
+FIND_IP_V6_RANGES.addAddress('::1', 'ipv6');
+function findIp(family) {
+    return Object.values((0, os_1.networkInterfaces)())
+        .flatMap((addresses) => addresses ?? [])
+        .find(({ address, family: addressFamily, internal }) => address &&
+        addressFamily === family &&
+        !internal &&
+        (family === 'IPv4' || FIND_IP_V6_RANGES.check(address, 'ipv6')))?.address;
+}