@use-tusk/drift-node-sdk 0.1.12 → 0.1.13

package/dist/index.cjs

@@ -276,15 +276,6 @@ var TdInstrumentationAbstract = class {
 	}
 };
 
-//#endregion
-//#region package.json
-var version = "0.1.12";
-
-//#endregion
-//#region src/version.ts
-const SDK_VERSION = version;
-const MIN_CLI_VERSION = "0.1.0";
-
 //#endregion
 //#region src/core/utils/dataNormalizationUtils.ts
 /**
@@ -564,51 +555,40 @@ const logger = {
 
 //#endregion
 //#region src/core/analytics/analyticsUtils.ts
-function sendAnalyticsPayload(payload) {
-	try {
-		if (TuskDriftCore.getInstance().getConfig().recording?.enable_analytics) {}
-	} catch (e) {
-		logger.error("Error sending analytics event:", e);
-	}
-}
-function sendTdAnalytics(eventName, properties = {}) {
-	const serviceId = TuskDriftCore.getInstance().getConfig().service?.id || "unknown-service";
-	const payload = {
-		distinctId: `tusk-drift:${serviceId}`,
-		event: `${eventName}`,
-		properties: {
-			serviceId,
-			tdMode: TuskDriftCore.getInstance().getMode(),
-			sdkVersion: SDK_VERSION,
-			...properties
-		}
-	};
-	sendAnalyticsPayload(payload);
-}
 /**
-* NOTE: analytics has not been implemented yet, so this function does nothing
+* Send version mismatch alert to CLI (only in REPLAY mode)
 */
 function sendVersionMismatchAlert({ moduleName, foundVersion, supportedVersions }) {
+	logger.info("Sending version mismatch alert", {
+		moduleName,
+		foundVersion,
+		supportedVersions
+	});
 	try {
-		sendTdAnalytics("version_mismatch", {
+		if (TuskDriftCore.getInstance().getMode() !== TuskDriftMode.REPLAY) return;
+		const protobufComm = TuskDriftCore.getInstance().getProtobufCommunicator();
+		if (protobufComm) protobufComm.sendInstrumentationVersionMismatchAlert({
 			moduleName,
-			foundVersion: foundVersion || "unknown",
-			supportedVersions: supportedVersions.join(", ")
+			requestedVersion: foundVersion,
+			supportedVersions
 		});
 	} catch (e) {
 		logger.error("Error sending version mismatch alert:", e);
 	}
 }
 /**
-* NOTE: analytics has not been implemented yet, so this function does nothing
+* Send unpatched dependency alert to CLI
 */
-function sendUnpatchedDependencyAlert({ method, spanId, traceId, stackTrace }) {
+function sendUnpatchedDependencyAlert({ traceTestServerSpanId, stackTrace }) {
+	logger.info("Sending unpatched dependency alert", {
+		traceTestServerSpanId,
+		stackTrace
+	});
 	try {
-		sendTdAnalytics("unpatched_dependency", {
-			method,
-			spanId,
-			traceId,
-			stackTrace: stackTrace ? stackTrace.split("\n").slice(0, 10).join("\n") : void 0
+		const protobufComm = TuskDriftCore.getInstance().getProtobufCommunicator();
+		if (protobufComm && stackTrace) protobufComm.sendUnpatchedDependencyAlert({
+			stackTrace,
+			traceTestServerSpanId
 		});
 	} catch (e) {
 		logger.error("Error sending unpatched dependency alert:", e);
@@ -2039,9 +2019,12 @@ var HttpReplayHooks = class {
 		const traceIdHeader = req.headers["x-td-trace-id"] || req.headers["X-TD-TRACE-ID"];
 		return traceIdHeader ? String(traceIdHeader) : null;
 	}
-	extractEnvVarsFromHeaders(req) {
-		const envVarsHeader = req.headers["x-td-env-vars"] || req.headers["X-TD-ENV-VARS"];
-		return envVarsHeader ? JSON.parse(String(envVarsHeader)) : void 0;
+	/**
+	* Check if we should fetch env vars from CLI
+	*/
+	extractShouldFetchEnvVars(req) {
+		const fetchHeader = req.headers["x-td-fetch-env-vars"] || req.headers["X-TD-FETCH-ENV-VARS"];
+		return fetchHeader === "true" || fetchHeader === true;
 	}
 	/**
 	* Handle outbound HTTP requests in replay mode
@@ -2654,8 +2637,13 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					return originalHandler.call(this);
 				}
 				logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
-				const envVars = this.replayHooks.extractEnvVarsFromHeaders(req);
-				if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+				if (this.replayHooks.extractShouldFetchEnvVars(req)) try {
+					const envVars = this.tuskDrift.requestEnvVarsSync(replayTraceId);
+					EnvVarTracker.setEnvVars(replayTraceId, envVars);
+					logger.debug(`[HttpInstrumentation] Fetched env vars from CLI for trace ${replayTraceId}`);
+				} catch (error) {
+					logger.error(`[HttpInstrumentation] Failed to fetch env vars from CLI:`, error);
+				}
 				const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
 				if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
 				return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
@@ -6189,12 +6177,13 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 				traceId: currentSpanInfo.traceId,
 				socketContext
 			});
-			logger.warn(`[TcpInstrumentation] Full stack trace:\n${(/* @__PURE__ */ new Error()).stack}`);
+			const stackTrace = (/* @__PURE__ */ new Error()).stack || "";
+			const traceTestServerSpanId = SpanUtils.getCurrentReplayTraceId();
+			logger.warn(`[TcpInstrumentation] Full stack trace:\n${stackTrace}`, { traceTestServerSpanId });
 			Error.stackTraceLimit = 10;
 			sendUnpatchedDependencyAlert({
-				method: methodName,
-				spanId: currentSpanInfo.spanId,
-				traceId: currentSpanInfo.traceId
+				traceTestServerSpanId: traceTestServerSpanId || "",
+				stackTrace
 			});
 			if (this.loggedSpans.size > 1e3) {
 				logger.debug(`[TcpInstrumentation] Cleaning up logged spans cache (${this.loggedSpans.size} entries)`);
@@ -9633,8 +9622,13 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 							return originalHandleRequest.call(this, req, res, parsedUrl);
 						}
 						logger.debug(`[NextjsInstrumentation] Setting replay trace id`, replayTraceId);
-						const envVars = self.replayHooks.extractEnvVarsFromHeaders(req);
-						if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+						if (self.replayHooks.extractShouldFetchEnvVars(req)) try {
+							const envVars = self.tuskDrift.requestEnvVarsSync(replayTraceId);
+							EnvVarTracker.setEnvVars(replayTraceId, envVars);
+							logger.debug(`[NextjsInstrumentation] Fetched env vars from CLI for trace ${replayTraceId}`);
+						} catch (error) {
+							logger.error(`[NextjsInstrumentation] Failed to fetch env vars from CLI:`, error);
+						}
 						const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
 						if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
 						return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
@@ -12673,9 +12667,18 @@ var TdSpanExporter = class {
 	}
 };
 
+//#endregion
+//#region package.json
+var version = "0.1.13";
+
+//#endregion
+//#region src/version.ts
+const SDK_VERSION = version;
+const MIN_CLI_VERSION = "0.1.0";
+
 //#endregion
 //#region src/core/ProtobufCommunicator.ts
-var ProtobufCommunicator = class {
+var ProtobufCommunicator = class ProtobufCommunicator {
 	constructor() {
 		this.client = null;
 		this.pendingRequests = /* @__PURE__ */ new Map();
@@ -12773,43 +12776,18 @@ var ProtobufCommunicator = class {
 		});
 	}
 	/**
-	* This function uses a separate Node.js child process to communicate with the CLI over a socket.
-	* The child process creates its own connection and event loop, allowing proper async socket handling.
-	* The parent process blocks synchronously waiting for the child to complete.
-	*
-	* Since this function blocks the main thread, there is a performance impact. We should use requestMockAsync whenever possible and only use this function
-	* for instrumentations that require fetching mocks synchronously.
+	* Generic synchronous request handler that spawns a child process.
+	* @param sdkMessage The SDK message to send
+	* @param filePrefix Prefix for temporary files (e.g., 'envvar', 'mock')
+	* @param responseHandler Function to extract and return the desired response
 	*/
-	requestMockSync(mockRequest) {
-		const requestId = this.generateRequestId();
-		const cleanSpan = mockRequest.outboundSpan ? this.cleanSpan(mockRequest.outboundSpan) : void 0;
-		if (cleanSpan?.inputValue) cleanSpan.inputValue = objectToProtobufStruct(cleanSpan.inputValue);
-		if (cleanSpan?.inputSchema) cleanSpan.inputSchema = objectToProtobufStruct(cleanSpan.inputSchema);
-		if (cleanSpan?.kind) cleanSpan.kind = mapOtToPb(cleanSpan.kind);
-		const protoMockRequest = __use_tusk_drift_schemas_core_communication.GetMockRequest.create({
-			...mockRequest,
-			requestId,
-			tags: {},
-			outboundSpan: cleanSpan,
-			stackTrace: cleanSpan?.stackTrace
-		});
-		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
-			type: __use_tusk_drift_schemas_core_communication.MessageType.MOCK_REQUEST,
-			requestId,
-			payload: {
-				oneofKind: "getMockRequest",
-				getMockRequest: protoMockRequest
-			}
-		});
-		logger.debug("Sending protobuf request to CLI (sync)", {
-			outboundSpan: mockRequest.outboundSpan,
-			testId: mockRequest.testId
-		});
+	executeSyncRequest(sdkMessage, filePrefix, responseHandler) {
+		const requestId = sdkMessage.requestId;
 		const messageBytes = __use_tusk_drift_schemas_core_communication.SDKMessage.toBinary(sdkMessage);
 		const tempDir = os.default.tmpdir();
-		const requestFile = path.default.join(tempDir, `tusk-sync-request-${requestId}.bin`);
-		const responseFile = path.default.join(tempDir, `tusk-sync-response-${requestId}.bin`);
-		const scriptFile = path.default.join(tempDir, `tusk-sync-script-${requestId}.js`);
+		const requestFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-request-${requestId}.bin`);
+		const responseFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-response-${requestId}.bin`);
+		const scriptFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-script-${requestId}.js`);
 		try {
 			const lengthBuffer = Buffer.allocUnsafe(4);
 			lengthBuffer.writeUInt32BE(messageBytes.length, 0);
@@ -12832,95 +12810,7 @@ var ProtobufCommunicator = class {
 				type: "unix",
 				path: path.default.join(os.default.tmpdir(), "tusk-connect.sock")
 			};
-			fs.default.writeFileSync(scriptFile, `
-const net = require('net');
-const fs = require('fs');
-
-const requestFile = process.argv[2];
-const responseFile = process.argv[3];
-const config = JSON.parse(process.argv[4]);
-
-let responseReceived = false;
-let timeoutId;
-
-function cleanup(exitCode) {
-  if (timeoutId) clearTimeout(timeoutId);
-  process.exit(exitCode);
-}
-
-try {
-  // Read the request data
-  const requestData = fs.readFileSync(requestFile);
-  
-  // Create connection based on config
-  const client = config.type === 'unix' 
-    ? net.createConnection({ path: config.path })
-    : net.createConnection({ host: config.host, port: config.port });
-
-  const incomingChunks = [];
-  let incomingBuffer = Buffer.alloc(0);
-
-  // Set timeout
-  timeoutId = setTimeout(() => {
-    if (!responseReceived) {
-      console.error('Timeout waiting for response');
-      client.destroy();
-      cleanup(1);
-    }
-  }, 10000);
-
-  client.on('connect', () => {
-    // Send the request
-    client.write(requestData);
-  });
-
-  client.on('data', (data) => {
-    incomingBuffer = Buffer.concat([incomingBuffer, data]);
-    
-    // Try to parse complete message (4 byte length prefix + message)
-    while (incomingBuffer.length >= 4) {
-      const messageLength = incomingBuffer.readUInt32BE(0);
-      
-      if (incomingBuffer.length < 4 + messageLength) {
-        // Incomplete message, wait for more data
-        break;
-      }
-      
-      // We have a complete message
-      const messageData = incomingBuffer.slice(4, 4 + messageLength);
-      incomingBuffer = incomingBuffer.slice(4 + messageLength);
-      
-      // Write the complete response (including length prefix)
-      const lengthPrefix = Buffer.allocUnsafe(4);
-      lengthPrefix.writeUInt32BE(messageLength, 0);
-      fs.writeFileSync(responseFile, Buffer.concat([lengthPrefix, messageData]));
-      
-      responseReceived = true;
-      client.destroy();
-      cleanup(0);
-      break;
-    }
-  });
-
-  client.on('error', (err) => {
-    if (!responseReceived) {
-      console.error('Connection error:', err.message);
-      cleanup(1);
-    }
-  });
-
-  client.on('close', () => {
-    if (!responseReceived) {
-      console.error('Connection closed without response');
-      cleanup(1);
-    }
-  });
-
-} catch (err) {
-  console.error('Script error:', err.message);
-  cleanup(1);
-}
-`);
+			fs.default.writeFileSync(scriptFile, ProtobufCommunicator.SYNC_CHILD_SCRIPT);
 			try {
 				(0, child_process.execSync)(`node "${scriptFile}" "${requestFile}" "${responseFile}" '${JSON.stringify(connectionConfig)}'`, {
 					timeout: 12e3,
@@ -12932,27 +12822,13 @@ try {
 				if (responseBuffer.length < 4 + responseLength) throw new Error("Invalid response: incomplete message");
 				const responseData = responseBuffer.slice(4, 4 + responseLength);
 				const cliMessage = __use_tusk_drift_schemas_core_communication.CLIMessage.fromBinary(responseData);
-				if (cliMessage.payload.oneofKind !== "getMockResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
-				const mockResponse = cliMessage.payload.getMockResponse;
-				if (!mockResponse) throw new Error("No mock response received");
-				if (mockResponse.found) try {
-					return {
-						found: true,
-						response: this.extractResponseData(mockResponse)
-					};
-				} catch (error) {
-					throw new Error(`Failed to extract response data: ${error}`);
-				}
-				else return {
-					found: false,
-					error: mockResponse.error || "Mock not found"
-				};
+				return responseHandler(cliMessage);
 			} catch (error) {
-				logger.error("[ProtobufCommunicator] error in sync request child process:", error);
+				logger.error(`[ProtobufCommunicator] error in sync ${filePrefix} request child process:`, error);
 				throw error;
 			}
 		} catch (error) {
-			throw new Error(`Sync request failed: ${error.message}`);
+			throw new Error(`Sync ${filePrefix} request failed: ${error.message}`);
 		} finally {
 			try {
 				if (fs.default.existsSync(requestFile)) fs.default.unlinkSync(requestFile);
@@ -12971,6 +12847,86 @@ try {
 			}
 		}
 	}
+	/**
+	* Request environment variables from CLI synchronously using a child process.
+	* This blocks the main thread, so it should be used carefully.
+	* Similar to requestMockSync but for environment variables.
+	*/
+	requestEnvVarsSync(traceTestServerSpanId) {
+		const requestId = this.generateRequestId();
+		const envVarRequest = __use_tusk_drift_schemas_core_communication.EnvVarRequest.create({ traceTestServerSpanId });
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.ENV_VAR_REQUEST,
+			requestId,
+			payload: {
+				oneofKind: "envVarRequest",
+				envVarRequest
+			}
+		});
+		logger.debug(`[ProtobufCommunicator] Requesting env vars (sync) for trace: ${traceTestServerSpanId}`);
+		return this.executeSyncRequest(sdkMessage, "envvar", (cliMessage) => {
+			if (cliMessage.payload.oneofKind !== "envVarResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
+			const envVarResponse = cliMessage.payload.envVarResponse;
+			if (!envVarResponse) throw new Error("No env var response received");
+			const envVars = {};
+			if (envVarResponse.envVars) Object.entries(envVarResponse.envVars).forEach(([key, value]) => {
+				envVars[key] = value;
+			});
+			logger.debug(`[ProtobufCommunicator] Received env vars (sync), count: ${Object.keys(envVars).length}`);
+			return envVars;
+		});
+	}
+	/**
+	* This function uses a separate Node.js child process to communicate with the CLI over a socket.
+	* The child process creates its own connection and event loop, allowing proper async socket handling.
+	* The parent process blocks synchronously waiting for the child to complete.
+	*
+	* Since this function blocks the main thread, there is a performance impact. We should use requestMockAsync whenever possible and only use this function
+	* for instrumentations that require fetching mocks synchronously.
+	*/
+	requestMockSync(mockRequest) {
+		const requestId = this.generateRequestId();
+		const cleanSpan = mockRequest.outboundSpan ? this.cleanSpan(mockRequest.outboundSpan) : void 0;
+		if (cleanSpan?.inputValue) cleanSpan.inputValue = objectToProtobufStruct(cleanSpan.inputValue);
+		if (cleanSpan?.inputSchema) cleanSpan.inputSchema = objectToProtobufStruct(cleanSpan.inputSchema);
+		if (cleanSpan?.kind) cleanSpan.kind = mapOtToPb(cleanSpan.kind);
+		const protoMockRequest = __use_tusk_drift_schemas_core_communication.GetMockRequest.create({
+			...mockRequest,
+			requestId,
+			tags: {},
+			outboundSpan: cleanSpan,
+			stackTrace: cleanSpan?.stackTrace
+		});
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.MOCK_REQUEST,
+			requestId,
+			payload: {
+				oneofKind: "getMockRequest",
+				getMockRequest: protoMockRequest
+			}
+		});
+		logger.debug("Sending protobuf request to CLI (sync)", {
+			outboundSpan: mockRequest.outboundSpan,
+			testId: mockRequest.testId
+		});
+		return this.executeSyncRequest(sdkMessage, "mock", (cliMessage) => {
+			if (cliMessage.payload.oneofKind !== "getMockResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
+			const mockResponse = cliMessage.payload.getMockResponse;
+			if (!mockResponse) throw new Error("No mock response received");
+			if (mockResponse.found) try {
+				return {
+					found: true,
+					response: this.extractResponseData(mockResponse)
+				};
+			} catch (error) {
+				throw new Error(`Failed to extract response data: ${error}`);
+			}
+			else return {
+				found: false,
+				error: mockResponse.error || "Mock not found"
+			};
+		});
+	}
 	async sendProtobufMessage(message) {
 		if (!this.client || !this.protobufContext) throw new Error("Not connected to CLI");
 		const messageBytes = __use_tusk_drift_schemas_core_communication.SDKMessage.toBinary(message);
@@ -13023,6 +12979,58 @@ try {
 		});
 		await this.sendProtobufMessage(sdkMessage);
 	}
+	/**
+	* Send an alert to the CLI (fire-and-forget, no response expected)
+	*/
+	async sendAlert(alert) {
+		if (!this.client || !this.protobufContext) {
+			logger.debug("[ProtobufCommunicator] Not connected to CLI, skipping alert");
+			return;
+		}
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.ALERT,
+			requestId: this.generateRequestId(),
+			payload: {
+				oneofKind: "sendAlertRequest",
+				sendAlertRequest: alert
+			}
+		});
+		try {
+			await this.sendProtobufMessage(sdkMessage);
+			logger.debug("[ProtobufCommunicator] Alert sent to CLI");
+		} catch (error) {
+			logger.debug("[ProtobufCommunicator] Failed to send alert to CLI:", error);
+		}
+	}
+	/**
+	* Send instrumentation version mismatch alert to CLI
+	*/
+	async sendInstrumentationVersionMismatchAlert(params) {
+		const alert = __use_tusk_drift_schemas_core_communication.SendAlertRequest.create({ alert: {
+			oneofKind: "versionMismatch",
+			versionMismatch: __use_tusk_drift_schemas_core_communication.InstrumentationVersionMismatchAlert.create({
+				moduleName: params.moduleName,
+				requestedVersion: params.requestedVersion || "",
+				supportedVersions: params.supportedVersions,
+				sdkVersion: SDK_VERSION
+			})
+		} });
+		await this.sendAlert(alert);
+	}
+	/**
+	* Send unpatched dependency alert to CLI
+	*/
+	async sendUnpatchedDependencyAlert(params) {
+		const alert = __use_tusk_drift_schemas_core_communication.SendAlertRequest.create({ alert: {
+			oneofKind: "unpatchedDependency",
+			unpatchedDependency: __use_tusk_drift_schemas_core_communication.UnpatchedDependencyAlert.create({
+				stackTrace: params.stackTrace,
+				traceTestServerSpanId: params.traceTestServerSpanId,
+				sdkVersion: SDK_VERSION
+			})
+		} });
+		await this.sendAlert(alert);
+	}
 	handleIncomingData(data) {
 		this.incomingBuffer = Buffer.concat([this.incomingBuffer, data]);
 		logger.debug(`[ProtobufCommunicator] Processing buffer, length: ${this.incomingBuffer.length}`);
@@ -13080,6 +13088,22 @@ try {
 				error: mockResponse.error || "Mock not found"
 			});
 		}
+		if (message.payload.oneofKind === "envVarResponse") {
+			const envVarResponse = message.payload.envVarResponse;
+			logger.debug(`[ProtobufCommunicator] Received env var response for requestId: ${requestId}`);
+			const pendingRequest = this.pendingRequests.get(requestId);
+			if (!pendingRequest) {
+				logger.warn("[ProtobufCommunicator] received env var response for unknown request:", requestId);
+				return;
+			}
+			this.pendingRequests.delete(requestId);
+			const envVars = {};
+			if (envVarResponse?.envVars) Object.entries(envVarResponse.envVars).forEach(([key, value]) => {
+				envVars[key] = value;
+			});
+			pendingRequest.resolve(envVars);
+			return;
+		}
 	}
 	/**
 	* Extract response data from MockResponse
@@ -13122,6 +13146,95 @@ try {
 		}
 	}
 };
+ProtobufCommunicator.SYNC_CHILD_SCRIPT = `
+const net = require('net');
+const fs = require('fs');
+
+const requestFile = process.argv[2];
+const responseFile = process.argv[3];
+const config = JSON.parse(process.argv[4]);
+
+let responseReceived = false;
+let timeoutId;
+
+function cleanup(exitCode) {
+  if (timeoutId) clearTimeout(timeoutId);
+  process.exit(exitCode);
+}
+
+try {
+  // Read the request data
+  const requestData = fs.readFileSync(requestFile);
+
+  // Create connection based on config
+  const client = config.type === 'unix'
+    ? net.createConnection({ path: config.path })
+    : net.createConnection({ host: config.host, port: config.port });
+
+  const incomingChunks = [];
+  let incomingBuffer = Buffer.alloc(0);
+
+  // Set timeout
+  timeoutId = setTimeout(() => {
+    if (!responseReceived) {
+      console.error('Timeout waiting for response');
+      client.destroy();
+      cleanup(1);
+    }
+  }, 10000);
+
+  client.on('connect', () => {
+    // Send the request
+    client.write(requestData);
+  });
+
+  client.on('data', (data) => {
+    incomingBuffer = Buffer.concat([incomingBuffer, data]);
+
+    // Try to parse complete message (4 byte length prefix + message)
+    while (incomingBuffer.length >= 4) {
+      const messageLength = incomingBuffer.readUInt32BE(0);
+
+      if (incomingBuffer.length < 4 + messageLength) {
+        // Incomplete message, wait for more data
+        break;
+      }
+
+      // We have a complete message
+      const messageData = incomingBuffer.slice(4, 4 + messageLength);
+      incomingBuffer = incomingBuffer.slice(4 + messageLength);
+
+      // Write the complete response (including length prefix)
+      const lengthPrefix = Buffer.allocUnsafe(4);
+      lengthPrefix.writeUInt32BE(messageLength, 0);
+      fs.writeFileSync(responseFile, Buffer.concat([lengthPrefix, messageData]));
+
+      responseReceived = true;
+      client.destroy();
+      cleanup(0);
+      break;
+    }
+  });
+
+  client.on('error', (err) => {
+    if (!responseReceived) {
+      console.error('Connection error:', err.message);
+      cleanup(1);
+    }
+  });
+
+  client.on('close', () => {
+    if (!responseReceived) {
+      console.error('Connection closed without response');
+      cleanup(1);
+    }
+  });
+
+} catch (err) {
+  console.error('Script error:', err.message);
+  cleanup(1);
+}
+`;
 
 //#endregion
 //#region src/core/TuskDriftInstrumentationModuleNames.ts
@@ -13474,6 +13587,30 @@ var TuskDriftCore = class TuskDriftCore {
 			};
 		}
 	}
+	/**
+	* Request environment variables from CLI for a specific trace (synchronously).
+	* This blocks the main thread, so it should be used carefully.
+	*/
+	requestEnvVarsSync(traceTestServerSpanId) {
+		if (!this.isConnectedWithCLI) {
+			logger.error("Requesting sync env vars but CLI is not ready yet");
+			throw new Error("Requesting sync env vars but CLI is not ready yet");
+		}
+		if (!this.communicator || this.mode !== TuskDriftMode.REPLAY) {
+			logger.debug("Cannot request env vars: not in replay mode or no CLI connection");
+			return {};
+		}
+		try {
+			logger.debug(`Requesting env vars (sync) for trace: ${traceTestServerSpanId}`);
+			const envVars = this.communicator.requestEnvVarsSync(traceTestServerSpanId);
+			logger.debug(`Received env vars from CLI, count: ${Object.keys(envVars).length}`);
+			logger.debug(`First 10 env vars: ${JSON.stringify(Object.keys(envVars).slice(0, 10), null, 2)}`);
+			return envVars;
+		} catch (error) {
+			logger.error(`[TuskDrift] Error requesting env vars from CLI:`, error);
+			return {};
+		}
+	}
 	requestMockSync(mockRequest) {
 		if (!this.isConnectedWithCLI) {
 			logger.error("Requesting sync mock but CLI is not ready yet");
@@ -13528,6 +13665,9 @@ var TuskDriftCore = class TuskDriftCore {
 	getTracer() {
 		return __opentelemetry_api.trace.getTracer(TD_INSTRUMENTATION_LIBRARY_NAME);
 	}
+	getProtobufCommunicator() {
+		return this.communicator;
+	}
 };
 var TuskDriftSDK = class {
 	constructor() {