nx 20.8.4 → 22.7.7

package/dist/src/daemon/client/daemon-environment.d.ts

@@ -0,0 +1,4 @@
+export declare function getDaemonEnv(): NodeJS.ProcessEnv & {
+    NX_PROJECT_GLOB_CACHE: string;
+    NX_CACHE_PROJECTS_CONFIG: string;
+};

package/dist/src/daemon/client/daemon-environment.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDaemonEnv = getDaemonEnv;
+const DAEMON_ENV_REQUIRED_SETTINGS = {
+    NX_PROJECT_GLOB_CACHE: 'false',
+    NX_CACHE_PROJECTS_CONFIG: 'false',
+};
+const DAEMON_ENV_OVERRIDABLE_SETTINGS = {
+    NX_VERBOSE_LOGGING: 'true',
+    NX_PERF_LOGGING: 'true',
+    NX_NATIVE_LOGGING: 'nx=debug',
+};
+/**
+ * Env vars that should NOT be sent to the daemon because they cannot affect
+ * the project graph. Only vars that can actually affect the project graph
+ * (e.g. PATH, JAVA_HOME, GRADLE_HOME) should be allowed through.
+ */
+const DAEMON_ENV_VARS_EXCLUSIONS = new Set([
+    // Nx task-scoped vars
+    'NX_TASK_TARGET_CONFIGURATION',
+    'NX_TASK_TARGET_PROJECT',
+    'NX_TASK_TARGET_TARGET',
+    'NX_TASK_HASH',
+    'NX_TERMINAL_OUTPUT_PATH',
+    'NX_TERMINAL_CAPTURE_STDERR',
+    'NX_STREAM_OUTPUT',
+    'NX_PREFIX_OUTPUT',
+    'NX_FORKED_TASK_EXECUTOR',
+    'NX_SET_CLI',
+    'NX_INVOKED_BY_RUNNER',
+    'NX_LOAD_DOT_ENV_FILES',
+    'NX_SKIP_NX_CACHE',
+    'NX_CACHE_FAILURES',
+    'NX_REJECT_UNKNOWN_LOCAL_CACHE',
+    'NX_IGNORE_CYCLES',
+    'NX_BATCH_MODE',
+    'NX_CI_EXECUTION_ID',
+    'NX_DAEMON_PROCESS',
+    // Nx UI/logging vars (don't affect graph structure)
+    'NX_TUI',
+    'NX_TUI_AUTO_EXIT',
+    'NX_TUI_SKIP_CAPABILITY_CHECK',
+    'NX_VERBOSE_LOGGING',
+    'NX_PERF_LOGGING',
+    'NX_NATIVE_LOGGING',
+    'NX_PROFILE',
+    'NX_DAEMON_VERBOSE_LOGGING',
+    // AI agent detection vars (the daemon itself is not an AI agent)
+    'CLAUDECODE',
+    'CLAUDE_CODE',
+    'REPL_ID',
+    'CURSOR_TRACE_ID',
+    'COMPOSER_NO_INTERACTION',
+    'OPENCODE',
+    'GEMINI_CLI',
+    // Shell mechanics
+    '_',
+    'SHLVL',
+    'OLDPWD',
+    'SHELL_SESSION_ID',
+    'TERM_SESSION_ID',
+    'SECURITYSESSIONID',
+    'COMMAND_MODE',
+    'WINDOWID',
+    'COLUMNS',
+    'LINES',
+    'TMPDIR',
+    // Session / auth
+    'SSH_AUTH_SOCK',
+    'SSH_AGENT_PID',
+    'XDG_SESSION_ID',
+    'DBUS_SESSION_BUS_ADDRESS',
+    'DISPLAY',
+    // macOS internals
+    '__CF_USER_TEXT_ENCODING',
+    '__CFBundleIdentifier',
+]);
+/**
+ * Env var prefixes that should never be sent to the daemon.
+ * These cover CI platforms, package managers, editors, and terminals.
+ */
+const DAEMON_ENV_PREFIX_EXCLUSIONS = [
+    // CI platforms
+    'GITHUB_',
+    'RUNNER_',
+    'CI_JOB_',
+    'CI_PIPELINE_',
+    'CIRCLE_',
+    'JENKINS_',
+    'BUILD_',
+    'AGENT_',
+    'SYSTEM_TASK',
+    // Package managers (process-scoped)
+    'npm_',
+    'pnpm_',
+    // Editors / IDEs
+    'VSCODE_',
+    'JETBRAINS_',
+    // Terminal emulators
+    'ITERM_',
+    'KITTY_',
+    'WEZTERM_',
+    'ALACRITTY_',
+    'KONSOLE_',
+    'TMUX',
+    // Benchmarking / profiling tools
+    'HYPERFINE_', // hyperfine sets HYPERFINE_RANDOMIZED_ENVIRONMENT_OFFSET for each iteration
+];
+function isExcludedEnvVar(key) {
+    return (DAEMON_ENV_VARS_EXCLUSIONS.has(key) ||
+        DAEMON_ENV_PREFIX_EXCLUSIONS.some((prefix) => key.startsWith(prefix)));
+}
+function getDaemonEnv() {
+    const env = { ...DAEMON_ENV_OVERRIDABLE_SETTINGS };
+    for (const key in process.env) {
+        if (!isExcludedEnvVar(key)) {
+            env[key] = process.env[key];
+        }
+    }
+    return Object.assign(env, DAEMON_ENV_REQUIRED_SETTINGS);
+}

