From 65a89455b68469a472db44303ffa9c0e604c1f3a Mon Sep 17 00:00:00 2001
From: Zero <1270128439@qq.com>
Date: Thu, 21 May 2026 22:51:54 +0800
Subject: [PATCH] fix: hysteria2 obfs round-trip, subscription identity, log
 scroll anchoring
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- hysteria2: parse obfs=salamander + obfs-password from share links into
  Finalmask udp[], and emit them back when generating share links. Previously
  dropped on import and never produced on export.
- subscription refresh: preserve node Ids by a multi-field identity key
  (protocol/host/port/network/security/path/credentials/uuid/flow/...) instead
  of just protocol://host:port. Lowercase case-insensitive fields, queue-match
  to handle duplicates, and dedupe via reusedIds so two new entries can't
  share one old Id.
- log window: when auto-scroll is OFF and the 500-line ring buffer evicts
  old lines, shift the scroll offset down by evicted * lineHeight so visible
  content stays anchored instead of drifting up.
- DialogService: set AcceptsReturn before Text on the Finalmask TextBox —
  single-line Text setter truncates at the first \r. Normalize line endings
  to \r as well.
- ServerDetailControl: guard ShadowRect_Loaded with _shadowsWired so the
  three AI-service Borders don't each re-add receivers (3*3=9 duplicates).
- MainWindow.xaml: child VM bindings and SwitchToSelectedServerCommand are
  immutable after construction, switch to OneTime; drop redundant Mode=OneWay
  on the MiniStartStop Command binding.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 MainWindow.xaml                   | 10 ++---
 Services/DialogService.cs         |  6 ++-
 Services/NodeLinkParser.cs        | 59 ++++++++++++++++++++++++++++-
 Services/NodeLinkSerializer.cs    | 62 +++++++++++++++++++++++++++----
 ViewModels/ServerListViewModel.cs | 47 +++++++++++++++++++++--
 Views/LogWindow.xaml.cs           | 27 +++++++++++++-
 Views/ServerDetailControl.xaml    |  2 +-
 Views/ServerDetailControl.xaml.cs |  9 ++++-
 8 files changed, 200 insertions(+), 22 deletions(-)

diff --git a/MainWindow.xaml b/MainWindow.xaml
index c799264..f903f83 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -93,7 +93,7 @@
                     </Grid.ColumnDefinitions>
 
                     <ToggleButton Grid.Column="0"
-                                  Command="{x:Bind ViewModel.MiniStartStopCommand, Mode=OneWay}"
+                                  Command="{x:Bind ViewModel.MiniStartStopCommand}"
                                   IsChecked="{x:Bind ViewModel.MiniIsRunning, Mode=OneWay}"
                                   Width="40" Height="40"
                                   CornerRadius="20"
@@ -169,8 +169,8 @@
 
             <views:ServerListControl Grid.Column="0"
                                       x:Name="ServerList"
-                                      ViewModel="{x:Bind ViewModel.ServerList, Mode=OneWay}"
-                                      SwitchToSelectedServerCommand="{x:Bind ViewModel.SwitchToSelectedServerCommand, Mode=OneWay}" />
+                                      ViewModel="{x:Bind ViewModel.ServerList, Mode=OneTime}"
+                                      SwitchToSelectedServerCommand="{x:Bind ViewModel.SwitchToSelectedServerCommand, Mode=OneTime}" />
 
             <Grid Grid.Column="1"
                   VerticalAlignment="Stretch">
@@ -184,11 +184,11 @@
 
                     <views:ServerDetailControl Grid.Row="0"
                                                x:Name="ServerDetail"
-                                               ViewModel="{x:Bind ViewModel.ServerDetail, Mode=OneWay}" />
+                                               ViewModel="{x:Bind ViewModel.ServerDetail, Mode=OneTime}" />
 
                     <views:ControlPanelControl x:Name="ControlPanel"
                                                Grid.Row="1"
