Fix HTML attribute and content escaping for dyad-tags (#2266)

e2e-tests/snapshots/local_agent_grep.spec.ts_local-agent---grep-search-2.aria.yml

@@ -5,4 +5,4 @@
 - button "Copy":
   - img
 - text: log
-- code: "src/main.tsx:1: import { createRoot } from \"react-dom/client\"; src/main.tsx:4: createRoot(document.getElementById(\"root\")!).render(<App />);"
+- code: "src/main.tsx:1: import { createRoot } from \"react-dom/client\"; src/main.tsx:4: createRoot(document.getElementById(\"root\")!).render(<App />);"
\ No newline at end of file

e2e-tests/snapshots/local_agent_grep.spec.ts_local-agent---grep-search-3.aria.yml

@@ -5,4 +5,4 @@
 - button "Copy":
   - img
 - text: log
-- code: "src/main.tsx:2: import App from \"./App.tsx\"; src/main.tsx:4: createRoot(document.getElementById(\"root\")!).render(<App />); src/App.tsx:1: const App = () => <div>Minimal imported app</div>; src/App.tsx:3: export default App;"
+- code: "src/main.tsx:2: import App from \"./App.tsx\"; src/main.tsx:4: createRoot(document.getElementById(\"root\")!).render(<App />); src/App.tsx:1: const App = () => <div>Minimal imported app</div>; src/App.tsx:3: export default App;"
\ No newline at end of file

shared/xmlEscape.ts

+/**
+ * XML escape/unescape utilities for dyad tags.
+ *
+ * When serializing dyad tags, we escape special characters to prevent
+ * breaking the tag structure. When deserializing (parsing), we need
+ * to unescape these characters to get the original values.
+ */
+
+/**
+ * Escapes special characters in XML attribute values.
+ * Handles: & " < >
+ */
+export function escapeXmlAttr(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+/**
+ * Unescapes XML attribute values.
+ * Note: Order matters - &amp; must be unescaped last to avoid double-unescaping.
+ */
+export function unescapeXmlAttr(str: string): string {
+  return str
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, "&");
+}
+
+/**
+ * Escapes special characters in XML content (text between tags).
+ * Handles: & < >
+ */
+export function escapeXmlContent(str: string): string {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/**
+ * Unescapes XML content values.
+ * Note: Order matters - &amp; must be unescaped last to avoid double-unescaping.
+ */
+export function unescapeXmlContent(str: string): string {
+  return str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}

src/__tests__/xmlEscape.test.ts

+import { describe, it, expect } from "vitest";
+import {
+  escapeXmlAttr,
+  unescapeXmlAttr,
+  escapeXmlContent,
+  unescapeXmlContent,
+} from "../../shared/xmlEscape";
+
+describe("xmlEscape", () => {
+  describe("escapeXmlAttr", () => {
+    it("should escape ampersands", () => {
+      expect(escapeXmlAttr("foo & bar")).toBe("foo & bar");
+    });
+
+    it("should escape double quotes", () => {
+      expect(escapeXmlAttr('foo "bar" baz')).toBe("foo "bar" baz");
+    });
+
+    it("should escape angle brackets", () => {
+      expect(escapeXmlAttr("foo <bar> baz")).toBe("foo &lt;bar&gt; baz");
+    });
+
+    it("should escape all special characters together", () => {
+      expect(escapeXmlAttr('use <a> and "b" & c')).toBe(
+        "use &lt;a&gt; and &quot;b&quot; &amp; c",
+      );
+    });
+
+    it("should handle empty strings", () => {
+      expect(escapeXmlAttr("")).toBe("");
+    });
+
+    it("should not modify strings without special characters", () => {
+      expect(escapeXmlAttr("hello world")).toBe("hello world");
+    });
+  });
+
+  describe("unescapeXmlAttr", () => {
+    it("should unescape ampersands", () => {
+      expect(unescapeXmlAttr("foo &amp; bar")).toBe("foo & bar");
+    });
+
+    it("should unescape double quotes", () => {
+      expect(unescapeXmlAttr("foo &quot;bar&quot; baz")).toBe('foo "bar" baz');
+    });
+
+    it("should unescape angle brackets", () => {
+      expect(unescapeXmlAttr("foo &lt;bar&gt; baz")).toBe("foo <bar> baz");
+    });
+
+    it("should unescape all special characters together", () => {
+      expect(unescapeXmlAttr("use &lt;a&gt; and &quot;b&quot; &amp; c")).toBe(
+        'use <a> and "b" & c',
+      );
+    });
+
+    it("should handle empty strings", () => {
+      expect(unescapeXmlAttr("")).toBe("");
+    });
+
+    it("should not modify strings without escaped characters", () => {
+      expect(unescapeXmlAttr("hello world")).toBe("hello world");
+    });
+  });
+
+  describe("escapeXmlContent", () => {
+    it("should escape ampersands", () => {
+      expect(escapeXmlContent("foo & bar")).toBe("foo &amp; bar");
+    });
+
+    it("should escape angle brackets", () => {
+      expect(escapeXmlContent("foo <bar> baz")).toBe("foo &lt;bar&gt; baz");
+    });
+
+    it("should NOT escape double quotes (content doesn't need it)", () => {
+      expect(escapeXmlContent('foo "bar" baz')).toBe('foo "bar" baz');
+    });
+
+    it("should handle empty strings", () => {
+      expect(escapeXmlContent("")).toBe("");
+    });
+  });
+
+  describe("unescapeXmlContent", () => {
+    it("should unescape ampersands", () => {
+      expect(unescapeXmlContent("foo &amp; bar")).toBe("foo & bar");
+    });
+
+    it("should unescape angle brackets", () => {
+      expect(unescapeXmlContent("foo &lt;bar&gt; baz")).toBe("foo <bar> baz");
+    });
+
+    it("should handle empty strings", () => {
+      expect(unescapeXmlContent("")).toBe("");
+    });
+  });
+
+  describe("roundtrip", () => {
+    it("should roundtrip attribute values correctly", () => {
+      const original = 'path with <special> "chars" & ampersand';
+      const escaped = escapeXmlAttr(original);
+      const unescaped = unescapeXmlAttr(escaped);
+      expect(unescaped).toBe(original);
+    });
+
+    it("should roundtrip content correctly", () => {
+      const original = "content with <tags> & ampersand";
+      const escaped = escapeXmlContent(original);
+      const unescaped = unescapeXmlContent(escaped);
+      expect(unescaped).toBe(original);
+    });
+
+    it("should handle complex nested escapes correctly", () => {
+      // Test that &amp;lt; doesn't get double-unescaped
+      const original = "literal &lt; should stay as &lt;";
+      const escaped = escapeXmlContent(original);
+      expect(escaped).toBe("literal &amp;lt; should stay as &amp;lt;");
+      const unescaped = unescapeXmlContent(escaped);
+      expect(unescaped).toBe(original);
+    });
+  });
+});

src/components/chat/DyadMarkdownParser.tsx

@@ -36,6 +36,7 @@ import { DyadStatus } from "./DyadStatus";
 import { mapActionToButton } from "./ChatInput";
 import { SuggestedAction } from "@/lib/schemas";
 import { FixAllErrorsButton } from "./FixAllErrorsButton";
+import { unescapeXmlAttr, unescapeXmlContent } from "../../../shared/xmlEscape";
 
 const DYAD_CUSTOM_TAGS = [
   "dyad-write",
@@ -274,25 +275,25 @@ function parseCustomTags(content: string): ContentPiece[] {
       });
     }
 
-    // Parse attributes
+    // Parse attributes and unescape values
     const attributes: Record<string, string> = {};
     const attrPattern = /([\w-]+)="([^"]*)"/g;
     let attrMatch;
     while ((attrMatch = attrPattern.exec(attributesStr)) !== null) {
-      attributes[attrMatch[1]] = attrMatch[2];
+      attributes[attrMatch[1]] = unescapeXmlAttr(attrMatch[2]);
     }
 
     // Check if this tag was marked as in progress
     const tagInProgressSet = inProgressTags.get(tag);
     const isInProgress = tagInProgressSet?.has(startIndex);
 