package/dist/src/daemon/client/daemon-socket-messenger.d.ts

@@ -0,0 +1,12 @@
+import { Socket } from 'net';
+import { DaemonMessage } from '../message-types/daemon-message';
+export declare class VersionMismatchError extends Error {
+    constructor();
+}
+export declare class DaemonSocketMessenger {
+    private socket;
+    constructor(socket: Socket);
+    sendMessage<T extends DaemonMessage>(messageToDaemon: T, force?: 'v8' | 'json'): void;
+    listen(onData: (message: string) => void, onClose?: () => void, onError?: (err: Error) => void): DaemonSocketMessenger;
+    close(): void;
+}

package/dist/src/daemon/client/daemon-socket-messenger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonSocketMessenger = exports.VersionMismatchError = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
+const logger_1 = require("../logger");
+const socket_utils_1 = require("../socket-utils");
+class VersionMismatchError extends Error {
+    constructor() {
+        super('Version mismatch with daemon server');
+        this.name = 'VersionMismatchError';
+        Object.setPrototypeOf(this, VersionMismatchError.prototype);
+    }
+}
+exports.VersionMismatchError = VersionMismatchError;
+class DaemonSocketMessenger {
+    constructor(socket) {
+        this.socket = socket;
+    }
+    sendMessage(messageToDaemon, force) {
+        if (!this.socket) {
+            throw new Error('Socket not initialized.');
+        }
+        logger_1.clientLogger.log('[Messenger] Sending message type:', messageToDaemon.type);
+        perf_hooks_1.performance.mark('daemon-message-serialization-start-' + messageToDaemon.type);
+        const serialized = (0, socket_utils_1.serialize)(messageToDaemon, force);
+        perf_hooks_1.performance.mark('daemon-message-serialization-end-' + messageToDaemon.type);
+        perf_hooks_1.performance.measure('daemon-message-serialization-' + messageToDaemon.type, 'daemon-message-serialization-start-' + messageToDaemon.type, 'daemon-message-serialization-end-' + messageToDaemon.type);
+        this.socket.write(serialized);
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        logger_1.clientLogger.log('[Messenger] Message sent');
+    }
+    listen(onData, onClose = () => { }, onError = () => { }) {
+        logger_1.clientLogger.log('[Messenger] Setting up socket listeners');
+        this.socket.on('close', onClose);
+        this.socket.on('error', (err) => {
+            logger_1.clientLogger.log('[Messenger] Socket error:', err.message);
+            onError(err);
+        });
+        this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (message) => {
+            logger_1.clientLogger.log('[Messenger] Received message, length:', message.length);
+            onData(message);
+        }));
+        logger_1.clientLogger.log('[Messenger] listen() complete');
+        return this;
+    }
+    close() {
+        if (this.socket) {
+            this.socket.destroy();
+        }
+    }
+}
+exports.DaemonSocketMessenger = DaemonSocketMessenger;

