parser: Fix another complex log parsing example

Author: addshore

utils/ByteStringParser.test.ts

@@ -183,6 +183,31 @@ describe('ByteStringParser', () => {
                 }
                 expect(foundIndex).toBe(expectedBytes.length);
             });
+
+            it('should parse continuous hex from messy logs (no spaces)', () => {
+                const input = `gingin-chasm-1  | [00] 2025-10-16T10:50:50.203Z INFO    in/udp.go:296   Received NATS message to send to device 10579203: 033a00d00700000100012dd300244090270e4750504e554c4c414e54454e4e4100000d5452494d424c4520414c4c4f59000053881f0000000048`;
+                const result = parseByteString(input);
+                expect(result.hasHex).toBe(true);
+                // The hex string should be parsed
+                expect(result.bytes.length).toBeGreaterThan(0);
+                // Check that we got the expected bytes at the start
+                expect(result.bytes[0]).toBe(0x03);
+                expect(result.bytes[1]).toBe(0x3a);
+                expect(result.bytes[2]).toBe(0x00);
+                expect(result.bytes[3]).toBe(0xd0);
+            });
+
+            it('should parse multiple continuous hex sequences from logs', () => {
+                const input = `gingin-chasm-1  | [00] 2025-10-16T10:50:50.203Z INFO    in/udp.go:296   Received NATS message to send to device 10579203: 033a00d00700000100012dd300244090270e4750504e554c4c414e54454e4e4100000d5452494d424c4520414c4c4f59000053881f0000000048
+gingin-chasm-1  | [00] 2025-10-16T10:50:50.223Z INFO    in/udp.go:296   Received NATS message to send to device 10579203: 03f800d0070000010001ebd300e24320275bb64582002085560c020000000020204080777fe7e7fa2a427a72428a1a1a23ead8a5490b42dcfef00eca4e5caa5157b3cc680e502484b5100c200c3e30707132827104fb166430da6cdcf3d9e9a3de82f006a3ed4dde3fbcf77a267f0d44ba95b4c0847efe1644b0591281e95008b7fc22e018085ea01692005a480065080a0360385080e1460394a855ff817c9a83d0d01ce508739541b17a0137fe0c4917ae03bee7a37b9e8bedf08fbe22fee9497ba51fecf847fffffffffffffffffffffffffffff800000017db75f65b44545d53755f73f3ad4db84f753af18e37ec434e120000007fed`;
+                const result = parseByteString(input);
+                expect(result.hasHex).toBe(true);
+                // Both messages should be concatenated
+                expect(result.bytes.length).toBeGreaterThan(100);
+                // Check start of first message
+                expect(result.bytes[0]).toBe(0x03);
+                expect(result.bytes[1]).toBe(0x3a);
+            });
         });
 
         describe('mixed and edge cases', () => {

utils/ByteStringParser.ts

@@ -74,7 +74,17 @@ function parseSingleByteString(input: string): ParsedBytes {
     const allHexPattern = /^[0-9a-fA-F]+$/;
 
     if (allHexPattern.test(onlyValid) && /[a-fA-F]/.test(onlyValid) && onlyValid.length >= 4 && onlyValid.length % 2 === 0) {
-        // Calculate how much of the original input is hex chars
+        // Check if there's a continuous hex sequence in the ORIGINAL input that's long enough (10+ bytes = 20+ chars)
+        // This handles cases where hex is embedded in messy logs
+        const continuousHexPattern = /[0-9a-fA-F]{20,}/g;
+        const continuousSequences = normalized.match(continuousHexPattern) || [];
+
+        if (continuousSequences.length > 0) {
+            // Found a long continuous hex sequence, likely hex mode
+            return parseHexBytes(normalized);
+        }
+
+        // Fallback: calculate how much of the original input is hex chars
         const hexDensity = onlyValid.length / normalized.replace(/\s/g, '').length;
         // If > 70% of non-whitespace chars are valid hex, likely continuous hex
         if (hexDensity > 0.7) {
@@ -94,7 +104,58 @@ function parseSingleByteString(input: string): ParsedBytes {
 function parseHexBytes(input: string): ParsedBytes {
     const bytes: number[] = [];
 
-    // First, try to find 0x-prefixed hex values
+    // First, check for long continuous hex sequences (4+ characters)
+    // These indicate actual hex messages embedded in logs
+    // Do this EARLY before other patterns to prioritize them
+    const continuousHexPattern = /[0-9a-fA-F]{4,}/g;
+    const sequences = input.match(continuousHexPattern) || [];
+
+    // If we found significant continuous sequences, extract all 4+ character sequences
+    // This handles cases where multiple messages are in the same input
+    if (sequences.length > 0) {
+        // Concatenate ALL sequences (even short ones like "2025") to handle multi-message logs
+        // But we'll sort them so we preserve order: keep them in original order from input
+        const hexOnly = sequences.join('');
+
+        // However, if we have a very long sequence (>= 20 chars), prefer just that
+        const significantSequences = sequences.filter(s => s.length >= 20);
+        if (significantSequences.length > 0) {
+            // Use only the significant sequences
+            const significantHex = significantSequences.join('');
+
+            // Parse as pairs of hex digits
+            for (let i = 0; i < significantHex.length; i += 2) {
+                const byteStr = significantHex.substring(i, i + 2);
+                if (byteStr.length === 2) {
+                    const value = parseInt(byteStr, 16);
+                    if (!isNaN(value)) {
+                        bytes.push(value);
+                    }
+                }
+            }
+
+            if (bytes.length > 0) {
+                return { bytes, hasHex: true };
+            }
+        } else {
+            // Use all sequences if none are particularly long
+            for (let i = 0; i < hexOnly.length; i += 2) {
+                const byteStr = hexOnly.substring(i, i + 2);
+                if (byteStr.length === 2) {
+                    const value = parseInt(byteStr, 16);
+                    if (!isNaN(value)) {
+                        bytes.push(value);
+                    }
+                }
+            }
+
+            if (bytes.length > 0) {
+                return { bytes, hasHex: true };
+            }
+        }
+    }
+
+    // Try to find 0x-prefixed hex values
     // Match 0x followed by exactly 1 or 2 hex digits
     // We'll match greedily and process all of them
     const hex0xPattern = /0x([0-9a-fA-F]{1,2})/gi;
@@ -153,7 +214,7 @@ function parseHexBytes(input: string): ParsedBytes {
         return { bytes, hasHex: true };
     }
 
-    // Last resort: extract all valid hex characters as continuous hex
+    // Final fallback: extract all valid hex characters as continuous hex
     // This handles cases like "ffff" without spaces
     const hexOnly = input.replace(/[^0-9a-fA-F]/g, '');