Removed HTML since we don't want navigation in the app

Author: jschick04

src/EventLogExpert.UI.Tests/Services/ReleaseNotesMarkdownRendererTests.cs

@@ -7,6 +7,24 @@ namespace EventLogExpert.UI.Tests.Services;
 
 public sealed class ReleaseNotesMarkdownRendererTests
 {
+    [Theory]
+    [InlineData("[evil](javascript:alert(1))")]
+    [InlineData("[evil](data:text/html,<script>)")]
+    [InlineData("[evil](file:///etc/passwd)")]
+    [InlineData("[evil](ftp://example.com)")]
+    public void RenderToHtml_AllLinkSchemes_StrippedToTextOnly(string markdown)
+    {
+        var html = ReleaseNotesMarkdownRenderer.RenderToHtml(markdown);
+
+        Assert.DoesNotContain("<a ", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.DoesNotContain("javascript:", html);
+        Assert.DoesNotContain("data:", html);
+        Assert.DoesNotContain("file://", html);
+        Assert.DoesNotContain("ftp://", html);
+        Assert.Contains("evil", html);
+    }
+
     [Fact]
     public void RenderToHtml_BlankLineBetweenBullets_StartsNewList()
     {
@@ -106,19 +124,25 @@ public void RenderToHtml_Headings(string markdown, string expected)
     }
 
     [Fact]
-    public void RenderToHtml_HttpLink_RendersAnchor()
+    public void RenderToHtml_HttpLink_RendersTextOnlyWithoutAnchor()
     {
         var html = ReleaseNotesMarkdownRenderer.RenderToHtml("[link](http://example.com)");
 
-        Assert.Contains("<a href=\"http://example.com\"", html);
+        Assert.DoesNotContain("<a ", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.DoesNotContain("http://example.com", html);
+        Assert.Contains("link", html);
     }
 
     [Fact]
-    public void RenderToHtml_HttpsLink_RendersAnchor()
+    public void RenderToHtml_HttpsLink_RendersTextOnlyWithoutAnchor()
     {
         var html = ReleaseNotesMarkdownRenderer.RenderToHtml("see [docs](https://example.com/page)");
 
-        Assert.Contains("<a href=\"https://example.com/page\" target=\"_blank\" rel=\"noopener noreferrer\">docs</a>", html);
+        Assert.DoesNotContain("<a ", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.DoesNotContain("https://example.com/page", html);
+        Assert.Contains("see docs", html);
     }
 
     [Fact]
@@ -185,14 +209,14 @@ public void RenderToHtml_PlainTextLines_RenderAsParagraph()
     [Theory]
     [InlineData("[xss](https://example.com\"onload=alert(1))")]
     [InlineData("[xss](https://example.com'onclick='alert(1))")]
-    public void RenderToHtml_QuotesInUrl_AreEscapedNotInjected(string markdown)
+    public void RenderToHtml_QuotesInUrl_StrippedAlongWithUrl(string markdown)
     {
         var html = ReleaseNotesMarkdownRenderer.RenderToHtml(markdown);
 
-        Assert.DoesNotContain("\" onload=", html);
-        Assert.DoesNotContain("\"onload=", html);
-        Assert.DoesNotContain("\" onclick=", html);
-        Assert.DoesNotContain("'onclick=", html);
+        Assert.DoesNotContain("onload=", html);
+        Assert.DoesNotContain("onclick=", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.Contains("xss", html);
     }
 
     [Fact]
@@ -224,7 +248,9 @@ public void RenderToHtml_RichLayoutSample_RendersAllElements()
         Assert.Contains("<h3>Features</h3>", html);
         Assert.Contains("<h3>Bug Fixes</h3>", html);
         Assert.Contains("<strong>Column reordering</strong>", html);
-        Assert.Contains("<a href=\"https://example.com/docs\"", html);
+        Assert.Contains("<li>Support for exported logs</li>", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.DoesNotContain("https://example.com", html);
         Assert.Contains("<li>Fixed crash when opening empty file</li>", html);
     }
 
@@ -263,24 +289,13 @@ public void RenderToHtml_UnmatchedBoldMarkers_LeftAsLiteral()
         Assert.Contains("**unclosed bold", html);
     }
 
-    [Theory]
-    [InlineData("[evil](javascript:alert(1))")]
-    [InlineData("[evil](data:text/html,<script>)")]
-    [InlineData("[evil](file:///etc/passwd)")]
-    [InlineData("[evil](ftp://example.com)")]
-    public void RenderToHtml_UnsafeLinkSchemes_NotRenderedAsAnchor(string markdown)
-    {
-        var html = ReleaseNotesMarkdownRenderer.RenderToHtml(markdown);
-
-        Assert.DoesNotContain("<a ", html);
-        Assert.DoesNotContain("href=", html);
-    }
-
     [Fact]
-    public void RenderToHtml_UrlWithAmpersand_PreservesEscapedEntity()
+    public void RenderToHtml_UrlWithAmpersand_NotRenderedInOutput()
     {
         var html = ReleaseNotesMarkdownRenderer.RenderToHtml("[link](https://example.com/path?a=1&b=2)");
 
-        Assert.Contains("href=\"https://example.com/path?a=1&amp;b=2\"", html);
+        Assert.DoesNotContain("href=", html);
+        Assert.DoesNotContain("https://example.com", html);
+        Assert.Contains("link", html);
     }
 }

src/EventLogExpert.UI.Tests/Services/ReleaseNotesNormalizerTests.cs

@@ -18,6 +18,16 @@ public void Normalize_BulletWithoutCommitPrefix_ConvertsToDashStyle()
         Assert.Equal("- Just a description with no commit id", result);
     }
 
+    [Fact]
+    public void Normalize_EmptySummary_RemovedWithoutEmittingHeading()
+    {
+        var result = ReleaseNotesNormalizer.Normalize("before<summary></summary>after");
+
+        Assert.DoesNotContain("##", result);
+        Assert.Contains("before", result);
+        Assert.Contains("after", result);
+    }
+
     [Fact]
     public void Normalize_LegacyFixture_ProducesCleanBullets()
     {
@@ -30,6 +40,37 @@ public void Normalize_LegacyFixture_ProducesCleanBullets()
         Assert.DoesNotContain("66b7d6883807a5c518ffcd59f92e07e528a5636a", result);
     }
 
+    [Fact]
+    public void Normalize_LegacyFixture_PromotesSummaryTextToHeading()
+    {
+        var result = ReleaseNotesNormalizer.Normalize(Constants.GitHubReleaseNotes);
+
+        Assert.Contains("## See More", result);
+        Assert.Contains("- Reduce unnecessary sorting", result);
+    }
+
+    [Fact]
+    public void Normalize_LegacyFixture_StripsAutoGeneratedFooter()
+    {
+        var result = ReleaseNotesNormalizer.Normalize(Constants.GitHubReleaseNotes);
+
+        Assert.DoesNotContain("This list of changes was", result);
+        Assert.DoesNotContain("auto generated", result);
+    }
+
+    [Fact]
+    public void Normalize_LegacyFixture_StripsRawHtmlWrappers()
+    {
+        var result = ReleaseNotesNormalizer.Normalize(Constants.GitHubReleaseNotes);
+
+        Assert.DoesNotContain("<details", result);
+        Assert.DoesNotContain("</details>", result);
+        Assert.DoesNotContain("<summary", result);
+        Assert.DoesNotContain("</summary>", result);
+        Assert.DoesNotContain("<b>", result);
+        Assert.DoesNotContain("</b>", result);
+    }
+
     [Fact]
     public void Normalize_LegacyShaBullet_StripsCommitId()
     {
@@ -79,4 +120,21 @@ public void Normalize_RichAuthoredMarkdown_PassesThroughUnchanged()
         Assert.Contains("- **Column reordering** with persistent sizing", result);
         Assert.Contains("[exported logs](https://example.com/docs)", result);
     }
+
+    [Fact]
+    public void Normalize_RichBodyWithBoldTag_PreservesInnerTextOnly()
+    {
+        var result = ReleaseNotesNormalizer.Normalize("Some <b>important</b> note");
+
+        Assert.Equal("Some important note", result);
+    }
+
+    [Fact]
+    public void Normalize_SummaryWithNonLegacyTags_StripsTagsFromHeading()
+    {
+        var result = ReleaseNotesNormalizer.Normalize("<summary>Click <iframe>here</summary>");
+
+        Assert.Contains("## Click here", result);
+        Assert.DoesNotContain("<iframe", result);
+    }
 }

src/EventLogExpert.UI.Tests/Services/UpdateServiceTests.cs

@@ -423,6 +423,36 @@ await mockAlertDialogService.DidNotReceive()
             .ShowAlert(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>());
     }
 
