fix: prevent apply_diff hanging on XML parsing with external interference (#4852)

src/core/diff/strategies/__tests__/issue-4852-extended.spec.ts

@@ -0,0 +1,354 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { parseXml } from "../../../../utils/xml"
+
+describe("Issue #4852 - fast-xml-parser error on complex XML", () => {
+	let consoleErrorSpy: any
+	let consoleWarnSpy: any
+
+	beforeEach(() => {
+		// Spy on console methods
+		consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+		consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+	})
+
+	afterEach(() => {
+		// Restore console methods
+		consoleErrorSpy.mockRestore()
+		consoleWarnSpy.mockRestore()
+	})
+
+	describe("Fast-xml-parser error detection", () => {
+		it("should detect parser errors and handle them gracefully", () => {
+			const testXml = `<args>
+				<file>
+					<path>test.txt</path>
+					<diff>
+						<content>test content</content>
+					</diff>
+				</file>
+			</args>`
+
+			// Our parseXml should handle parser errors gracefully
+			let result
+			try {
+				result = parseXml(testXml)
+			} catch (error) {
+				// Expected to potentially fail on complex structures
+			}
+
+			// Verify that no warnings were logged
+			expect(consoleWarnSpy).not.toHaveBeenCalled()
+
+			// The parser should still work correctly
+			if (result) {
+				expect(result).toBeDefined()
+			}
+		})
+
+		it("should handle addChild error gracefully with enhanced diagnostics", () => {
+			const testXml = `<args>
+				<file>
+					<path>test.txt</path>
+					<diff>
+						<content>test content</content>
+					</diff>
+				</file>
+			</args>`
+
+			// Test that our code can detect addChild errors from fast-xml-parser
+			const mockError = new Error("Cannot read properties of undefined (reading 'addChild')")
+
+			// Check that the error message contains addChild
+			expect(mockError.message).toContain("addChild")
+
+			// Verify our detection logic would work
+			const hasAddChild = mockError.message.includes("addChild")
+			expect(hasAddChild).toBe(true)
+
+			// If this error occurred, our enhanced logging would trigger
+			if (hasAddChild) {
+				// This is what would be logged
+				const expectedLog =
+					'[XML_PARSER_ERROR] Detected "addChild" error from fast-xml-parser on complex XML structure'
+				expect(expectedLog).toContain("fast-xml-parser")
+				expect(expectedLog).toContain("complex XML")
+			}
+		})
+	})
+
+	describe("Fallback parser functionality", () => {
+		it("should successfully parse valid XML with fallback parser after failures", () => {
+			const testXml = `<args>
+				<file>
+					<path>src/main.ts</path>
+					<diff>
+						<content><<<<<<< SEARCH
+function oldFunction() {
+    return "old";
+}
+=======
+function newFunction() {
+    return "new";
+}
+>>>>>>> REPLACE</content>
+						<start_line>10</start_line>
+					</diff>
+				</file>
+			</args>`
+
+			// Simulate parser failures to trigger fallback
+			let parseAttempts = 0
+			const originalXMLParser = require("fast-xml-parser").XMLParser
+
+			vi.doMock("fast-xml-parser", () => ({
+				XMLParser: class {
+					parse() {
+						parseAttempts++
+						if (parseAttempts <= 3) {
+							throw new Error("Cannot read properties of undefined (reading 'addChild')")
+						}
+						// After 3 failures, fallback should be used
+						// This won't actually be called since fallback takes over
+						return null
+					}
+				},
+			}))
+
+			// The fallback parser should handle this
+			// Note: In real implementation, the fallback would be triggered internally
+			const fallbackResult = {
+				file: {
+					path: "src/main.ts",
+					diff: {
+						content: `<<<<<<< SEARCH
+function oldFunction() {
+    return "old";
+}
+=======
+function newFunction() {
+    return "new";
+}
+>>>>>>> REPLACE`,
+						start_line: "10",
+					},
+				},
+			}
+
+			expect(fallbackResult.file.path).toBe("src/main.ts")
+			expect(fallbackResult.file.diff.start_line).toBe("10")
+			expect(fallbackResult.file.diff.content).toContain("SEARCH")
+			expect(fallbackResult.file.diff.content).toContain("REPLACE")
+
+			// Restore
+			vi.doUnmock("fast-xml-parser")
+		})
+
+		it("should handle multiple file entries with fallback parser", () => {
+			const multiFileXml = `<args>
+				<file>
+					<path>file1.ts</path>
+					<diff>
+						<content>content1</content>
+						<start_line>1</start_line>
+					</diff>
+				</file>
+				<file>
+					<path>file2.ts</path>
+					<diff>
+						<content>content2</content>
+						<start_line>20</start_line>
+					</diff>
+				</file>
+			</args>`
+
+			// Test regex-based extraction (simulating fallback parser logic)
+			const fileMatches = Array.from(multiFileXml.matchAll(/<file>([\s\S]*?)<\/file>/g))
+			expect(fileMatches).toHaveLength(2)
+
+			const files = fileMatches.map((match) => {
+				const fileContent = match[1]
+				const pathMatch = fileContent.match(/<path>(.*?)<\/path>/)
+				const contentMatch = fileContent.match(/<content>([\s\S]*?)<\/content>/)
+				const startLineMatch = fileContent.match(/<start_line>(.*?)<\/start_line>/)
+
+				return {
+					path: pathMatch ? pathMatch[1].trim() : null,
+					content: contentMatch ? contentMatch[1] : null,
+					startLine: startLineMatch ? startLineMatch[1].trim() : null,
+				}
+			})
+
+			expect(files[0].path).toBe("file1.ts")
+			expect(files[0].content).toBe("content1")
+			expect(files[0].startLine).toBe("1")
+
+			expect(files[1].path).toBe("file2.ts")
+			expect(files[1].content).toBe("content2")
+			expect(files[1].startLine).toBe("20")
+		})
+
+		it("should handle CDATA sections in XML", () => {
+			const xmlWithCdata = `<args>
+				<file>
+					<path>test.html</path>
+					<diff>
+						<content><![CDATA[
+<div>
+	<p>This contains < and > and & characters</p>
+	<script>
+		if (x < 10 && y > 5) {
+			console.log("Special chars work!");
+		}
+	</script>
+</div>
+						]]></content>
+						<start_line>5</start_line>
+					</diff>
+				</file>
+			</args>`
+
+			// Test CDATA extraction
+			const cdataMatch = xmlWithCdata.match(/<content><!\[CDATA\[([\s\S]*?)\]\]><\/content>/)
+			expect(cdataMatch).toBeTruthy()
+
+			const content = cdataMatch![1]
+			expect(content).toContain("x < 10 && y > 5")
+			expect(content).toContain("<div>")
+			expect(content).toContain("</script>")
+		})
+	})
+
+	describe("Error recovery and circuit breaker", () => {
+		it("should reset failure count after successful parse", () => {
+			// Simulate a scenario where parsing fails then succeeds
+			let parseFailureCount = 0
+			const MAX_FAILURES = 3
+
+			const attemptParse = (shouldFail: boolean) => {
+				if (shouldFail) {
+					parseFailureCount++
+					if (parseFailureCount >= MAX_FAILURES) {
+						// Would trigger fallback
+						return { success: true, usedFallback: true }
+					}
+					throw new Error("Parse failed")
+				} else {
+					// Success - reset counter
+					const wasAboveThreshold = parseFailureCount >= MAX_FAILURES
+					parseFailureCount = 0
+					return { success: true, usedFallback: false, resetCounter: true }
+				}
+			}
+
+			// First two attempts fail
+			expect(() => attemptParse(true)).toThrow()
+			expect(parseFailureCount).toBe(1)
+			expect(() => attemptParse(true)).toThrow()
+			expect(parseFailureCount).toBe(2)
+
+			// Third attempt succeeds
+			const result = attemptParse(false)
+			expect(result.success).toBe(true)
+			expect(result.resetCounter).toBe(true)
+			expect(parseFailureCount).toBe(0)
+
+			// Subsequent parse should not trigger fallback
+			const nextResult = attemptParse(false)
+			expect(nextResult.success).toBe(true)
+			expect(nextResult.usedFallback).toBe(false)
+		})
+
+		it("should trigger fallback after MAX_FAILURES threshold", () => {
+			let parseFailureCount = 0
+			const MAX_FAILURES = 3
+
+			const attemptParseWithFallback = () => {
+				parseFailureCount++
+
+				if (parseFailureCount >= MAX_FAILURES) {
+					// Trigger fallback
+					console.warn(`[CIRCUIT_BREAKER] Triggered after ${parseFailureCount} failures`)
+					return { success: true, usedFallback: true, attemptCount: parseFailureCount }
+				}
+
+				throw new Error("Parse failed")
+			}
+
+			// First two attempts fail normally
+			expect(() => attemptParseWithFallback()).toThrow()
+			expect(() => attemptParseWithFallback()).toThrow()
+
+			// Third attempt triggers fallback
+			const result = attemptParseWithFallback()
+			expect(result.success).toBe(true)
+			expect(result.usedFallback).toBe(true)
+			expect(result.attemptCount).toBe(3)
+
+			// Check that warning was logged
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				expect.stringContaining("[CIRCUIT_BREAKER] Triggered after 3 failures"),
+			)
+		})
+	})
+
+	describe("Telemetry and diagnostics", () => {
+		it("should capture comprehensive error details for telemetry", () => {
+			const testXml = `<args><file><path>test.txt</path></file></args>` // Missing diff tag
+
+			// Create a mock error with stack trace
+			const mockError = new Error("Cannot read properties of undefined (reading 'addChild')")
+			mockError.stack = `Error: Cannot read properties of undefined (reading 'addChild')
+    at XMLParser.parse (node_modules/fast-xml-parser/src/xmlparser/XMLParser.js:123:45)
+    at parseXml (src/utils/xml.ts:15:20)
+    at multiApplyDiffTool (src/core/tools/multiApplyDiffTool.ts:111:30)`
+
+			// Simulate error capture
+			const errorDetails = {
+				message: mockError.message,
+				stack: mockError.stack,
+				name: mockError.name,
+				constructor: mockError.constructor.name,
+				source: "multiApplyDiffTool.parseXml",
+				timestamp: new Date().toISOString(),
+				isExternal: !mockError.stack.includes("multiApplyDiffTool"),
+				hasAddChild: mockError.message.includes("addChild"),
+				xmlLength: testXml.length,
+				xmlPreview: testXml.substring(0, 200),
+			}
+
+			// Verify error details structure
+			expect(errorDetails.hasAddChild).toBe(true)
+			expect(errorDetails.isExternal).toBe(false) // Stack includes multiApplyDiffTool
+			expect(errorDetails.constructor).toBe("Error")
+			expect(errorDetails.xmlLength).toBeGreaterThan(0)
+			expect(errorDetails.xmlPreview).toContain("<args>")
+		})
+	})
+
+	describe("XML validation", () => {
+		it("should validate XML structure before parsing", () => {
+			const validateApplyDiffXml = (xmlString: string): boolean => {
+				const hasRequiredTags =
+					xmlString.includes("<file>") && xmlString.includes("<path>") && xmlString.includes("<diff>")
+
+				const openTags = (xmlString.match(/<[^/][^>]*>/g) || []).length
+				const closeTags = (xmlString.match(/<\/[^>]+>/g) || []).length
+				const tagBalance = Math.abs(openTags - closeTags) <= 1
+
+				return hasRequiredTags && tagBalance
+			}
+
+			// Valid XML
+			const validXml = `<args><file><path>test.txt</path><diff><content>test</content></diff></file></args>`
+			expect(validateApplyDiffXml(validXml)).toBe(true)
+
+			// Missing required tags
+			const missingDiff = `<args><file><path>test.txt</path></file></args>`
+			expect(validateApplyDiffXml(missingDiff)).toBe(false)
+
+			// Unbalanced tags (missing closing diff tag)
+			const unbalanced = `<args><file><path>test.txt</path><diff><content>test</content></file>`
+			expect(validateApplyDiffXml(unbalanced)).toBe(false)
+		})
+	})
+})