-                                               ViewModel="{x:Bind ViewModel.ControlPanel, Mode=OneWay}" />
+                                               ViewModel="{x:Bind ViewModel.ControlPanel, Mode=OneTime}" />
                 </Grid>
 
                 <!-- Personalize view — lazily realized in code-behind on first show
diff --git a/Services/DialogService.cs b/Services/DialogService.cs
index 29a0e1f..f926462 100644
--- a/Services/DialogService.cs
+++ b/Services/DialogService.cs
@@ -185,10 +185,12 @@ void SyncDialogButtons()
             var txtFinalmask = new TextBox
             {
                 Header = "Finalmask (JSON)",
-                Text = existing?.Finalmask ?? string.Empty,
+                // AcceptsReturn must be set BEFORE Text — initializer assigns properties in
+                // declared order, and Text setter in single-line mode truncates at the first \r.
                 AcceptsReturn = true,
                 Height = 104,
-                TextWrapping = TextWrapping.NoWrap
+                TextWrapping = TextWrapping.NoWrap,
+                Text = (existing?.Finalmask ?? string.Empty).Replace("\r\n", "\r").Replace("\n", "\r"),
             };
 
             // Row containers for conditional visibility
diff --git a/Services/NodeLinkParser.cs b/Services/NodeLinkParser.cs
index 5c4e918..0b6c1a6 100644
--- a/Services/NodeLinkParser.cs
+++ b/Services/NodeLinkParser.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using XrayUI.Models;
 
 namespace XrayUI.Services
@@ -287,7 +288,7 @@ int GetInt(string key, int def = 0) =>
 
                 var query = ParseQuery(uri.Query);
                 var sni   = Q(query, "sni", string.Empty) ?? string.Empty;
-                var finalmask = FinalmaskJson.NormalizeForStorage(Q(query, "fm"));
+                var finalmask = BuildHysteria2Finalmask(query);
                 var allowInsecure = IsTruthy(Q(query, "allowInsecure")) || IsTruthy(Q(query, "insecure"));
 
                 return new ServerEntry
@@ -311,6 +312,62 @@ int GetInt(string key, int def = 0) =>
             }
         }
 
+        private static string BuildHysteria2Finalmask(Dictionary<string, string> query)
+        {
+            var finalmask = FinalmaskJson.NormalizeForStorage(
+                Q(query, "fm") ?? Q(query, "finalmask"));
+
+            var obfs = Q(query, "obfs");
+            if (!string.Equals(obfs, "salamander", StringComparison.OrdinalIgnoreCase))
+                return finalmask;
+
+            var obfsPassword = Q(query, "obfs-password")
+                               ?? Q(query, "obfs_password")
+                               ?? Q(query, "obfsPassword");
+            if (obfsPassword is null)
+                return finalmask;
+
+            return AddHysteria2SalamanderMask(finalmask, obfsPassword);
+        }
+
+        private static string AddHysteria2SalamanderMask(string finalmask, string password)
+        {
+            var parsed = FinalmaskJson.Parse(finalmask);
+            if (parsed is not null and not JsonObject)
+                return finalmask;
+
+            if (parsed is null && !string.IsNullOrWhiteSpace(finalmask))
+                return finalmask;
+
+            var root = parsed as JsonObject ?? [];
+            var udp = root["udp"] as JsonArray;
+            if (udp is null)
+            {
+                udp = [];
+                root["udp"] = udp;
+            }
+
+            foreach (var item in udp)
+            {
+                if (item is JsonObject itemObject
+                    && string.Equals(itemObject["type"]?.GetValue<string>(), "salamander", StringComparison.OrdinalIgnoreCase))
+                {
+                    return root.ToJsonString(AppJsonSerializerContext.WriteReadable);
+                }
+            }
+
+            udp.Insert(0, new JsonObject
+            {
+                ["type"] = "salamander",
+                ["settings"] = new JsonObject
+                {
+                    ["password"] = password
+                }
+            });
+
+            return root.ToJsonString(AppJsonSerializerContext.WriteReadable);
+        }
+
         // Trojan
 
         private static ServerEntry? ParseTrojan(string link)