+    [Fact]
+    public async Task GetReleaseNotes_WithCurrentChangesButNoSubscriber_ShouldFallBackToAlert()
+    {
+        // Arrange
+        var mockCurrentVersionProvider = Substitute.For<ICurrentVersionProvider>();
+        mockCurrentVersionProvider.CurrentVersion.Returns(new Version(Constants.GitHubLatestVersion[1..]));
+        mockCurrentVersionProvider.IsDevBuild.Returns(false);
+
+        var mockGitHubService = Substitute.For<IGitHubService>();
+        mockGitHubService.GetReleases().Returns(Task.FromResult(GitHubUtils.CreateGitReleaseModels()));
+
+        var mockAlertDialogService = Substitute.For<IAlertDialogService>();
+
+        var updateService = CreateUpdateService(
+            mockCurrentVersionProvider,
+            gitHubService: mockGitHubService,
+            alertDialogService: mockAlertDialogService);
+
+        // Act — note: no subscriber attached to ReleaseNotesReady.
+        await updateService.CheckForUpdates(false, false);
+        await updateService.GetReleaseNotes();
+
+        // Assert — without a UI subscriber the service must surface notes via the alert dialog
+        // so the user is never left with silent no-op feedback.
+        await mockAlertDialogService.Received(1).ShowAlert(
+            Arg.Is<string>(title => title.Contains("Release notes")),
+            Arg.Is<string>(body => body.Contains("Updated Azure yml to .NET 8")),
+            "Ok");
+    }
+
     private static UpdateService CreateUpdateService(
         ICurrentVersionProvider? currentVersionProvider = null,
         IAppTitleService? appTitleService = null,

src/EventLogExpert.UI/Services/ReleaseNotesMarkdownRenderer.cs

@@ -135,10 +135,6 @@ void FlushList()
     [GeneratedRegex(@"^(#{1,6})\s+(.+)$")]
     private static partial Regex HeadingRegex();
 
-    private static bool IsSafeUrl(string url) =>
-        url.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
-        url.StartsWith("https://", StringComparison.OrdinalIgnoreCase);
-
     [GeneratedRegex(@"\*([^*\n]+)\*")]
     private static partial Regex ItalicRegex();
 
@@ -160,20 +156,12 @@ private static string ProcessInline(string line)
             return $"{CodePlaceholderSentinel}{codeSpans.Count - 1}{CodePlaceholderSentinel}";
         });
 