package/dist/src/daemon/is-nx-version-mismatch.d.ts

@@ -0,0 +1 @@
+export declare function isNxVersionMismatch(): boolean;

package/dist/src/daemon/is-nx-version-mismatch.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNxVersionMismatch = isNxVersionMismatch;
+const versions_1 = require("../utils/versions");
+const installed_nx_version_1 = require("../utils/installed-nx-version");
+function isNxVersionMismatch() {
+    return (0, installed_nx_version_1.getInstalledNxVersion)() !== versions_1.nxVersion;
+}

package/dist/src/daemon/is-v8-serializer-enabled.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if v8 serializer is enabled for daemon communication.
+ * V8 serializer is enabled by default unless explicitly disabled.
+ */
+export declare function isV8SerializerEnabled(): boolean;

package/dist/src/daemon/is-v8-serializer-enabled.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isV8SerializerEnabled = isV8SerializerEnabled;
+/**
+ * Check if v8 serializer is enabled for daemon communication.
+ * V8 serializer is enabled by default unless explicitly disabled.
+ */
+function isV8SerializerEnabled() {
+    return process.env.NX_USE_V8_SERIALIZER === 'true';
+}

package/dist/src/daemon/logger.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Unified logger for daemon server and client.
+ *
+ * To improve the overall readability of the logs, we categorize things by "trigger":
+ *
+ * - [REQUEST] meaning that the current set of actions were triggered by a client request to the server
+ * - [WATCHER] meaning the current set of actions were triggered by handling changes to the workspace files
+ *
+ * We keep those two "triggers" left aligned at the top level and then indent subsequent logs so that there is a
+ * logical hierarchy/grouping.
+ */
+import { ProgressTopic } from '../utils/progress-topics';
+import { EmitLogLevel } from './message-types/streaming-messages';
+type LogSource = 'Server' | 'Client';
+declare class DaemonLogger {
+    private source;
+    constructor(source: LogSource);
+    log(...s: unknown[]): void;
+    requestLog(...s: unknown[]): void;
+    watcherLog(...s: unknown[]): void;
+    /**
+     * Broadcasts a log line to every client currently subscribed to the
+     * given topic. Useful for warnings raised inside daemon-executed code
+     * that we want the user to see in their terminal rather than lose to
+     * the daemon log file.
+     *
+     * Falls back to writing into the daemon log when no clients are
+     * subscribed to the topic.
+     *
+     * Must only be invoked from inside the Nx daemon process.
+     */
+    logToClient(topic: ProgressTopic, message: string, level?: EmitLogLevel): void;
+    private writeToFile;
+    private formatLogMessage;
+    private getNow;
+}
+export declare const serverLogger: DaemonLogger;
+export declare const clientLogger: DaemonLogger;
+export {};