-    // Add the tag info
+    // Add the tag info with unescaped content
     contentPieces.push({
       type: "custom-tag",
       tagInfo: {
         tag,
         attributes,
-        content: tagContent,
+        content: unescapeXmlContent(tagContent),
         fullMatch,
         inProgress: isInProgress || false,
       },

src/ipc/handlers/chat_stream_handlers.ts

@@ -67,6 +67,7 @@ import { cleanFullResponse } from "../utils/cleanFullResponse";
 import { generateProblemReport } from "../processors/tsc";
 import { createProblemFixPrompt } from "@/shared/problem_prompt";
 import { AsyncVirtualFileSystem } from "../../../shared/VirtualFilesystem";
+import { escapeXmlAttr, escapeXmlContent } from "../../../shared/xmlEscape";
 import {
   getDyadAddDependencyTags,
   getDyadWriteTags,
@@ -125,13 +126,7 @@ async function isTextFile(filePath: string): Promise<boolean> {
   return TEXT_FILE_EXTENSIONS.includes(ext);
 }
 
-function escapeXml(unsafe: string): string {
-  return unsafe
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}
+// Use escapeXmlAttr from shared/xmlEscape for XML escaping
 
 // Safely parse an MCP tool key that combines server and tool names.
 // We split on the LAST occurrence of "__" to avoid ambiguity if either
@@ -1276,7 +1271,7 @@ ${formattedSearchReplaceIssues}`,
 ${problemReport.problems
   .map(
     (problem) =>
-      `<problem file="${escapeXml(problem.file)}" line="${problem.line}" column="${problem.column}" code="${problem.code}">${escapeXml(problem.message)}</problem>`,
+      `<problem file="${escapeXmlAttr(problem.file)}" line="${problem.line}" column="${problem.column}" code="${problem.code}">${escapeXmlContent(problem.message)}</problem>`,
   )
   .join("\n")}
 </dyad-problem-report>`;

src/ipc/utils/dyad_tag_parser.ts

 import { normalizePath } from "../../../shared/normalizePath";
+import { unescapeXmlAttr, unescapeXmlContent } from "../../../shared/xmlEscape";
 import log from "electron-log";
 import { SqlQuery } from "../../lib/schemas";
 
@@ -18,14 +19,16 @@ export function getDyadWriteTags(fullResponse: string): {
 
   while ((match = dyadWriteRegex.exec(fullResponse)) !== null) {
     const attributesString = match[1];
-    let content = match[2].trim();
+    let content = unescapeXmlContent(match[2].trim());
 
     const pathMatch = pathRegex.exec(attributesString);
     const descriptionMatch = descriptionRegex.exec(attributesString);
 
     if (pathMatch && pathMatch[1]) {
-      const path = pathMatch[1];
-      const description = descriptionMatch?.[1];
+      const path = unescapeXmlAttr(pathMatch[1]);
+      const description = descriptionMatch?.[1]
+        ? unescapeXmlAttr(descriptionMatch[1])
+        : undefined;
 
       const contentLines = content.split("\n");
       if (contentLines[0]?.startsWith("```")) {
@@ -57,8 +60,8 @@ export function getDyadRenameTags(fullResponse: string): {
   const tags: { from: string; to: string }[] = [];
   while ((match = dyadRenameRegex.exec(fullResponse)) !== null) {
     tags.push({
-      from: normalizePath(match[1]),
-      to: normalizePath(match[2]),
+      from: normalizePath(unescapeXmlAttr(match[1])),
+      to: normalizePath(unescapeXmlAttr(match[2])),
     });
   }
   return tags;
@@ -70,7 +73,7 @@ export function getDyadDeleteTags(fullResponse: string): string[] {
   let match;
   const paths: string[] = [];
   while ((match = dyadDeleteRegex.exec(fullResponse)) !== null) {
-    paths.push(normalizePath(match[1]));
+    paths.push(normalizePath(unescapeXmlAttr(match[1])));
   }
   return paths;
 }
@@ -81,7 +84,7 @@ export function getDyadAddDependencyTags(fullResponse: string): string[] {
   let match;
   const packages: string[] = [];
   while ((match = dyadAddDependencyRegex.exec(fullResponse)) !== null) {
-    packages.push(...match[1].split(" "));
+    packages.push(...unescapeXmlAttr(match[1]).split(" "));
   }
   return packages;
 }
@@ -91,7 +94,7 @@ export function getDyadChatSummaryTag(fullResponse: string): string | null {
     /<dyad-chat-summary>([\s\S]*?)<\/dyad-chat-summary>/g;
   const match = dyadChatSummaryRegex.exec(fullResponse);
   if (match && match[1]) {
-    return match[1].trim();
+    return unescapeXmlContent(match[1].trim());
   }
   return null;
 }
@@ -105,9 +108,11 @@ export function getDyadExecuteSqlTags(fullResponse: string): SqlQuery[] {
 
   while ((match = dyadExecuteSqlRegex.exec(fullResponse)) !== null) {
     const attributesString = match[1] || "";
-    let content = match[2].trim();
+    let content = unescapeXmlContent(match[2].trim());
     const descriptionMatch = descriptionRegex.exec(attributesString);
-    const description = descriptionMatch?.[1];
+    const description = descriptionMatch?.[1]
+      ? unescapeXmlAttr(descriptionMatch[1])
+      : undefined;
 
     // Handle markdown code blocks if present
     const contentLines = content.split("\n");
@@ -132,7 +137,7 @@ export function getDyadCommandTags(fullResponse: string): string[] {
   const commands: string[] = [];
 
   while ((match = dyadCommandRegex.exec(fullResponse)) !== null) {
-    commands.push(match[1]);
+    commands.push(unescapeXmlAttr(match[1]));
   }
 
   return commands;
@@ -153,14 +158,16 @@ export function getDyadSearchReplaceTags(fullResponse: string): {
 
   while ((match = dyadSearchReplaceRegex.exec(fullResponse)) !== null) {
     const attributesString = match[1] || "";
-    let content = match[2].trim();
+    let content = unescapeXmlContent(match[2].trim());
 
     const pathMatch = pathRegex.exec(attributesString);
     const descriptionMatch = descriptionRegex.exec(attributesString);
 
     if (pathMatch && pathMatch[1]) {
-      const path = pathMatch[1];
-      const description = descriptionMatch?.[1];
+      const path = unescapeXmlAttr(pathMatch[1]);
+      const description = descriptionMatch?.[1]
+        ? unescapeXmlAttr(descriptionMatch[1])
+        : undefined;
 
       // Handle markdown code fences if present
       const contentLines = content.split("\n");

src/pro/main/ipc/handlers/local_agent/tools/types.ts

@@ -12,17 +12,12 @@ import { AgentTodo } from "@/ipc/ipc_types";
 // XML Escape Helpers
 // ============================================================================
 
-export function escapeXmlAttr(str: string): string {
-  return str
-    .replace(/&/g, "&")
-    .replace(/"/g, """)
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-export function escapeXmlContent(str: string): string {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
+export {
+  escapeXmlAttr,
+  unescapeXmlAttr,
+  escapeXmlContent,
+  unescapeXmlContent,
+} from "../../../../../../../shared/xmlEscape";
 
 // ============================================================================
 // Todo Types

src/pro/main/ipc/handlers/local_agent/xml_tool_translator.ts

@@ -8,11 +8,7 @@
  */
 
 import type { ToolCallPart } from "ai";
-
-// Escape XML content (less strict than attributes)
-function escapeXmlContent(str: string): string {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
+import { escapeXmlContent } from "../../../../../../shared/xmlEscape";
 
 /**
  * Wrap thinking text in think tags