diff --git a/Services/NodeLinkSerializer.cs b/Services/NodeLinkSerializer.cs
index fe40dec..ff1553b 100644
--- a/Services/NodeLinkSerializer.cs
+++ b/Services/NodeLinkSerializer.cs
@@ -168,25 +168,37 @@ public static class NodeLinkSerializer
             sb.Append(':');
             sb.Append(s.Port);
 
-            var finalmask = FinalmaskJson.NormalizeForShare(s.Finalmask);
-            bool hasQuery = !string.IsNullOrEmpty(s.Sni) || s.AllowInsecure || !string.IsNullOrEmpty(finalmask);
+            var (hasSalamanderObfs, obfsPassword, finalmask) =
+                ExtractHysteria2SalamanderObfs(FinalmaskJson.NormalizeForShare(s.Finalmask));
+            bool hasQuery = !string.IsNullOrEmpty(s.Sni)
+                            || s.AllowInsecure
+                            || hasSalamanderObfs
+                            || !string.IsNullOrEmpty(finalmask);
             if (hasQuery)
             {
                 sb.Append('?');
                 bool first = true;
-                if (!string.IsNullOrEmpty(s.Sni))
+
+                void AddParam(string key, string value)
                 {
-                    AppendParam(sb, "sni", s.Sni, first: true);
+                    AppendParam(sb, key, value, first);
                     first = false;
                 }
+
+                if (!string.IsNullOrEmpty(s.Sni))
+                    AddParam("sni", s.Sni);
                 if (s.AllowInsecure)
                 {
-                    AppendParam(sb, "insecure", "1", first: first);
-                    first = false;
+                    AddParam("insecure", "1");
+                }
+                if (hasSalamanderObfs)
+                {
+                    AddParam("obfs", "salamander");
+                    AddParam("obfs-password", obfsPassword ?? string.Empty);
                 }
                 if (!string.IsNullOrEmpty(finalmask))
                 {
-                    AppendParam(sb, "fm", finalmask, first: first);
+                    AddParam("fm", finalmask);
                 }
             }
 
@@ -201,6 +213,42 @@ public static class NodeLinkSerializer
 
         // ── Trojan ───────────────────────────────────────────────────────────
 
+        private static (bool hasObfs, string? password, string finalmask) ExtractHysteria2SalamanderObfs(string finalmask)
+        {
+            // FinalmaskJson.Parse returns a freshly-parsed node owned by this call, so we
+            // mutate `root` and `udp` in place rather than cloning.
+            var parsed = FinalmaskJson.Parse(finalmask);
+            if (parsed is not JsonObject root)
+                return (false, null, finalmask);
+
+            if (root["udp"] is not JsonArray udp)
+                return (false, null, finalmask);
+
+            string? password = null;
+            for (int i = 0; i < udp.Count; i++)
+            {
+                if (udp[i] is JsonObject itemObject
+                    && string.Equals(itemObject["type"]?.GetValue<string>(), "salamander", StringComparison.OrdinalIgnoreCase))
+                {
+                    password = (itemObject["settings"] as JsonObject)?["password"]?.GetValue<string>() ?? string.Empty;
+                    udp.RemoveAt(i);
+                    break;
+                }
+            }
+
+            if (password is null)
+                return (false, null, finalmask);
+
+            if (udp.Count == 0)
+                root.Remove("udp");
+
+            var cleanedFinalmask = root.Count == 0
+                ? string.Empty
+                : FinalmaskJson.NormalizeForShare(root.ToJsonString());
+
+            return (true, password, cleanedFinalmask);
+        }
+
         private static string? ToTrojanLink(ServerEntry s)
         {
             if (string.IsNullOrEmpty(s.Password)) return null;
diff --git a/ViewModels/ServerListViewModel.cs b/ViewModels/ServerListViewModel.cs
index 84ef7e9..847cb79 100644
--- a/ViewModels/ServerListViewModel.cs
+++ b/ViewModels/ServerListViewModel.cs
@@ -727,14 +727,27 @@ private async Task RefreshSubscriptionAsync(SubscriptionEntry sub)
 
                 // Preserve Ids for nodes that survived the refresh so LastAutoConnectServerId
                 // (and any other Id-based reference) keeps pointing at the same logical node.
-                var oldByEndpoint = new Dictionary<string, ServerEntry>(removed.Count);
+                var oldByIdentity = new Dictionary<string, Queue<ServerEntry>>(StringComparer.Ordinal);
                 foreach (var s in removed)
-                    oldByEndpoint[$"{s.Protocol}://{s.Host}:{s.Port}"] = s;
+                {
+                    var key = BuildNodeIdentityKey(s);
+                    if (!oldByIdentity.TryGetValue(key, out var matches))
+                    {
+                        matches = new Queue<ServerEntry>();
+                        oldByIdentity[key] = matches;
+                    }
+                    matches.Enqueue(s);
+                }
+
+                var reusedIds = new HashSet<string>(StringComparer.Ordinal);
                 foreach (var e in newEntries)
                 {
-                    if (oldByEndpoint.TryGetValue($"{e.Protocol}://{e.Host}:{e.Port}", out var match))
+                    if (oldByIdentity.TryGetValue(BuildNodeIdentityKey(e), out var matches)
+                        && matches.Count > 0)
                     {
-                        e.Id = match.Id;
+                        var match = matches.Dequeue();
+                        if (!string.IsNullOrWhiteSpace(match.Id) && reusedIds.Add(match.Id))
+                            e.Id = match.Id;
                         e.IsFavorite = match.IsFavorite;
                     }
                 }
@@ -760,6 +773,32 @@ private async Task RefreshSubscriptionAsync(SubscriptionEntry sub)
             }
         }
 