package/dist/src/daemon/logger.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Unified logger for daemon server and client.
+ *
+ * To improve the overall readability of the logs, we categorize things by "trigger":
+ *
+ * - [REQUEST] meaning that the current set of actions were triggered by a client request to the server
+ * - [WATCHER] meaning the current set of actions were triggered by handling changes to the workspace files
+ *
+ * We keep those two "triggers" left aligned at the top level and then indent subsequent logs so that there is a
+ * logical hierarchy/grouping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientLogger = exports.serverLogger = void 0;
+const fs_1 = require("fs");
+const versions_1 = require("../utils/versions");
+const client_socket_context_1 = require("./server/client-socket-context");
+const tmp_dir_1 = require("./tmp-dir");
+class DaemonLogger {
+    constructor(source) {
+        this.source = source;
+    }
+    log(...s) {
+        const message = this.formatLogMessage(s
+            .map((val) => {
+            if (typeof val === 'string') {
+                return val;
+            }
+            return JSON.stringify(val);
+        })
+            .join(' '));
+        if (this.source === 'Server') {
+            // Server's stdout is redirected to daemon.log
+            console.log(message);
+        }
+        else {
+            // Client writes directly to the log file
+            this.writeToFile(message);
+        }
+    }
+    requestLog(...s) {
+        this.log(`[REQUEST]: ${s.join(' ')}`);
+    }
+    watcherLog(...s) {
+        this.log(`[WATCHER]: ${s.join(' ')}`);
+    }
+    /**
+     * Broadcasts a log line to every client currently subscribed to the
+     * given topic. Useful for warnings raised inside daemon-executed code
+     * that we want the user to see in their terminal rather than lose to
+     * the daemon log file.
+     *
+     * Falls back to writing into the daemon log when no clients are
+     * subscribed to the topic.
+     *
+     * Must only be invoked from inside the Nx daemon process.
+     */
+    logToClient(topic, message, level = 'log') {
+        (0, client_socket_context_1.sendEmitLogMessageToTopic)(topic, message, level);
+    }
+    writeToFile(message) {
+        try {
+            if (!(0, fs_1.existsSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE)) {
+                (0, fs_1.mkdirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, { recursive: true });
+            }
+            (0, fs_1.appendFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, message + '\n');
+        }
+        catch {
+            // Ignore write errors
+        }
+    }
+    formatLogMessage(message) {
+        return `[NX v${versions_1.nxVersion} Daemon ${this.source}] - ${this.getNow()} - ${message}`;
+    }
+    getNow() {
+        return new Date(Date.now()).toISOString();
+    }
+}
+exports.serverLogger = new DaemonLogger('Server');
+exports.clientLogger = new DaemonLogger('Client');

package/dist/src/daemon/message-types/configure-ai-agents.d.ts

@@ -0,0 +1,20 @@
+export declare const GET_CONFIGURE_AI_AGENTS_STATUS: "GET_CONFIGURE_AI_AGENTS_STATUS";
+export type HandleGetConfigureAiAgentsStatusMessage = {
+    type: typeof GET_CONFIGURE_AI_AGENTS_STATUS;
+};
+export type AgentStatusInfo = {
+    name: string;
+    displayName: string;
+};
+export type ConfigureAiAgentsStatusResponse = {
+    fullyConfiguredAgents: AgentStatusInfo[];
+    outdatedAgents: AgentStatusInfo[];
+    partiallyConfiguredAgents: AgentStatusInfo[];
+    nonConfiguredAgents: AgentStatusInfo[];
+};
+export declare function isHandleGetConfigureAiAgentsStatusMessage(message: unknown): message is HandleGetConfigureAiAgentsStatusMessage;
+export declare const RESET_CONFIGURE_AI_AGENTS_STATUS: "RESET_CONFIGURE_AI_AGENTS_STATUS";
+export type HandleResetConfigureAiAgentsStatusMessage = {
+    type: typeof RESET_CONFIGURE_AI_AGENTS_STATUS;
+};
+export declare function isHandleResetConfigureAiAgentsStatusMessage(message: unknown): message is HandleResetConfigureAiAgentsStatusMessage;

