feat: replace Firebase periodic polling with real-time SSE listener

Switch from 45-second DispatcherTimer polling to Server-Sent Events
streaming for instant sync. Open note windows now refresh automatically
when remote changes arrive. Fix timezone-aware date comparisons using
ToUniversalTime() and prevent sync loops with localOnly save flag.

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

Author: devohmycode

FirebaseSync.cs

@@ -29,6 +29,9 @@ public class FirebaseSync : IDisposable
     private string? _refreshToken;
     private Timer? _refreshTimer;
 
+    private CancellationTokenSource? _listenerCts;
+    private int _sseSkips;
+
     public bool IsConfigured => !string.IsNullOrEmpty(_databaseUrl) && !string.IsNullOrEmpty(_apiKey);
     public bool IsConnected => _idToken != null;
     public string? Email { get; private set; }
@@ -377,7 +380,7 @@ public static List<NoteEntry> MergePullWithLocal(
 
     private static NoteEntry MergeRemoteIntoLocal(NoteEntry local, NoteEntry remote)
     {
-        if (remote.UpdatedAt <= local.UpdatedAt)
+        if (remote.UpdatedAt.ToUniversalTime() <= local.UpdatedAt.ToUniversalTime())
             return local;
         return new NoteEntry
         {
@@ -465,7 +468,7 @@ private static Dictionary<string, NoteEntry> MergeNotesForPush(
                 merged[id] = l;
                 continue;
             }
-            merged[id] = l.UpdatedAt >= r.UpdatedAt ? l : r;
+            merged[id] = l.UpdatedAt.ToUniversalTime() >= r.UpdatedAt.ToUniversalTime() ? l : r;
         }
 
         foreach (var (id, r) in remote)
@@ -589,7 +592,12 @@ public async Task<bool> PushNotesAsync(IReadOnlyList<NoteEntry> notes)
             };
             var patchJson = JsonSerializer.Serialize(patchPayload);
             using var patchResponse = await _http.PatchAsync(userUrl, new StringContent(patchJson, Encoding.UTF8, "application/json"));
-            return patchResponse.IsSuccessStatusCode;
+            if (patchResponse.IsSuccessStatusCode)
+            {
+                Interlocked.Increment(ref _sseSkips);
+                return true;
+            }
+            return false;
         }
         catch { return false; }
     }
@@ -626,8 +634,90 @@ public async Task<bool> PushSettingsAsync(Dictionary<string, object> settings)
         catch { return null; }
     }
 
+    // ── SSE Real-time Listener ──────────────────────────────────
+
+    public void StartListening(Action onDataChanged)
+    {
+        StopListening();
+        _listenerCts = new CancellationTokenSource();
+        _ = ListenLoopAsync(onDataChanged, _listenerCts.Token);
+    }
+
+    public void StopListening()
+    {
+        _listenerCts?.Cancel();
+        _listenerCts?.Dispose();
+        _listenerCts = null;
+    }
+
+    private async Task ListenLoopAsync(Action onDataChanged, CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            try
+            {
+                await ListenOnceAsync(onDataChanged, ct);
+            }
+            catch (OperationCanceledException) when (ct.IsCancellationRequested) { break; }
+            catch
+            {
+                try { await Task.Delay(5000, ct); } catch { break; }
+            }
+        }
+    }
+
+    private async Task ListenOnceAsync(Action onDataChanged, CancellationToken ct)
+    {
+        if (!IsConnected || _localId == null)
+        {
+            await Task.Delay(5000, ct);
+            return;
+        }
+
+        var url = $"{_databaseUrl}/users/{_localId}/notes.json?auth={_idToken}";
+        using var request = new HttpRequestMessage(HttpMethod.Get, url);
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
+
+        using var sseClient = new HttpClient { Timeout = Timeout.InfiniteTimeSpan };
+        using var response = await sseClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct);
+        response.EnsureSuccessStatusCode();
+
+        await using var stream = await response.Content.ReadAsStreamAsync(ct);
+        using var reader = new StreamReader(stream);
+
+        var isFirstPut = true;
+
+        while (!ct.IsCancellationRequested)
+        {
+            var line = await reader.ReadLineAsync(ct);
+            if (line == null) break;
+
+            if (!line.StartsWith("event:", StringComparison.Ordinal)) continue;
+            var eventType = line["event:".Length..].Trim();
+
+            if (eventType is not "put" and not "patch") continue;
+
+            // Skip the initial full snapshot (we already have the data)
+            if (isFirstPut)
+            {
+                isFirstPut = false;
+                continue;
+            }
+
+            // Skip echoes of our own writes
+            if (Interlocked.CompareExchange(ref _sseSkips, 0, 0) > 0)
+            {
+                Interlocked.Decrement(ref _sseSkips);
+                continue;
+            }
+
+            onDataChanged();
+        }
+    }
+
     public void Dispose()
     {
+        StopListening();
         _refreshTimer?.Dispose();
         _http.Dispose();
     }