+        // Case-insensitive identifiers (host, protocol, uuid, etc.) are lowercased so a
+        // subscription that re-emits "Example.com" still matches a stored "example.com".
+        // Case-sensitive material (credentials, paths, base64/hex keys) is only trimmed.
+        private static string BuildNodeIdentityKey(ServerEntry s) =>
+            string.Join("|",
+                NormalizeIdentityPart(s.Protocol),
+                NormalizeIdentityPart(s.Host),
+                s.Port.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                NormalizeIdentityPart(s.Network),
+                NormalizeIdentityPart(s.Security),
+                s.Path?.Trim() ?? string.Empty,
+                NormalizeIdentityPart(s.WsHost),
+                NormalizeIdentityPart(s.Sni),
+                NormalizeIdentityPart(s.Encryption),
+                s.Username?.Trim() ?? string.Empty,
+                s.Password?.Trim() ?? string.Empty,
+                NormalizeIdentityPart(s.Uuid),
+                s.AlterId.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                s.VlessEncryption?.Trim() ?? string.Empty,
+                s.Flow?.Trim() ?? string.Empty,
+                s.PublicKey?.Trim() ?? string.Empty,
+                s.ShortId?.Trim() ?? string.Empty);
+
+        private static string NormalizeIdentityPart(string? value) =>
+            value?.Trim().ToLowerInvariant() ?? string.Empty;
+
         private async Task<bool> DeleteSubscriptionAsync(SubscriptionEntry sub)
         {
             if (IsSubscriptionLocked(sub.Id))
diff --git a/Views/LogWindow.xaml.cs b/Views/LogWindow.xaml.cs
index 2987809..1973752 100644
--- a/Views/LogWindow.xaml.cs
+++ b/Views/LogWindow.xaml.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml.Media;
@@ -28,6 +29,8 @@ public sealed partial class LogWindow
 
         // Set from background thread when new lines arrive; consumed on UI thread.
         private volatile bool _dirty;
+        private int _linesReceivedSinceFlush; // Background-thread increments; UI thread reads + clears.
+        private int _prevBufferCount;
 
         public LogWindow(
             XrayService xray,
@@ -72,6 +75,7 @@ private void OnLogReceived(object? sender, string line)
         {
             // Called from background thread. Do NOT touch the UI here —
             // just mark dirty; the timer will re-render on the UI thread.
+            Interlocked.Increment(ref _linesReceivedSinceFlush);
             _dirty = true;
         }
 
@@ -85,12 +89,31 @@ private void OnFlushTick(DispatcherQueueTimer sender, object args)
             if (!_dirty) return;
             _dirty = false;
 
+            var autoScroll = AutoScrollToggle.IsChecked == true;
+            var prevOffset = LogScrollViewer.VerticalOffset;
+            var prevExtent = LogScrollViewer.ExtentHeight;
+            var prevCount  = _prevBufferCount;
+            var received   = Interlocked.Exchange(ref _linesReceivedSinceFlush, 0);
+
             RenderLog();
+            var newCount = _prevBufferCount; // RenderLog just updated this.
 
-            if (AutoScrollToggle.IsChecked == true)
+            if (autoScroll)
             {
                 LogScrollViewer.ChangeView(null, double.MaxValue, null, disableAnimation: true);
             }
+            else
+            {
+                // Ring buffer evicted some lines: (received) − (net buffer growth) = lines pushed out.
+                // Shift the scroll offset down by that height so visible content stays anchored.
+                var evicted = Math.Max(0, received - (newCount - prevCount));
+                if (evicted > 0 && prevCount > 0 && prevExtent > 0)
+                {
+                    var lineHeight = prevExtent / prevCount;
+                    var target = Math.Max(0, prevOffset - evicted * lineHeight);
+                    LogScrollViewer.ChangeView(null, target, null, disableAnimation: true);
+                }
+            }
         }
 
         // ── Rendering ──────────────────────────────────────────────────────────
@@ -101,6 +124,7 @@ private void RenderLog()
             var lines = _xray.GetLogBuffer();
             LogTextBlock.Text = string.Join('\n', lines);
             LineCountText.Text = $"({lines.Count} 行)";
+            _prevBufferCount = lines.Count;
         }
 
         private async Task InitializeMaskAddressMenuAsync()