package/dist/src/daemon/message-types/configure-ai-agents.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESET_CONFIGURE_AI_AGENTS_STATUS = exports.GET_CONFIGURE_AI_AGENTS_STATUS = void 0;
+exports.isHandleGetConfigureAiAgentsStatusMessage = isHandleGetConfigureAiAgentsStatusMessage;
+exports.isHandleResetConfigureAiAgentsStatusMessage = isHandleResetConfigureAiAgentsStatusMessage;
+exports.GET_CONFIGURE_AI_AGENTS_STATUS = 'GET_CONFIGURE_AI_AGENTS_STATUS';
+function isHandleGetConfigureAiAgentsStatusMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_CONFIGURE_AI_AGENTS_STATUS);
+}
+exports.RESET_CONFIGURE_AI_AGENTS_STATUS = 'RESET_CONFIGURE_AI_AGENTS_STATUS';
+function isHandleResetConfigureAiAgentsStatusMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.RESET_CONFIGURE_AI_AGENTS_STATUS);
+}

package/dist/src/daemon/message-types/daemon-message.d.ts

@@ -0,0 +1,6 @@
+export type DaemonMessage = {
+    type: string;
+    env?: Record<string, string>;
+    data?: any;
+};
+export declare function isDaemonMessage(msg: unknown): msg is DaemonMessage;

package/dist/src/daemon/message-types/daemon-message.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDaemonMessage = isDaemonMessage;
+function isDaemonMessage(msg) {
+    return typeof msg === 'object' && msg && 'type' in msg;
+}

package/dist/src/daemon/message-types/nx-console.d.ts

@@ -0,0 +1,17 @@
+export declare const GET_NX_CONSOLE_STATUS: "GET_NX_CONSOLE_STATUS";
+export declare const SET_NX_CONSOLE_PREFERENCE_AND_INSTALL: "SET_NX_CONSOLE_PREFERENCE_AND_INSTALL";
+export type HandleGetNxConsoleStatusMessage = {
+    type: typeof GET_NX_CONSOLE_STATUS;
+};
+export type NxConsoleStatusResponse = {
+    shouldPrompt: boolean;
+};
+export type HandleSetNxConsolePreferenceAndInstallMessage = {
+    type: typeof SET_NX_CONSOLE_PREFERENCE_AND_INSTALL;
+    preference: boolean;
+};
+export type SetNxConsolePreferenceAndInstallResponse = {
+    installed: boolean;
+};
+export declare function isHandleGetNxConsoleStatusMessage(message: unknown): message is HandleGetNxConsoleStatusMessage;
+export declare function isHandleSetNxConsolePreferenceAndInstallMessage(message: unknown): message is HandleSetNxConsolePreferenceAndInstallMessage;

package/dist/src/daemon/message-types/nx-console.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_NX_CONSOLE_PREFERENCE_AND_INSTALL = exports.GET_NX_CONSOLE_STATUS = void 0;
+exports.isHandleGetNxConsoleStatusMessage = isHandleGetNxConsoleStatusMessage;
+exports.isHandleSetNxConsolePreferenceAndInstallMessage = isHandleSetNxConsolePreferenceAndInstallMessage;
+exports.GET_NX_CONSOLE_STATUS = 'GET_NX_CONSOLE_STATUS';
+exports.SET_NX_CONSOLE_PREFERENCE_AND_INSTALL = 'SET_NX_CONSOLE_PREFERENCE_AND_INSTALL';
+function isHandleGetNxConsoleStatusMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_NX_CONSOLE_STATUS);
+}
+function isHandleSetNxConsolePreferenceAndInstallMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.SET_NX_CONSOLE_PREFERENCE_AND_INSTALL);
+}

package/dist/src/daemon/message-types/register-project-graph-listener.d.ts

@@ -0,0 +1,5 @@
+export declare const REGISTER_PROJECT_GRAPH_LISTENER = "REGISTER_PROJECT_GRAPH_LISTENER";
+export type RegisterProjectGraphListenerMessage = {
+    type: typeof REGISTER_PROJECT_GRAPH_LISTENER;
+};
+export declare function isRegisterProjectGraphListenerMessage(message: unknown): message is RegisterProjectGraphListenerMessage;

