@matter-server/ws-controller 0.2.5 → 0.2.7-alpha.0-20260118-993a1c7

package/src/server/Converters.ts

@@ -293,18 +293,103 @@ const BIGINT_MARKER = "__BIGINT__";
 /**
  * Parse JSON with BigInt support for large numbers that exceed JavaScript precision.
  * Numbers with 15+ digits that exceed MAX_SAFE_INTEGER are converted to BigInt.
+ *
+ * This function carefully avoids modifying numbers that appear inside string values.
  */
 export function parseBigIntAwareJson(json: string): unknown {
     // Pre-process: Replace large numbers (15+ digits) with marked string placeholders
     // This must happen before JSON.parse to preserve precision
-    // Match numbers after colon (object values) or after [ or , (array elements)
-    const processed = json.replace(/([:,[])\s*(\d{15,})(?=[,}\]\s])/g, (match, prefix, number) => {
-        const num = BigInt(number);
-        if (num > Number.MAX_SAFE_INTEGER) {
-            return `${prefix}"${BIGINT_MARKER}${number}"`;
+    // We need to track whether we're inside a string to avoid modifying string contents
+    const result: string[] = [];
+    let i = 0;
+    let inString = false;
+
+    while (i < json.length) {
+        const char = json[i];
+
+        if (inString) {
+            // Inside a string - copy characters as-is until we find the closing quote
+            if (char === "\\") {
+                // Escape sequence - copy both the backslash and the next character
+                result.push(char);
+                i++;
+                if (i < json.length) {
+                    result.push(json[i]);
+                    i++;
+                }
+            } else if (char === '"') {
+                // End of string
+                result.push(char);
+                inString = false;
+                i++;
+            } else {
+                result.push(char);
+                i++;
+            }
+        } else {
+            // Outside a string
+            if (char === '"') {
+                // Start of a string
+                result.push(char);
+                inString = true;
+                i++;
+            } else if (char >= "0" && char <= "9") {
+                // Potential number - extract and check
+                // Check if previous character was a minus sign (for negative numbers)
+                const hasMinus = result.length > 0 && result[result.length - 1] === "-";
+                if (hasMinus) {
+                    result.pop(); // Remove the minus sign, we'll include it in the number
+                }
+
+                // Extract the integer part
+                const start = i;
+                while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+                    i++;
+                }
+
+                // Check for decimal point (fractional number) or exponent
+                let isFloat = false;
+                if (i < json.length && json[i] === ".") {
+                    isFloat = true;
+                    i++; // consume the decimal point
+                    while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+                        i++;
+                    }
+                }
+
+                // Check for exponent (e.g., 1e10, 1E-5)
+                if (i < json.length && (json[i] === "e" || json[i] === "E")) {
+                    isFloat = true;
+                    i++; // consume 'e' or 'E'
+                    if (i < json.length && (json[i] === "+" || json[i] === "-")) {
+                        i++; // consume sign
+                    }
+                    while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+                        i++;
+                    }
+                }
+
+                const numberStr = (hasMinus ? "-" : "") + json.slice(start, i);
+
+                // Only convert integers (not floats) with 15+ digits that exceed safe integer range
+                if (!isFloat && numberStr.length - (hasMinus ? 1 : 0) >= 15) {
+                    const num = BigInt(numberStr);
+                    if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+                        result.push(`"${BIGINT_MARKER}${numberStr}"`);
+                    } else {
+                        result.push(numberStr);
+                    }
+                } else {
+                    result.push(numberStr);
+                }
+            } else {
+                result.push(char);
+                i++;
+            }
         }
-        return match;
-    });
+    }
+
+    const processed = result.join("");
 
     // Parse with reviver to convert marked strings back to BigInt
     return JSON.parse(processed, (_key, value) => {

package/src/server/WebSocketControllerHandler.ts

@@ -405,7 +405,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
             if (result === undefined) {
                 throw new Error("No response");
             }
-            logger.info("WebSocket request handled", messageId, result);
+            logger.info(`WebSocket request (${command}) handled`, messageId, result);
             return {
                 response: {
                     message_id: messageId ?? "",