@@ -143,6 +167,7 @@ private void CopyButton_Click(object sender, RoutedEventArgs e)
         private void ClearButton_Click(object sender, RoutedEventArgs e)
         {
             _xray.ClearLogBuffer();
+            Interlocked.Exchange(ref _linesReceivedSinceFlush, 0);
             RenderLog();
         }
 
diff --git a/Views/ServerDetailControl.xaml b/Views/ServerDetailControl.xaml
index e8bb54e..759daa7 100644
--- a/Views/ServerDetailControl.xaml
+++ b/Views/ServerDetailControl.xaml
@@ -142,7 +142,7 @@
                                            Foreground="{ThemeResource TextFillColorSecondaryBrush}"
                                            VerticalAlignment="Center" />
 
-                            <Grid ColumnSpacing="12" 
+                                <Grid ColumnSpacing="12" 
                                   HorizontalAlignment="Center">
                                 <Grid.ColumnDefinitions>
                                     <ColumnDefinition Width="Auto" />
diff --git a/Views/ServerDetailControl.xaml.cs b/Views/ServerDetailControl.xaml.cs
index a27ef35..ffa1e47 100644
--- a/Views/ServerDetailControl.xaml.cs
+++ b/Views/ServerDetailControl.xaml.cs
@@ -7,13 +7,20 @@ public sealed partial class ServerDetailControl
     {
         public ServerDetailViewModel ViewModel { get; set; } = null!;
 
+        // The three AI service Borders share this handler. Without a guard, each Border's
+        // Loaded fire would re-add AIShadowCastGrid to all three Shadows — three Borders ×
+        // three receivers = nine entries, with duplicates causing wasted compositor work.
+        private bool _shadowsWired;
+
         public ServerDetailControl()
         {
             this.InitializeComponent();
         }
-        
+
         private void ShadowRect_Loaded(object sender, RoutedEventArgs e)
         {
+            if (_shadowsWired) return;
+            _shadowsWired = true;
             Shadow1.Receivers.Add(AIShadowCastGrid);
             Shadow2.Receivers.Add(AIShadowCastGrid);
             Shadow3.Receivers.Add(AIShadowCastGrid);