MainWindow.xaml.cs

@@ -46,7 +46,6 @@ private enum ViewMode { Notes, Favorites, Tags, TagFilter, Archive }
     private const int DefaultFullHeight = 650;
     private const int CompactHeight = 40;
     private Microsoft.UI.Xaml.DispatcherTimer? _animTimer;
-    private Microsoft.UI.Xaml.DispatcherTimer? _firebasePeriodicTimer;
     private int _preCompactWidth = 380;
     private int _preCompactHeight = DefaultFullHeight;
     private int _targetHeight;
@@ -125,7 +124,7 @@ public MainWindow()
         this.Closed += (_, _) =>
         {
             SaveMainWindowPosition();
-            StopFirebasePeriodicPull();
+            StopFirebaseListener();
             _attachmentService?.Dispose();
             foreach (var w in _attachedNoteWindows.Values.ToList())
             {
@@ -182,42 +181,50 @@ private async Task InitCloudSync()
         await _notes.InitWebDavFromSettings();
         UpdateSyncButtonVisibility();
         RefreshCurrentView();
-        StartFirebasePeriodicPull();
+        StartFirebaseListener();
     }
 
-    /// <summary>Background pull from RTDB (same idea as web <c>onValue</c>), so web deletes propagate without pressing Sync.</summary>
-    private void StartFirebasePeriodicPull()
+    /// <summary>Real-time SSE listener on RTDB notes, replaces periodic polling.</summary>
+    private void StartFirebaseListener()
     {
-        StopFirebasePeriodicPull();
-        if (_notes.Firebase is not { IsConnected: true }) return;
-        _firebasePeriodicTimer = new Microsoft.UI.Xaml.DispatcherTimer
-        {
-            Interval = TimeSpan.FromSeconds(45),
-        };
-        _firebasePeriodicTimer.Tick += (_, _) =>
+        StopFirebaseListener();
+        if (_notes.Firebase is not { IsConnected: true } fb) return;
+        fb.StartListening(() =>
         {
             DispatcherQueue.TryEnqueue(() => _ = PullFirebaseInBackgroundAsync());
-        };
-        _firebasePeriodicTimer.Start();
+        });
     }
 
-    private void StopFirebasePeriodicPull()
+    private void StopFirebaseListener()
     {
-        if (_firebasePeriodicTimer != null)
-        {
-            _firebasePeriodicTimer.Stop();
-            _firebasePeriodicTimer = null;
-        }
+        _notes.Firebase?.StopListening();
     }
 
     private async Task PullFirebaseInBackgroundAsync()
     {
         if (_notes.IsSyncing) return;
         if (_notes.Firebase is not { IsConnected: true }) return;
         await _notes.SyncFromFirebase();
+        RefreshOpenNoteWindows();
         RefreshCurrentView();
     }
 