-        var withLinks = LinkRegex().Replace(withCodePlaceholders, match =>
-        {
-            var text = match.Groups[1].Value;
-            var url = match.Groups[2].Value;
-
-            if (!IsSafeUrl(url))
-            {
-                return match.Value;
-            }
-
-            return $"<a href=\"{url}\" target=\"_blank\" rel=\"noopener noreferrer\">{text}</a>";
-        });
+        // Render Markdown links as their visible text only. The release notes
+        // modal is intentionally read-only; we do not want users navigating to
+        // external URLs from inside the app.
+        var withLinkTextOnly = LinkRegex().Replace(withCodePlaceholders, match => match.Groups[1].Value);
 
-        var withBold = BoldRegex().Replace(withLinks, "<strong>$1</strong>");
+        var withBold = BoldRegex().Replace(withLinkTextOnly, "<strong>$1</strong>");
         var withItalic = ItalicRegex().Replace(withBold, "<em>$1</em>");
 
         var restored = CodePlaceholderRegex().Replace(withItalic, match =>

src/EventLogExpert.UI/Services/ReleaseNotesNormalizer.cs

@@ -10,9 +10,14 @@ namespace EventLogExpert.UI.Services;
 /// rendered by <see cref="ReleaseNotesMarkdownRenderer"/>.
 ///
 /// Future releases are hand-authored in rich Markdown (headings, bold, lists,
-/// links) and pass through unchanged. Legacy releases used a flat list of
-/// <c>* &lt;commit-id&gt; description</c> bullets; this normalizer strips the
-/// commit-id prefix from those lines so they render as clean bullet items.
+/// links). Hand-authored content largely passes through; the only rewrites
+/// applied universally are converting <c>*</c> bullet markers to <c>-</c> for
+/// consistency and collapsing runs of 3+ blank lines. Legacy releases used a
+/// flat list of <c>* &lt;commit-id&gt; description</c> bullets, sometimes
+/// wrapped in raw HTML (<c>&lt;details&gt;</c>/<c>&lt;summary&gt;</c>/
+/// <c>&lt;b&gt;</c>) and followed by an auto-generated build-pipeline footer.
+/// This normalizer strips that noise so the renderer (which escapes raw HTML)
+/// does not surface the markup as literal text.
 /// </summary>
 public static partial class ReleaseNotesNormalizer
 {
@@ -25,11 +30,28 @@ public static string Normalize(string? rawBody)
 
         var working = rawBody.Replace("\r\n", "\n").Replace('\r', '\n');
 
+        working = SummaryTagRegex().Replace(working, match =>
+        {
+            // Strip any nested HTML tags (legacy or otherwise) so they do not
+            // surface as literal text inside the promoted heading.
+            var inner = AnyHtmlTagRegex().Replace(match.Groups[1].Value, string.Empty).Trim();
+            return string.IsNullOrEmpty(inner) ? string.Empty : $"\n\n## {inner}\n";
+        });
+
+        working = LegacyHtmlTagRegex().Replace(working, string.Empty);
+        working = AutoGeneratedFooterRegex().Replace(working, string.Empty);
         working = BulletRegex().Replace(working, match => $"- {match.Groups[1].Value.Trim()}");
+        working = CollapseBlankLinesRegex().Replace(working, "\n\n");
 
         return working.Trim();
     }
 
+    [GeneratedRegex(@"<[^>]+>")]
+    private static partial Regex AnyHtmlTagRegex();
+
+    [GeneratedRegex(@"^This list of changes was \[auto generated\][^\n]*$", RegexOptions.Multiline)]
+    private static partial Regex AutoGeneratedFooterRegex();
+
     /// <summary>
     /// Matches a <c>* </c> bullet whose content optionally begins with a commit
     /// identifier — either a 40-character SHA or a Markdown link
@@ -40,5 +62,27 @@ public static string Normalize(string? rawBody)
     [GeneratedRegex(@"^\*\s+(?:\[[0-9a-f]{6,}\]\([^)\s]+\)\s+|[0-9a-f]{40}\s+)?(.+)$",
         RegexOptions.Multiline | RegexOptions.IgnoreCase)]
     private static partial Regex BulletRegex();
+
+    [GeneratedRegex(@"\n{3,}")]
+    private static partial Regex CollapseBlankLinesRegex();
+
+    /// <summary>
+    /// Strips the structural HTML wrappers and inline emphasis tags that
+    /// historically appeared in GitHub release bodies. Inner text is preserved.
+    /// </summary>
+    [GeneratedRegex(@"</?(?:details|summary|b|i|em|strong)[^>]*>", RegexOptions.IgnoreCase)]
+    private static partial Regex LegacyHtmlTagRegex();
+
+    /// <summary>
+    /// Captures a <c>&lt;summary&gt;</c> block and promotes its inner text to a
+    /// section heading so the collapsible "See More" label is preserved as a
+    /// visible divider in the rendered notes. Any nested HTML tags inside the
+    /// captured text are removed by <see cref="AnyHtmlTagRegex"/> before the
+    /// heading is emitted, so even non-legacy markup (e.g. <c>&lt;iframe&gt;</c>)
+    /// cannot surface as literal text in the heading.
+    /// </summary>
+    [GeneratedRegex(@"<summary[^>]*>(.*?)</summary>", RegexOptions.IgnoreCase | RegexOptions.Singleline)]
+    private static partial Regex SummaryTagRegex();
 }
 
