fix(tray/macos): mirror web before/after word-diff in ServerDetailView

Bring the macOS tray's Tool Quarantine diff in line with the web UI's
new before/after layout. Previously the tray stacked a red "minus"
box above a green "plus" box containing the raw old/new text, which
gave no hint about which specific words actually changed. Now the
diff section renders two labelled boxes ("Before (approved)" and
"After (current)") built from a longest-common-subsequence word diff;
each side only shows its own words with removals/additions
highlighted inside their respective boxes via AttributedString
background color.

Ports the same LCS used in ServerDetail.vue (split-on-whitespace
tokens, backtrack to build parts, merge consecutive parts of the same
kind). Adds ToolDiffTests covering identical inputs, empty sides, the
real gcore short→docstring expansion, and reconstruction invariants.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: claude

native/macos/MCPProxy/MCPProxy/Views/ServerDetailView.swift

@@ -1158,12 +1158,7 @@ struct ToolRow: View {
                         .foregroundStyle(.secondary)
 
                     if oldDesc != newDesc {
-                        if !oldDesc.isEmpty {
-                            diffLine(text: oldDesc, isOld: true)
-                        }
-                        if !newDesc.isEmpty {
-                            diffLine(text: newDesc, isOld: false)
-                        }
+                        diffBeforeAfter(previous: oldDesc, current: newDesc)
                     } else {
                         Text("No description changes")
                             .font(.scaled(.caption, scale: fontScale))
@@ -1188,12 +1183,7 @@ struct ToolRow: View {
                         .padding(.top, 4)
 
                     if oldSchema != newSchema {
-                        if !oldSchema.isEmpty {
-                            diffLine(text: oldSchema, isOld: true)
-                        }
-                        if !newSchema.isEmpty {
-                            diffLine(text: newSchema, isOld: false)
-                        }
+                        diffBeforeAfter(previous: oldSchema, current: newSchema)
                     } else {
                         Text("No schema changes")
                             .font(.scaled(.caption, scale: fontScale))
@@ -1219,20 +1209,78 @@ struct ToolRow: View {
     }
 
     @ViewBuilder
-    private func diffLine(text: String, isOld: Bool) -> some View {
-        HStack(alignment: .top, spacing: 4) {
-            Image(systemName: isOld ? "minus.circle.fill" : "plus.circle.fill")
-                .font(.scaled(.caption2, scale: fontScale))
-                .foregroundStyle(isOld ? .red : .green)
-            Text(text)
-                .font(.scaledMonospaced(.caption, scale: fontScale))
-                .foregroundStyle(isOld ? .secondary : .primary)
-                .lineLimit(isOld ? 6 : nil)
+    private func diffBeforeAfter(previous: String, current: String) -> some View {
+        let parts = computeWordDiff(previous, current)
+        VStack(alignment: .leading, spacing: 6) {
+            diffBox(
+                label: "BEFORE (APPROVED)",
+                attributed: renderDiffSide(parts, keep: .removed),
+                accent: .red,
+                isEmpty: previous.isEmpty
+            )
+            diffBox(
+                label: "AFTER (CURRENT)",
+                attributed: renderDiffSide(parts, keep: .added),
+                accent: .green,
+                isEmpty: current.isEmpty
+            )
         }
-        .padding(4)
-        .frame(maxWidth: .infinity, alignment: .leading)
-        .background((isOld ? Color.red : Color.green).opacity(0.08))
-        .cornerRadius(4)
+    }
+
+    @ViewBuilder
+    private func diffBox(label: String, attributed: AttributedString, accent: Color, isEmpty: Bool) -> some View {
+        VStack(alignment: .leading, spacing: 3) {
+            Text(label)
+                .font(.system(size: 9 * fontScale, weight: .semibold))
+                .tracking(0.5)
+                .foregroundStyle(.secondary)
+            if isEmpty {
+                Text("(empty)")
+                    .font(.scaledMonospaced(.caption, scale: fontScale))
+                    .foregroundStyle(.tertiary)
+                    .padding(6)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(accent.opacity(0.04))
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 4)
+                            .strokeBorder(accent.opacity(0.25), lineWidth: 1)
+                    )
+                    .cornerRadius(4)
+            } else {
+                Text(attributed)
+                    .font(.scaledMonospaced(.caption, scale: fontScale))
+                    .textSelection(.enabled)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(6)
+                    .background(accent.opacity(0.04))
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 4)
+                            .strokeBorder(accent.opacity(0.25), lineWidth: 1)
+                    )
+                    .cornerRadius(4)
+            }
+        }
+    }
+
+    /// Build AttributedString for one side of the diff. `keep` is the change-type
+    /// (removed or added) that belongs in this side; same-type parts render plain
+    /// in both sides; the opposite change-type is dropped.
+    private func renderDiffSide(_ parts: [ToolDiffPart], keep: ToolDiffPart.Kind) -> AttributedString {
+        var result = AttributedString()
+        for part in parts {
+            switch part.kind {
+            case .same:
+                result += AttributedString(part.text)
+            case .added, .removed:
+                if part.kind != keep { continue }
+                var span = AttributedString(part.text)
+                let accent: Color = part.kind == .removed ? .red : .green
+                span.backgroundColor = accent.opacity(0.25)
+                span.foregroundColor = accent
+                result += span
+            }
+        }
+        return result
     }
 
     private func loadDiff() {
@@ -1314,6 +1362,88 @@ struct ToolRow: View {
     }
 }
 
+// MARK: - Tool Description Word Diff
+
+struct ToolDiffPart {
+    enum Kind { case same, added, removed }
+    let kind: Kind
+    let text: String
+}
+
+/// Split a string into tokens, preserving runs of whitespace as their own tokens
+/// (matches the web UI's `split(/(\s+)/)` so the LCS behaves identically).
+private func splitPreservingWhitespace(_ s: String) -> [String] {
+    var tokens: [String] = []
+    var buffer = ""
+    var bufferIsWhitespace: Bool? = nil
+    for ch in s {
+        let chIsWhitespace = ch.isWhitespace
+        if bufferIsWhitespace == nil {
+            bufferIsWhitespace = chIsWhitespace
+            buffer.append(ch)
+        } else if bufferIsWhitespace == chIsWhitespace {
+            buffer.append(ch)
+        } else {
+            tokens.append(buffer)
+            buffer = String(ch)
+            bufferIsWhitespace = chIsWhitespace
+        }
+    }
+    if !buffer.isEmpty { tokens.append(buffer) }
+    return tokens
+}
+
+/// Word-level diff via longest common subsequence. Returns parts in original order.
+func computeWordDiff(_ oldText: String, _ newText: String) -> [ToolDiffPart] {
+    let oldTokens = splitPreservingWhitespace(oldText)
+    let newTokens = splitPreservingWhitespace(newText)
+    let m = oldTokens.count
+    let n = newTokens.count
+    if m == 0 && n == 0 { return [] }
+    if m == 0 { return [ToolDiffPart(kind: .added, text: newText)] }
+    if n == 0 { return [ToolDiffPart(kind: .removed, text: oldText)] }
+
+    var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
+    for i in 1...m {
+        for j in 1...n {
+            if oldTokens[i - 1] == newTokens[j - 1] {
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            } else {
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+            }
+        }
+    }
+
+    var parts: [ToolDiffPart] = []
+    var i = m
+    var j = n
+    while i > 0 || j > 0 {
+        if i > 0 && j > 0 && oldTokens[i - 1] == newTokens[j - 1] {
+            parts.append(ToolDiffPart(kind: .same, text: oldTokens[i - 1]))
+            i -= 1
+            j -= 1
+        } else if j > 0 && (i == 0 || dp[i][j - 1] >= dp[i - 1][j]) {
+            parts.append(ToolDiffPart(kind: .added, text: newTokens[j - 1]))
+            j -= 1
+        } else {
+            parts.append(ToolDiffPart(kind: .removed, text: oldTokens[i - 1]))
+            i -= 1
+        }
+    }
+    parts.reverse()
+
+    // Merge consecutive parts of the same kind to minimize attribute spans.
+    var merged: [ToolDiffPart] = []
+    for part in parts {
+        if let last = merged.last, last.kind == part.kind {
+            merged[merged.count - 1] = ToolDiffPart(kind: last.kind, text: last.text + part.text)
+        } else {
+            merged.append(part)
+        }
+    }
+    return merged
+}
+
 // MARK: - Flow Layout (for wrapping annotation badges)
 
 /// A simple horizontal flow layout that wraps items to the next line.

native/macos/MCPProxy/MCPProxyTests/ToolDiffTests.swift

@@ -0,0 +1,84 @@
+import XCTest
+@testable import MCPProxy
+
+final class ToolDiffTests: XCTestCase {
+
+    private func partsByKind(_ parts: [ToolDiffPart]) -> (same: String, added: String, removed: String) {
+        var same = ""
+        var added = ""
+        var removed = ""
+        for p in parts {
+            switch p.kind {
+            case .same: same += p.text
+            case .added: added += p.text
+            case .removed: removed += p.text
+            }
+        }
+        return (same, added, removed)
+    }
+
+    func testIdenticalStringsProduceOnlySameParts() {
+        let text = "Get the list of Alibaba Cloud regions."
+        let parts = computeWordDiff(text, text)
+        let buckets = partsByKind(parts)
+        XCTAssertEqual(buckets.same, text)
+        XCTAssertEqual(buckets.added, "")
+        XCTAssertEqual(buckets.removed, "")
+    }
+
+    func testEmptyBeforeMarksEverythingAdded() {
+        let parts = computeWordDiff("", "Hello world")
+        XCTAssertEqual(parts.count, 1)
+        XCTAssertEqual(parts[0].kind, .added)
+        XCTAssertEqual(parts[0].text, "Hello world")
+    }
+
+    func testEmptyAfterMarksEverythingRemoved() {
+        let parts = computeWordDiff("Hello world", "")
+        XCTAssertEqual(parts.count, 1)
+        XCTAssertEqual(parts[0].kind, .removed)
+        XCTAssertEqual(parts[0].text, "Hello world")
+    }
+
+    func testExpansionOfAlibabaRegions() {
+        // Real case from gcore-mcp-server: short one-liner expanded to docstring.
+        let before = "Get the list of Alibaba Cloud regions."
+        let after = "Get the list of Alibaba Cloud regions. Args: limit: Maximum number of items."
+        let parts = computeWordDiff(before, after)
+        let buckets = partsByKind(parts)
+
+        // The common prefix must survive intact in "same" parts.
+        XCTAssertTrue(buckets.same.contains("Get the list of Alibaba Cloud regions."))
+        // The trailing docstring must be in the "added" bucket.
+        XCTAssertTrue(buckets.added.contains("Args:"))
+        XCTAssertTrue(buckets.added.contains("limit:"))
+        // Nothing should be removed in this direction.
+        XCTAssertEqual(buckets.removed, "")
+    }
+
+    func testReconstructionFromAddedAndRemoved() {
+        // Reconstructing before = same + removed; after = same + added (in order)
+        let before = "alpha beta gamma"
+        let after = "alpha delta gamma"
+        let parts = computeWordDiff(before, after)
+
+        let reconstructedBefore = parts.compactMap { p -> String? in
+            p.kind == .added ? nil : p.text
+        }.joined()
+        let reconstructedAfter = parts.compactMap { p -> String? in
+            p.kind == .removed ? nil : p.text
+        }.joined()
+
+        XCTAssertEqual(reconstructedBefore, before)
+        XCTAssertEqual(reconstructedAfter, after)
+    }
+
+    func testConsecutivePartsOfSameKindAreMerged() {
+        let parts = computeWordDiff("one two three", "one two three four five")
+        // Trailing addition should be a single merged part, not many tokens.
+        let addedParts = parts.filter { $0.kind == .added }
+        XCTAssertEqual(addedParts.count, 1, "Consecutive added tokens must merge")
+        XCTAssertTrue(addedParts[0].text.contains("four"))
+        XCTAssertTrue(addedParts[0].text.contains("five"))
+    }
+}