package/dist/src/daemon/message-types/register-project-graph-listener.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTER_PROJECT_GRAPH_LISTENER = void 0;
+exports.isRegisterProjectGraphListenerMessage = isRegisterProjectGraphListenerMessage;
+exports.REGISTER_PROJECT_GRAPH_LISTENER = 'REGISTER_PROJECT_GRAPH_LISTENER';
+function isRegisterProjectGraphListenerMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.REGISTER_PROJECT_GRAPH_LISTENER);
+}

package/dist/src/daemon/message-types/streaming-messages.d.ts

@@ -0,0 +1,14 @@
+export declare const UPDATE_PROGRESS_MESSAGE: "UPDATE_PROGRESS_MESSAGE";
+export type UpdateProgressMessage = {
+    type: typeof UPDATE_PROGRESS_MESSAGE;
+    message: string;
+};
+export declare function isUpdateProgressMessage(message: unknown): message is UpdateProgressMessage;
+export declare const EMIT_LOG: "EMIT_LOG";
+export type EmitLogLevel = 'log' | 'warn' | 'error';
+export type EmitLogMessage = {
+    type: typeof EMIT_LOG;
+    level: EmitLogLevel;
+    message: string;
+};
+export declare function isEmitLogMessage(message: unknown): message is EmitLogMessage;

package/dist/src/daemon/message-types/streaming-messages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMIT_LOG = exports.UPDATE_PROGRESS_MESSAGE = void 0;
+exports.isUpdateProgressMessage = isUpdateProgressMessage;
+exports.isEmitLogMessage = isEmitLogMessage;
+exports.UPDATE_PROGRESS_MESSAGE = 'UPDATE_PROGRESS_MESSAGE';
+function isUpdateProgressMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.UPDATE_PROGRESS_MESSAGE);
+}
+exports.EMIT_LOG = 'EMIT_LOG';
+function isEmitLogMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.EMIT_LOG);
+}

package/dist/src/daemon/server/client-socket-context.d.ts

@@ -0,0 +1,23 @@
+import type { Socket } from 'net';
+import { ProgressTopic } from '../../utils/progress-topics';
+import { EmitLogLevel } from '../message-types/streaming-messages';
+export declare function subscribeClientToTopic(socket: Socket, topic: ProgressTopic): void;
+export declare function unsubscribeClientFromTopic(socket: Socket, topic: ProgressTopic): void;
+export declare function getTopicSubscribers(topic: ProgressTopic): Set<Socket>;
+export declare function assertOnDaemon(helperName: string): void;
+/**
+ * Writes a streaming message over the given socket using the daemon's
+ * configured serialization format and terminated with MESSAGE_END_SEQ.
+ * Errors are logged to the daemon's stdout (redirected to the daemon
+ * log) rather than propagated — a disconnected client shouldn't tear
+ * down the current request handler or other subscribers.
+ */
+export declare function writeStreamingMessage(socket: Socket, payload: unknown, description: string): void;
+/**
+ * Broadcasts a progress message to every client currently subscribed to
+ * the given topic. No-op when there are no subscribers.
+ *
+ * Must only be invoked from inside the Nx daemon process.
+ */
+export declare function sendProgressMessageToTopic(topic: ProgressTopic, message: string): void;
+export declare function sendEmitLogMessageToTopic(topic: ProgressTopic, message: string, level: EmitLogLevel): void;