+

src/EventLogExpert.UI/Services/UpdateService.cs

@@ -159,6 +159,18 @@ await alertDialogService.ShowAlert("Release Notes Failure",
         var markdown = ReleaseNotesNormalizer.Normalize(_currentRawChanges);
         var title = $"Release notes for v{versionProvider.CurrentVersion}";
 
-        ReleaseNotesReady?.Invoke(new ReleaseNotesContent(title, markdown));
+        var subscribers = ReleaseNotesReady;
+
+        if (subscribers is null)
+        {
+            // No UI is wired up to render the rich modal (e.g., service used
+            // outside the Blazor host). Fall back to a plain alert so the user
+            // still sees something rather than getting silent no-op feedback.
+            await alertDialogService.ShowAlert(title, markdown, "Ok");
+
+            return;
+        }
+
+        subscribers.Invoke(new ReleaseNotesContent(title, markdown));
     }
 }

src/EventLogExpert/Shared/Components/ReleaseNotesModal.razor.css

@@ -51,8 +51,3 @@
     font-family: Consolas, monospace;
     font-size: 0.95em;
 }
-
-.release-notes-content a {
-    color: var(--clr-lightblue);
-    text-decoration: underline;
-}

src/EventLogExpert/wwwroot/js/modals.js

@@ -1,5 +1,5 @@
 window.openModal = (ref) => {
-    if (ref != null) {
+    if (ref != null && !ref.open) {
         ref.showModal();
     }
 };