nx 22.7.10 → 22.7.12

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

@@ -33,10 +33,12 @@ export declare class DaemonClient {
     private _daemonReady;
     private fileWatcherMessenger;
     private fileWatcherReconnecting;
+    private fileWatcherFramingFailures;
     private fileWatcherCallbacks;
     private fileWatcherConfigs;
     private projectGraphListenerMessenger;
     private projectGraphListenerReconnecting;
+    private projectGraphListenerFramingFailures;
     private projectGraphListenerCallbacks;
     enabled(): boolean;
     reset(): void;

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

@@ -54,6 +54,11 @@ const WAIT_FOR_SERVER_CONFIG = {
     delayMs: 10,
     maxAttempts: 6000, // 6000 * 10ms = 60 seconds
 };
+/**
+ * A framing failure repeats on every redial, so the watcher channels stop
+ * re-dialing once this many land back to back without a message in between.
+ */
+const MAX_CONSECUTIVE_FRAMING_FAILURES = 3;
 class DaemonClient {
     constructor() {
         // Tracks the spinner owned by the in-flight request so streamed
@@ -65,9 +70,11 @@ class DaemonClient {
         this._waitForDaemonReady = null;
         this._daemonReady = null;
         this.fileWatcherReconnecting = false;
+        this.fileWatcherFramingFailures = 0;
         this.fileWatcherCallbacks = new Map();
         this.fileWatcherConfigs = new Map();
         this.projectGraphListenerReconnecting = false;
+        this.projectGraphListenerFramingFailures = 0;
         this.projectGraphListenerCallbacks = new Map();
         this.envReflectionSent = false;
         try {
@@ -220,6 +227,8 @@ class DaemonClient {
             this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    // A delivered message means the stream is healthy again.
+                    this.fileWatcherFramingFailures = 0;
                     // Notify all callbacks
                     for (const cb of this.fileWatcherCallbacks.values()) {
                         cb(null, parsedMessage);
@@ -248,6 +257,12 @@ class DaemonClient {
                 for (const cb of this.fileWatcherCallbacks.values()) {
                     cb(err, null);
                 }
+                if (err instanceof consume_messages_from_socket_1.MessageFramingError) {
+                    this.fileWatcherFramingFailures++;
+                }
+                // Close so 'close' fires and the reconnect path runs; a framing
+                // failure would otherwise leave this channel silent forever.
+                this.fileWatcherMessenger?.close();
             });
             this.fileWatcherMessenger.sendMessage({
                 type: 'REGISTER_FILE_WATCHER',
@@ -270,6 +285,19 @@ class DaemonClient {
         if (this.fileWatcherReconnecting) {
             return;
         }
+        // The concurrency guard above is cleared before this method recurses, so it
+        // bounds overlap rather than iterations. A framing failure is deterministic
+        // — re-dialing replays it — so without this the channel would reconnect and
+        // re-fail forever. Reaching a payload over NX_MAX_MESSAGE_SIZE does exactly
+        // that on every notification.
+        if (this.fileWatcherFramingFailures >= MAX_CONSECUTIVE_FRAMING_FAILURES) {
+            logger_1.clientLogger.log(`[FileWatcher] Giving up after ${this.fileWatcherFramingFailures} consecutive framing failures`);
+            this.fileWatcherReconnecting = false;
+            for (const cb of this.fileWatcherCallbacks.values()) {
+                cb('closed', null);
+            }
+            return;
+        }
         if (this.fileWatcherCallbacks.size === 0) {
             return; // No callbacks to reconnect
         }
@@ -306,6 +334,8 @@ class DaemonClient {
             this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    // A delivered message means the stream is healthy again.
+                    this.fileWatcherFramingFailures = 0;
                     for (const cb of this.fileWatcherCallbacks.values()) {
                         cb(null, parsedMessage);
                     }
@@ -331,7 +361,12 @@ class DaemonClient {
                     }
                     process.exit(1);
                 }
-                // Other errors during reconnection - let retry loop handle
+                if (err instanceof consume_messages_from_socket_1.MessageFramingError) {
+                    this.fileWatcherFramingFailures++;
+                }
+                // The retry loop is driven by 'close', which a framing failure does
+                // not emit, so close explicitly to hand off to it.
+                this.fileWatcherMessenger?.close();
             });
             // Re-register all stored configs
             for (const cfg of this.fileWatcherConfigs.values()) {
@@ -374,6 +409,8 @@ class DaemonClient {
             this.projectGraphListenerMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    // A delivered message means the stream is healthy again.
+                    this.projectGraphListenerFramingFailures = 0;
                     // Notify all callbacks
                     for (const cb of this.projectGraphListenerCallbacks.values()) {
                         cb(null, parsedMessage);
@@ -402,6 +439,10 @@ class DaemonClient {
                 for (const cb of this.projectGraphListenerCallbacks.values()) {
                     cb(err, null);
                 }
+                if (err instanceof consume_messages_from_socket_1.MessageFramingError) {
+                    this.projectGraphListenerFramingFailures++;
+                }
+                this.projectGraphListenerMessenger?.close();
             });
             this.projectGraphListenerMessenger.sendMessage({
                 type: register_project_graph_listener_1.REGISTER_PROJECT_GRAPH_LISTENER,
@@ -422,6 +463,17 @@ class DaemonClient {
         if (this.projectGraphListenerReconnecting) {
             return;
         }
+        // See reconnectFileWatcher: a framing failure repeats on every redial, so
+        // the concurrency guard alone cannot bound it.
+        if (this.projectGraphListenerFramingFailures >=
+            MAX_CONSECUTIVE_FRAMING_FAILURES) {
+            logger_1.clientLogger.log(`[ProjectGraphListener] Giving up after ${this.projectGraphListenerFramingFailures} consecutive framing failures`);
+            this.projectGraphListenerReconnecting = false;
+            for (const cb of this.projectGraphListenerCallbacks.values()) {
+                cb('closed', null);
+            }
+            return;
+        }
         if (this.projectGraphListenerCallbacks.size === 0) {
             return; // No callbacks to reconnect
         }
@@ -458,6 +510,8 @@ class DaemonClient {
             this.projectGraphListenerMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    // A delivered message means the stream is healthy again.
+                    this.projectGraphListenerFramingFailures = 0;
                     for (const cb of this.projectGraphListenerCallbacks.values()) {
                         cb(null, parsedMessage);
                     }
@@ -483,7 +537,12 @@ class DaemonClient {
                     }
                     process.exit(1);
                 }
-                // Other errors during reconnection - let retry loop handle
+                if (err instanceof consume_messages_from_socket_1.MessageFramingError) {
+                    this.projectGraphListenerFramingFailures++;
+                }
+                // The retry loop is driven by 'close', which a framing failure does
+                // not emit, so close explicitly to hand off to it.
+                this.projectGraphListenerMessenger?.close();
             });
             // Re-register
             this.projectGraphListenerMessenger.sendMessage({
@@ -768,8 +827,14 @@ class DaemonClient {
                 this.handleConnectionError(daemonProcessException('Daemon process terminated and closed the connection'));
             }
         }, (err) => {
+            // Every recovery path below is keyed on the socket 'close' event, and a
+            // framing failure emits neither 'close' nor 'error'. Without the
+            // teardown at the end of this handler the connection stays open and
+            // permanently deaf, and the next request waits out the keep-alive.
             if (!err.message) {
-                return this.currentReject(daemonProcessException(err.toString()));
+                this.currentReject(daemonProcessException(err.toString()));
+                this.socketMessenger?.close();
+                return;
             }
             let error;
             if (err.message.startsWith('connect ENOENT')) {
@@ -790,6 +855,7 @@ class DaemonClient {
                 error = daemonProcessException(err.toString());
             }
             this.currentReject(error);
+            this.socketMessenger?.close();
         });
     }
     async handleConnectionError(error) {
@@ -960,9 +1026,9 @@ class DaemonClient {
             }
         }
         catch (e) {
-            const endOfResponse = serializedResult.length > 300
-                ? serializedResult.substring(serializedResult.length - 300)
-                : serializedResult;
+            const endOfResponse = (0, consume_messages_from_socket_1.describeMessage)(serializedResult, {
+                from: 'end',
+            });
             this.currentReject(daemonProcessException([
                 'Could not deserialize response from Nx daemon.',
                 `Message: ${e.message}`,
@@ -999,7 +1065,7 @@ class DaemonClient {
             detached: true,
             windowsHide: true,
             shell: false,
-            env: (0, daemon_environment_1.getDaemonEnv)(),
+            env: (0, daemon_environment_1.getDaemonSpawnEnv)(),
         });
         // The child now owns dup'd copies of the descriptors, so release ours.
         (0, node_fs_1.closeSync)(outFd);

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

@@ -2,3 +2,14 @@ export declare function getDaemonEnv(): NodeJS.ProcessEnv & {
     NX_PROJECT_GLOB_CACHE: string;
     NX_CACHE_PROJECTS_CONFIG: string;
 };
+/**
+ * Env for spawning the daemon process. On top of the reflected env it re-adds
+ * NX_MAX_MESSAGE_SIZE, which is excluded from reflection (see above) so one
+ * client cannot change the ceiling for another. The value here therefore holds
+ * for the daemon's whole lifetime, and changing it needs a daemon restart
+ * (`nx reset`).
+ */
+export declare function getDaemonSpawnEnv(): NodeJS.ProcessEnv & {
+    NX_PROJECT_GLOB_CACHE: string;
+    NX_CACHE_PROJECTS_CONFIG: string;
+};

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemonEnv = getDaemonEnv;
+exports.getDaemonSpawnEnv = getDaemonSpawnEnv;
 const DAEMON_ENV_REQUIRED_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -16,6 +17,11 @@ const DAEMON_ENV_OVERRIDABLE_SETTINGS = {
  * (e.g. PATH, JAVA_HOME, GRADLE_HOME) should be allowed through.
  */
 const DAEMON_ENV_VARS_EXCLUSIONS = new Set([
+    // The message-size ceiling is read when a connection is accepted, before the
+    // client's env could apply, so reflecting it would hand one client's value to
+    // the next client's connection. Pinned at daemon spawn instead; see
+    // getDaemonSpawnEnv.
+    'NX_MAX_MESSAGE_SIZE',
     // Nx task-scoped vars
     'NX_TASK_TARGET_CONFIGURATION',
     'NX_TASK_TARGET_PROJECT',
@@ -119,3 +125,17 @@ function getDaemonEnv() {
     }
     return Object.assign(env, DAEMON_ENV_REQUIRED_SETTINGS);
 }
+/**
+ * Env for spawning the daemon process. On top of the reflected env it re-adds
+ * NX_MAX_MESSAGE_SIZE, which is excluded from reflection (see above) so one
+ * client cannot change the ceiling for another. The value here therefore holds
+ * for the daemon's whole lifetime, and changing it needs a daemon restart
+ * (`nx reset`).
+ */
+function getDaemonSpawnEnv() {
+    const env = getDaemonEnv();
+    if (process.env.NX_MAX_MESSAGE_SIZE !== undefined) {
+        env.NX_MAX_MESSAGE_SIZE = process.env.NX_MAX_MESSAGE_SIZE;
+    }
+    return env;
+}

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

@@ -7,6 +7,6 @@ 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;
+    listen(onData: (message: Buffer) => void, onClose?: () => void, onError?: (err: Error) => void): DaemonSocketMessenger;
     close(): void;
 }

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

@@ -30,9 +30,7 @@ class DaemonSocketMessenger {
         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);
+        (0, consume_messages_from_socket_1.writeMessage)(this.socket, serialized);
         logger_1.clientLogger.log('[Messenger] Message sent');
     }
     listen(onData, onClose = () => { }, onError = () => { }) {
@@ -45,6 +43,13 @@ class DaemonSocketMessenger {
         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);
+        }, 
+        // A framing failure leaves the socket open and writable, so nothing
+        // else settles the in-flight request. Route it to the same handler as
+        // a socket error rather than waiting for the keep-alive timeout.
+        (err) => {
+            logger_1.clientLogger.log('[Messenger] Framing error:', err.message);
+            onError(err);
         }));
         logger_1.clientLogger.log('[Messenger] listen() complete');
         return this;

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

@@ -1,5 +1,5 @@
 /**
- * Check if v8 serializer is enabled for daemon communication.
- * V8 serializer is enabled by default unless explicitly disabled.
+ * Off by default; set `NX_USE_V8_SERIALIZER=true` to opt in. Governs every Nx
+ * socket channel: the daemon client and server, plugin workers, and pseudo-IPC.
  */
 export declare function isV8SerializerEnabled(): boolean;

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

@@ -2,8 +2,8 @@
 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.
+ * Off by default; set `NX_USE_V8_SERIALIZER=true` to opt in. Governs every Nx
+ * socket channel: the daemon client and server, plugin workers, and pseudo-IPC.
  */
 function isV8SerializerEnabled() {
     return process.env.NX_USE_V8_SERIALIZER === 'true';

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

@@ -7,7 +7,7 @@ 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.
+ * configured serialization format, length-prefixed like any other message.
  * 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.

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

@@ -7,7 +7,6 @@ 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");
@@ -43,7 +42,7 @@ function assertOnDaemon(helperName) {
 }
 /**
  * Writes a streaming message over the given socket using the daemon's
- * configured serialization format and terminated with MESSAGE_END_SEQ.
+ * configured serialization format, length-prefixed like any other message.
  * 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.
@@ -51,7 +50,7 @@ function assertOnDaemon(helperName) {
 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) => {
+        (0, socket_utils_1.sendMessage)(socket, payload, undefined, (err) => {
             if (err) {
                 console.log(`Streaming message write error (client likely disconnected): ${err.message}`);
             }

package/dist/src/daemon/server/handle-hash-tasks.js

@@ -11,7 +11,7 @@ const configuration_1 = require("../../config/configuration");
 let storedProjectGraph = null;
 let storedHasher = null;
 async function handleHashTasks(payload) {
-    const { error, projectGraph, allWorkspaceFiles, fileMap, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const { error, projectGraph, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
     if (error) {
         throw error;
     }

package/dist/src/daemon/server/project-graph-incremental-recomputation.d.ts

@@ -1,5 +1,5 @@
 import { Socket } from 'net';
-import { FileData, FileMap, ProjectGraph } from '../../config/project-graph';
+import { FileMap, ProjectGraph } from '../../config/project-graph';
 import { NxWorkspaceFilesExternals } from '../../native';
 import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
@@ -7,8 +7,6 @@ interface SerializedProjectGraph {
     error: Error | null;
     projectGraph: ProjectGraph | null;
     projectFileMapCache: FileMapCache | null;
-    fileMap: FileMap | null;
-    allWorkspaceFiles: FileData[] | null;
     serializedProjectGraph: string | null;
     serializedSourceMaps: string | null;
     sourceMaps: ConfigurationSourceMaps | null;
@@ -16,7 +14,6 @@ interface SerializedProjectGraph {
 }
 export declare let fileMapWithFiles: {
     fileMap: FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals;
 } | undefined;
 export declare let currentProjectFileMapCache: FileMapCache | undefined;

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -113,8 +113,6 @@ async function getCachedSerializedProjectGraphPromise(socket) {
             sourceMaps: null,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
-            allWorkspaceFiles: null,
             rustReferences: null,
         };
     }
@@ -277,9 +275,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
                     error: g.error,
                     projectGraph: null,
                     projectFileMapCache: null,
-                    fileMap: null,
                     rustReferences: null,
-                    allWorkspaceFiles: null,
                     serializedProjectGraph: null,
                     serializedSourceMaps: null,
                     sourceMaps: null,
@@ -291,9 +287,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
                 error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps),
                 projectGraph: null,
                 projectFileMapCache: null,
-                fileMap: null,
                 rustReferences: null,
-                allWorkspaceFiles: null,
                 serializedProjectGraph: null,
                 serializedSourceMaps: null,
                 sourceMaps: null,
@@ -308,9 +302,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
             error: err,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
             rustReferences: null,
-            allWorkspaceFiles: null,
             serializedProjectGraph: null,
             serializedSourceMaps: null,
             sourceMaps: null,
@@ -334,9 +326,8 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
     try {
         perf_hooks_1.performance.mark('create-project-graph-start');
         const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
-        const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
         const rustReferences = exports.fileMapWithFiles.rustReferences;
-        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)(), sourceMaps);
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)(), sourceMaps);
         exports.currentProjectFileMapCache = projectFileMapCache;
         exports.currentProjectGraph = projectGraph;
         exports.currentSourceMaps = sourceMaps;
@@ -351,8 +342,6 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
             error: null,
             projectGraph,
             projectFileMapCache,
-            fileMap,
-            allWorkspaceFiles,
             serializedProjectGraph,
             serializedSourceMaps,
             sourceMaps,
@@ -365,8 +354,6 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
             error: e,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
-            allWorkspaceFiles: null,
             serializedProjectGraph: null,
             serializedSourceMaps: null,
             sourceMaps: null,

package/dist/src/daemon/server/server.js

@@ -6,7 +6,6 @@ exports.startServer = startServer;
 const fs_1 = require("fs");
 const net_1 = require("net");
 const path_1 = require("path");
-const v8_1 = require("v8");
 const analytics_1 = require("../../analytics");
 const file_hasher_1 = require("../../hasher/file-hasher");
 const native_1 = require("../../native");
@@ -76,7 +75,16 @@ const server = (0, net_1.createServer)(async (socket) => {
     logger_1.serverLogger.log(`Established a connection. Number of open connections: ${numberOfOpenConnections}`);
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (message) => {
-        await handleMessage(socket, message);
+        // A rejection here would otherwise be unhandled and take the daemon
+        // down with it, failing every other client's request too.
+        await handleMessage(socket, message).catch(async (e) => {
+            await (0, shutdown_utils_1.respondWithError)(socket, 'Error handling message', e);
+        });
+    }, (err) => {
+        logger_1.serverLogger.log(`Framing error: ${err.message}`);
+        // The stream cannot resynchronize, so close it and let the client
+        // observe the disconnect instead of waiting on a reply.
+        (0, shutdown_utils_1.respondWithError)(socket, 'Malformed message', err).finally(() => socket.destroy());
     }));
     socket.on('error', (e) => {
         logger_1.serverLogger.log(`Socket error: ${e.message}`);
@@ -99,21 +107,14 @@ async function handleMessage(socket, data) {
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     const unparsedPayload = data;
     let payload;
-    let mode = 'json';
+    // Reply in the format the client used.
+    const mode = (0, consume_messages_from_socket_1.isJsonMessage)(unparsedPayload) ? 'json' : 'v8';
     logger_1.serverLogger.log(`Received raw message of length ${unparsedPayload.length}`);
     try {
-        // JSON Message
-        if ((0, consume_messages_from_socket_1.isJsonMessage)(unparsedPayload)) {
-            payload = JSON.parse(unparsedPayload);
-        }
-        else {
-            // V8 Serialized Message
-            payload = (0, v8_1.deserialize)(Buffer.from(unparsedPayload, 'binary'));
-            mode = 'v8';
-        }
+        payload = (0, consume_messages_from_socket_1.parseMessage)(unparsedPayload);
     }
     catch (e) {
-        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${(0, consume_messages_from_socket_1.describeMessage)(unparsedPayload, { maxBytes: 200 })}`));
     }
     logger_1.serverLogger.log(`Received ${mode} message of type ${payload.type}`);
     // A mismatch means the client reached the wrong daemon (e.g. a shared
@@ -233,7 +234,7 @@ async function handleMessage(socket, data) {
         await handleResult(socket, configure_ai_agents_1.RESET_CONFIGURE_AI_AGENTS_STATUS, () => (0, handle_configure_ai_agents_1.handleResetConfigureAiAgentsStatus)(), mode);
     }
     else {
-        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${(0, consume_messages_from_socket_1.describeMessage)(unparsedPayload, { maxBytes: 200 })}`));
     }
 }
 async function handleResult(socket, type, hrFn, mode) {
@@ -252,8 +253,8 @@ async function handleResult(socket, type, hrFn, mode) {
     else {
         logger_1.serverLogger.log(`Serializing response for ${type} message in ${mode} mode`);
         const response = typeof hr.response === 'string'
-            ? hr.response
-            : serializeUnserializedResult(hr.response, mode);
+            ? Buffer.from(hr.response, 'utf8')
+            : (0, socket_utils_1.serializeWithFallback)(hr.response, mode);
         logger_1.serverLogger.log(`Responding to ${type} message`);
         await (0, shutdown_utils_1.respondToClient)(socket, response, hr.description);
     }
@@ -531,11 +532,3 @@ function forwardEnvToPluginWorkers(env) {
         // Plugins may not be loaded yet — env will be picked up on next load
     });
 }
-function serializeUnserializedResult(response, mode) {
-    if (mode === 'json') {
-        return JSON.stringify(response);
-    }
-    else {
-        return (0, v8_1.serialize)(response).toString('binary');
-    }
-}

package/dist/src/daemon/server/shutdown-utils.d.ts

@@ -13,7 +13,7 @@ interface HandleServerProcessTerminationParams {
 export declare function handleServerProcessTermination({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
 export declare function handleServerProcessTerminationWithRestart({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
 export declare function resetInactivityTimeout(cb: () => void): void;
-export declare function respondToClient(socket: Socket, response: string, description: string): Promise<unknown>;
+export declare function respondToClient(socket: Socket, response: Buffer, description: string): Promise<unknown>;
 /**
  * Send an error to the client without terminating the daemon. Use this when the
  * daemon should keep running for other clients after refusing a request.

package/dist/src/daemon/server/shutdown-utils.js

@@ -127,7 +127,7 @@ function respondToClient(socket, response, description) {
         if (description) {
             logger_1.serverLogger.requestLog(`Responding to the client.`, description);
         }
-        socket.write(response + consume_messages_from_socket_1.MESSAGE_END_SEQ, (err) => {
+        (0, consume_messages_from_socket_1.writeMessage)(socket, response, (err) => {
             if (err) {
                 logger_1.serverLogger.log(`Socket write error (client likely disconnected): ${err.message}`);
             }
@@ -148,7 +148,7 @@ async function respondWithError(socket, description, error) {
     logger_1.serverLogger.requestLog(`Responding to the client with an error.`, description, normalizedError.message);
     console.error(normalizedError.stack);
     // Respond with the original error
-    await respondToClient(socket, (0, socket_utils_1.serializeResult)(error, null, null), null);
+    await respondToClient(socket, Buffer.from((0, socket_utils_1.serializeResult)(error, null, null), 'utf8'), null);
 }
 async function respondWithErrorAndExit(socket, description, error) {
     await respondWithError(socket, description, error);

package/dist/src/daemon/socket-utils.d.ts

@@ -1,3 +1,4 @@
+import type { Socket } from 'net';
 export declare const isWindows: boolean;
 /**
  * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
@@ -12,13 +13,31 @@ export declare function getPluginSocketFileName(id: string): string;
 export declare function killSocketOrPath(): void;
 export declare function serializeResult(error: Error | null, serializedProjectGraph: string | null, serializedSourceMaps: string | null): string | null;
 /**
- * Helper to serialize data either using v8 serialization or JSON serialization, based on
- * the user's preference and the success of each method. Should only be used by "client" side
- * connections, daemon or other servers should respond based on the type of serialization used
- * by the client it is communicating with.
+ * Serialize using `preferred`, falling back to the other format when it throws.
+ * Neither format subsumes the other: JSON cannot represent a BigInt and hits the
+ * max string length far sooner, while v8 cannot clone a function.
  *
  * @param data Data to serialize
- * @param force Forces one serialization method over the other
- * @returns Serialized data as a string
+ * @param preferred Format to attempt first
+ * @returns Serialized data as bytes ready to be framed onto a socket
  */
-export declare function serialize(data: any, force?: 'v8' | 'json'): string;
+export declare function serializeWithFallback(data: any, preferred: 'v8' | 'json'): Buffer;
+/**
+ * Serialize data for IPC using the format the user configured.
+ *
+ * @param data Data to serialize
+ * @param force Use this format without falling back. For callers whose data is
+ *              known to be unrepresentable in the other format, where a fallback
+ *              would only swap one failure for a less obvious one.
+ * @returns Serialized data as bytes ready to be framed onto a socket
+ */
+export declare function serialize(data: any, force?: 'v8' | 'json'): Buffer;
+/**
+ * Serialize `data` and write it as one framed message.
+ *
+ * Lives here rather than in `writeMessage` so the framing stays a byte-level
+ * primitive: `utils/consume-messages-from-socket` is shared by callers that
+ * already hold bytes, and having it reach back into the daemon's serializer
+ * would invert the dependency.
+ */
+export declare function sendMessage(socket: Socket, data: any, force?: 'v8' | 'json', callback?: (err?: Error) => void): void;