package/dist/src/daemon/server/client-socket-context.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeClientToTopic = subscribeClientToTopic;
+exports.unsubscribeClientFromTopic = unsubscribeClientFromTopic;
+exports.getTopicSubscribers = getTopicSubscribers;
+exports.assertOnDaemon = assertOnDaemon;
+exports.writeStreamingMessage = writeStreamingMessage;
+exports.sendProgressMessageToTopic = sendProgressMessageToTopic;
+exports.sendEmitLogMessageToTopic = sendEmitLogMessageToTopic;
+const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
+const is_on_daemon_1 = require("../is-on-daemon");
+const logger_1 = require("../logger");
+const streaming_messages_1 = require("../message-types/streaming-messages");
+const socket_utils_1 = require("../socket-utils");
+const topicSubscribers = new Map();
+function subscribeClientToTopic(socket, topic) {
+    let subscribers = getTopicSubscribers(topic);
+    if (!subscribers) {
+        subscribers = new Set();
+        topicSubscribers.set(topic, subscribers);
+    }
+    subscribers.add(socket);
+}
+function unsubscribeClientFromTopic(socket, topic) {
+    const subscribers = getTopicSubscribers(topic);
+    if (!subscribers)
+        return;
+    subscribers.delete(socket);
+}
+function getTopicSubscribers(topic) {
+    const subscribers = topicSubscribers.get(topic);
+    if (!subscribers) {
+        const set = new Set();
+        topicSubscribers.set(topic, set);
+        return set;
+    }
+    return subscribers;
+}
+function assertOnDaemon(helperName) {
+    if (!(0, is_on_daemon_1.isOnDaemon)()) {
+        throw new Error(`${helperName} can only be called from the Nx daemon process.`);
+    }
+}
+/**
+ * Writes a streaming message over the given socket using the daemon's
+ * configured serialization format and terminated with MESSAGE_END_SEQ.
+ * Errors are logged to the daemon's stdout (redirected to the daemon
+ * log) rather than propagated — a disconnected client shouldn't tear
+ * down the current request handler or other subscribers.
+ */
+function writeStreamingMessage(socket, payload, description) {
+    try {
+        logger_1.serverLogger.log('Streaming message to client:', description);
+        socket.write((0, socket_utils_1.serialize)(payload) + consume_messages_from_socket_1.MESSAGE_END_SEQ, (err) => {
+            if (err) {
+                console.log(`Streaming message write error (client likely disconnected): ${err.message}`);
+            }
+        });
+    }
+    catch (e) {
+        console.log(`Failed to send streaming message to client: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Broadcasts a progress message to every client currently subscribed to
+ * the given topic. No-op when there are no subscribers.
+ *
+ * Must only be invoked from inside the Nx daemon process.
+ */
+function sendProgressMessageToTopic(topic, message) {
+    assertOnDaemon('sendProgressMessageToTopic');
+    const subscribers = getTopicSubscribers(topic);
+    if (!subscribers?.size)
+        return;
+    const payload = { type: streaming_messages_1.UPDATE_PROGRESS_MESSAGE, message };
+    for (const socket of subscribers) {
+        writeStreamingMessage(socket, payload, 'progress update for topic ' + topic);
+    }
+}
+function sendEmitLogMessageToTopic(topic, message, level) {
+    assertOnDaemon('sendEmitLogMessageToTopic');
+    const subscribers = getTopicSubscribers(topic);
+    if (!subscribers?.size)
+        return;
+    const payload = { type: streaming_messages_1.EMIT_LOG, message, level };
+    for (const socket of subscribers) {
+        writeStreamingMessage(socket, payload, 'emit log message to ' + topic);
+    }
+}

package/dist/src/daemon/server/file-watching/file-change-events.d.ts

@@ -0,0 +1,7 @@
+export interface FileChangeEvent {
+    createdFiles: string[];
+    updatedFiles: string[];
+    deletedFiles: string[];
+}
+export declare function registerFileChangeListener(listener: (event: FileChangeEvent) => void): void;
+export declare function notifyFileChangeListeners(event: FileChangeEvent): void;

package/dist/src/daemon/server/file-watching/file-change-events.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFileChangeListener = registerFileChangeListener;
+exports.notifyFileChangeListeners = notifyFileChangeListeners;
+const logger_1 = require("../../logger");
+const fileChangeListeners = new Set();
+function registerFileChangeListener(listener) {
+    fileChangeListeners.add(listener);
+}
+function notifyFileChangeListeners(event) {
+    for (const listener of fileChangeListeners) {
+        try {
+            listener(event);
+        }
+        catch (error) {
+            logger_1.serverLogger.log('Error notifying file change listener:', error);
+        }
+    }
+}