+    private void RefreshOpenNoteWindows()
+    {
+        foreach (var w in _openNoteWindows)
+        {
+            var updated = _notes.Notes.FirstOrDefault(n => n.Id == w.NoteId);
+            if (updated != null)
+                w.ReloadAfterSync(updated);
+        }
+        foreach (var (id, w) in _attachedNoteWindows)
+        {
+            var updated = _notes.Notes.FirstOrDefault(n => n.Id == id);
+            if (updated != null)
+                w.ReloadAfterSync(updated);
+        }
+    }
+
     private void UpdateSyncButtonVisibility()
     {
         SyncButton.Visibility = _notes.Firebase is { IsConnected: true }
@@ -232,6 +239,7 @@ private async void SyncButton_Click(object sender, RoutedEventArgs e)
         {
             await _notes.SyncSettingsFromFirebase();
             await _notes.SyncFromFirebase();
+            RefreshOpenNoteWindows();
             RefreshCurrentView();
         }
         finally
@@ -1119,13 +1127,14 @@ private void Settings_Click(object sender, RoutedEventArgs e)
             onConfigureFirebase: async () => await ShowFirebaseConfigDialog(),
             onDisconnectFirebase: () =>
             {
-                StopFirebasePeriodicPull();
+                StopFirebaseListener();
                 _notes.DisconnectFirebase();
                 UpdateSyncButtonVisibility();
             },
             onSyncFirebase: async () =>
             {
                 await _notes.SyncFromFirebase();
+                RefreshOpenNoteWindows();
                 RefreshCurrentView();
             },
             onConfigureWebDav: async () => await ShowWebDavConfigDialog(),
@@ -1560,9 +1569,10 @@ private async Task ShowFirebaseConfigDialog()
             if (success)
             {
                 await _notes.SyncFromFirebase();
+                RefreshOpenNoteWindows();
                 UpdateSyncButtonVisibility();
                 RefreshCurrentView();
-                StartFirebasePeriodicPull();
+                StartFirebaseListener();
                 googleSignInDone = true;
             }
             else
@@ -1596,9 +1606,10 @@ private async Task ShowFirebaseConfigDialog()
             if (success)
             {
                 await _notes.SyncFromFirebase();
+                RefreshOpenNoteWindows();
                 UpdateSyncButtonVisibility();
                 RefreshCurrentView();
-                StartFirebasePeriodicPull();
+                StartFirebaseListener();
                 break;
             }
 

NoteWindow.xaml.cs

@@ -13,7 +13,7 @@ namespace NoteUI;
 public sealed partial class NoteWindow : Window
 {
     private readonly NotesManager _notesManager;
-    private readonly NoteEntry _note;
+    private NoteEntry _note;
     private SnippetManager? _snippetManager;
     private bool _isPinnedOnTop;
     private bool _suppressTextChanged;
@@ -457,6 +457,21 @@ private void SaveCurrentNote()
         NoteChanged?.Invoke();
     }
 
+    public void ReloadAfterSync(NoteEntry updatedNote)
+    {
+        var changed = _note.Content != updatedNote.Content
+                   || _note.Title != updatedNote.Title
+                   || _note.Color != updatedNote.Color;
+        _note = updatedNote;
+        if (!changed) return;
+        TitleText.Text = _note.Title;
+        if (_note.NoteType == "tasklist")
+            LoadTaskNoteContent();
+        else
+            LoadNote();
+        ApplyNoteColor(_note.Color);
+    }
+
     // ── Task note (free-form text in tasklist mode) ─────────────
 
     private void LoadTaskNoteContent()

NotesManager.cs

@@ -46,7 +46,7 @@ public void ChangeFolder(string newFolder)
         Load();
     }
 
-    public void Save()
+    public void Save(bool localOnly = false)
     {
         try
         {
@@ -56,6 +56,8 @@ public void Save()
         }
         catch { }
 
+        if (localOnly) return;
+
         // Fire-and-forget push to cloud
         if (Firebase is { IsConnected: true })
             _ = Firebase.PushNotesAsync(_notes);
@@ -137,7 +139,7 @@ public async Task<bool> SyncFromFirebase()
 
             _notes.Clear();
             _notes.AddRange(merged);
-            Save();
+            Save(localOnly: true);
             return true;
         }
         catch { return false; }
@@ -264,13 +266,13 @@ public async Task<bool> SyncFromWebDav()
             foreach (var n in remote)
             {
                 // Prefer remote when newer or same instant (avoids losing pin-only web updates if clocks align to the same tick).
-                if (!merged.TryGetValue(n.Id, out var local) || n.UpdatedAt >= local.UpdatedAt)
+                if (!merged.TryGetValue(n.Id, out var local) || n.UpdatedAt.ToUniversalTime() >= local.UpdatedAt.ToUniversalTime())
                     merged[n.Id] = n;
             }
 
             _notes.Clear();
             _notes.AddRange(merged.Values);
-            Save();
+            Save(localOnly: true);
             return true;
         }
         catch { return false; }
@@ -631,7 +633,7 @@ private static string StripRtf(string rtf)
                 }
                 continue;
             }
-            if (depth <= 1 && (c >= ' ' || c == '\n' || c == '\t'))
+            if (depth <= 1 && c >= ' ')
                 result.Append(c);
             i++;
         }