Chrome-like UI, ForensicEngine/PrivacyEngine improvements, time consistency

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: orstro

BrowserTab.cs

@@ -6,10 +6,15 @@
 
 namespace PrivacyMonitor
 {
+    /// <summary>Per-tab state: UI refs, request/fingerprint data, and protection state. UI refs are set by MainWindow after creation.
+    /// BlockedRequests and other lists are not thread-safe; RegisterBlocked and DrainPending must be called on the UI thread.
+    /// Consider constructor injection for required UI refs when refactoring the creation flow.</summary>
     public class BrowserTab
     {
         public string Id { get; } = Guid.NewGuid().ToString("N")[..8];
+        /// <summary>Set by MainWindow after creation. Not null once tab is fully initialized.</summary>
         public WebView2 WebView { get; set; } = null!;
+        /// <summary>Set by MainWindow after BuildTabHeader(tab).</summary>
         public Border TabHeader { get; set; } = null!;
         public TextBlock TitleBlock { get; set; } = null!;
         public TextBlock InitialBlock { get; set; } = null!;
@@ -20,11 +25,13 @@ public class BrowserTab
         public string Title { get; set; } = "New Tab";
         public string Url { get; set; } = "";
         public string CurrentHost { get; set; } = "";
-        public DateTime ScanStart { get; set; } = DateTime.Now;
+        /// <summary>When the current page scan started (UTC). Use UTC for consistency with LastActivityUtc.</summary>
+        public DateTime ScanStart { get; set; } = DateTime.UtcNow;
         /// <summary>Last time this tab had user or network activity (UTC). Used for idle sleep.</summary>
         public DateTime LastActivityUtc { get; set; } = DateTime.UtcNow;
         /// <summary>Last measured approximate memory usage for this tab (bytes, from JS APIs).</summary>
         public long? LastMemoryBytes { get; set; }
+        /// <summary>Next ID for new requests. Incremented at ingestion (e.g. Interlocked.Increment in the request handler).</summary>
         public int NextRequestId;
         public bool IsReady { get; set; }
         public bool IsLoading { get; set; }
@@ -38,17 +45,25 @@ public class BrowserTab
 
         // ── Thread-safe request ingestion ──
         public ConcurrentQueue<RequestEntry> PendingRequests { get; } = new();
+        /// <summary>Max requests kept per tab. Consider making configurable via settings.</summary>
         public const int MaxRequests = 5000;
+        /// <summary>Max blocked-request records kept. Consider making configurable.</summary>
         public const int MaxBlockedRequests = 2000;
 
-        // ── Processed data (UI-thread only) ──
-        public List<RequestEntry> Requests { get; } = new();
+        // ── Processed data (UI-thread only; not thread-safe) ──
+        /// <summary>LinkedList for O(1) eviction when over MaxRequests; use Last/Previous to scan recent-first.</summary>
+        public LinkedList<RequestEntry> Requests { get; } = new();
         public List<FingerprintFinding> Fingerprints { get; } = new();
         public List<CookieItem> Cookies { get; } = new();
         public List<StorageItem> Storage { get; } = new();
         public List<WebRtcLeak> WebRtcLeaks { get; } = new();
         public List<SecurityHeaderResult> SecurityHeaders { get; set; } = new();
 
+        /// <summary>Raised after one or more requests are drained (UI thread). Optional for UI refresh. Subscribers doing heavy work may want to debounce.</summary>
+        public event Action? RequestProcessed;
+        /// <summary>Raised when a request is recorded as blocked. Must only be called from the UI thread (BlockedRequests is not thread-safe).</summary>
+        public event Action<BlockedRequestInfo>? BlockedRequestAdded;
+
         // ── Detection context (for cross-request correlation) ──
         public HashSet<string> SeenTrackerDomains { get; } = new(StringComparer.OrdinalIgnoreCase);
         public HashSet<string> SeenTrackerCompanies { get; } = new(StringComparer.OrdinalIgnoreCase);
@@ -58,6 +73,8 @@ public class BrowserTab
         // ── Forensic state ──
         public Dictionary<string, HashSet<string>> IdentifierToDomains { get; } = new();
         public List<DataFlowEdge> DataFlowEdges { get; } = new();
+        /// <summary>O(1) lookup for AddOrUpdateEdge; cleared with DataFlowEdges on ResetDetection.</summary>
+        public Dictionary<string, DataFlowEdge> DataFlowEdgeLookup { get; } = new();
         public List<ForensicEvent> ForensicTimeline { get; } = new();
 
         // ── Protection state ──
@@ -69,49 +86,107 @@ public class BrowserTab
         public string? FingerprintDetectScriptId { get; set; }
         public string? BehavioralMonitorScriptId { get; set; }
 
-        /// <summary>Drain pending queue into Requests list. Call from UI thread.</summary>
+        /// <summary>Drain pending queue into Requests. Call from UI thread only. Eviction is O(1) via LinkedList.</summary>
         public int DrainPending()
         {
             int drained = 0;
             while (PendingRequests.TryDequeue(out var entry))
             {
-                Requests.Add(entry);
+                Requests.AddLast(entry);
                 drained++;
 
-                // Track domain counts
-                DomainRequestCounts[entry.Host] = DomainRequestCounts.GetValueOrDefault(entry.Host) + 1;
+                var host = entry.Host ?? "";
+                DomainRequestCounts[host] = DomainRequestCounts.GetValueOrDefault(host) + 1;
 
-                // Track seen trackers
-                if (!string.IsNullOrEmpty(entry.TrackerLabel))
+                if (!string.IsNullOrEmpty(entry.TrackerLabel) && host.Length > 0)
                 {
-                    SeenTrackerDomains.Add(entry.Host);
+                    SeenTrackerDomains.Add(host);
                     if (!string.IsNullOrEmpty(entry.TrackerCompany))
                         SeenTrackerCompanies.Add(entry.TrackerCompany);
                 }
 
-                // Forensic correlation (runs on UI thread, lightweight per-request)
-                ForensicEngine.ExtractAndRegisterIdentifiers(entry, IdentifierToDomains, ForensicTimeline);
-                ForensicEngine.AnalyzeDataFlow(entry, CurrentHost, DataFlowEdges, ForensicTimeline);
+                try
+                {
+                    ForensicEngine.ExtractAndRegisterIdentifiers(entry, IdentifierToDomains, ForensicTimeline);
+                    ForensicEngine.AnalyzeDataFlow(entry, CurrentHost, DataFlowEdges, ForensicTimeline, DataFlowEdgeLookup);
+                }
+                catch
+                {
+                    // ForensicEngine failed; avoid breaking drain. Log in host app if needed.
+                }
 
-                // Evict oldest if over limit
                 if (Requests.Count > MaxRequests)
-                    Requests.RemoveAt(0);
+                    Requests.RemoveFirst();
             }
+            if (drained > 0)
+                RequestProcessed?.Invoke();
             return drained;
         }
 
-        /// <summary>Reset all detection state (on host change).</summary>
+        /// <summary>Reset all detection state (on host change). Preserves list references for bindings (e.g. SecurityHeaders.Clear()).</summary>
         public void ResetDetection()
         {
-            Requests.Clear(); Fingerprints.Clear(); Cookies.Clear();
-            Storage.Clear(); WebRtcLeaks.Clear(); SecurityHeaders = new();
-            NextRequestId = 0; ScanStart = DateTime.Now; ConsentDetected = false;
-            SeenTrackerDomains.Clear(); SeenTrackerCompanies.Clear();
-            DomainRequestCounts.Clear(); SeenUrls.Clear();
-            IdentifierToDomains.Clear(); DataFlowEdges.Clear(); ForensicTimeline.Clear();
-            BlockedCount = 0; BlockedRequests.Clear(); AntiFingerprintInjected = false;
-            // Drain any pending
+            Requests.Clear();
+            Fingerprints.Clear();
+            Cookies.Clear();
+            Storage.Clear();
+            WebRtcLeaks.Clear();
+            SecurityHeaders.Clear();
+            NextRequestId = 0;
+            ScanStart = DateTime.UtcNow;
+            ConsentDetected = false;
+            SeenTrackerDomains.Clear();
+            SeenTrackerCompanies.Clear();
+            DomainRequestCounts.Clear();
+            SeenUrls.Clear();
+            IdentifierToDomains.Clear();
+            DataFlowEdges.Clear();
+            DataFlowEdgeLookup.Clear();
+            ForensicTimeline.Clear();
+            BlockedCount = 0;
+            BlockedRequests.Clear();
+            AntiFingerprintInjected = false;
             while (PendingRequests.TryDequeue(out _)) { }
         }
+
+        /// <summary>Record user or network activity (updates LastActivityUtc for idle sleep).</summary>
+        public void NoteActivity()
+        {
+            LastActivityUtc = DateTime.UtcNow;
+        }
+
+        /// <summary>Mark this tab as crashed (e.g. after ProcessFailed).</summary>
+        public void MarkCrashed()
+        {
+            IsCrashed = true;
+        }
+
+        /// <summary>Mark this tab as sleeping (suspended) or awake.</summary>
+        public void MarkSleeping(bool sleeping = true)
+        {
+            IsSleeping = sleeping;
+        }
+
+        /// <summary>Record a blocked request for the forensic trail and badge. Must be called on the UI thread (BlockedRequests is not thread-safe).</summary>
+        public void RegisterBlocked(DateTime time, string host, string url, string reason, string category, double confidence, string trackerLabel, string resourceType, string method)
+        {
+            BlockedCount++;
+            var info = new BlockedRequestInfo
+            {
+                Time = time,
+                Host = host ?? "",
+                Url = url ?? "",
+                Reason = reason ?? "",
+                Category = category ?? "",
+                Confidence = confidence,
+                TrackerLabel = trackerLabel ?? "",
+                ResourceType = resourceType ?? "",
+                Method = method ?? ""
+            };
+            BlockedRequests.Add(info);
+            if (BlockedRequests.Count > MaxBlockedRequests)
+                BlockedRequests.RemoveAt(0);
+            BlockedRequestAdded?.Invoke(info);
+        }
     }
 }

DesktopShortcut.cs

@@ -1,10 +1,13 @@
 using System.IO;
 using System.Runtime.InteropServices;
+using System;
+using System.Threading.Tasks;
 
 namespace PrivacyMonitor;
 
 /// <summary>
 /// Creates a Windows desktop shortcut to the current app so users have easy access after download/install.
+/// Reflection-based COM interop is used for compatibility and to avoid an extra dependency.
 /// </summary>
 public static class DesktopShortcut
 {
@@ -13,11 +16,21 @@ public static class DesktopShortcut
     /// <summary>
     /// Ensures a desktop shortcut exists. Creates it if missing or if the target path changed (e.g. user moved the exe).
     /// Call once at app startup (e.g. from App.OnStartup). Safe to call every run; only creates/updates when needed.
+    /// For UI snappiness, consider running in a background task if startup time is critical.
     /// </summary>
     public static void EnsureDesktopShortcut()
+    {
+        // Note: Shortcut creation is very fast but can be put on a background thread if desired:
+        // Task.Run(() => EnsureDesktopShortcutImpl());
+
+        EnsureDesktopShortcutImpl();
+    }
+
+    private static void EnsureDesktopShortcutImpl()
     {
         try
         {
+            // .NET 6+ ProcessPath; fallback just in case
             var exePath = Environment.ProcessPath ?? Path.Combine(AppContext.BaseDirectory, "PrivacyMonitor.exe");
             if (string.IsNullOrEmpty(exePath) || !File.Exists(exePath))
                 return;
@@ -30,78 +43,115 @@ public static void EnsureDesktopShortcut()
             var exeDir = Path.GetDirectoryName(exePath) ?? "";
 
             // If shortcut exists and already points to this exe, skip
-            if (File.Exists(shortcutPath) && GetShortcutTargetPath(shortcutPath) == exePath)
+            var targetOfExisting = File.Exists(shortcutPath) ? GetShortcutTargetPath(shortcutPath) : null;
+            if (targetOfExisting != null && string.Equals(targetOfExisting, exePath, StringComparison.OrdinalIgnoreCase))
                 return;
 
             CreateShortcut(shortcutPath, exePath, exeDir);
         }
-        catch
+        catch (Exception ex)
         {
             // Non-critical: do not crash the app if shortcut creation fails (e.g. no desktop, permissions).
+            // Optionally log here for diagnostics.
+            // Console.Error.WriteLine($"Failed to ensure desktop shortcut: {ex}");
         }
     }
 
+    /// <summary>
+    /// Creates a .lnk shortcut using late-bound COM interop.
+    /// </summary>
     private static void CreateShortcut(string shortcutPath, string targetPath, string workingDirectory)
     {
-        Type? shellType = Type.GetTypeFromProgID("WScript.Shell");
+        Type? shellType = Type.GetTypeFromProgID("WScript.Shell", throwOnError: false);
         if (shellType == null)
             return;
 
-        object? shell = Activator.CreateInstance(shellType);
-        if (shell == null)
-            return;
-
+        object? shell = null;
+        object? shortcut = null;
         try
         {
-            // CreateShortcut(fullPath) returns IShellLinkW / IWshShortcut
-            object? shortcut = shellType.InvokeMember("CreateShortcut", System.Reflection.BindingFlags.InvokeMethod, null, shell, new object[] { shortcutPath });
+            shell = Activator.CreateInstance(shellType);
+            if (shell == null)
+                return;
+
+            // CreateShortcut returns a COM object implementing IWshShortcut
+            shortcut = shellType.InvokeMember(
+                "CreateShortcut",
+                System.Reflection.BindingFlags.InvokeMethod,
+                null,
+                shell,
+                new object[] { shortcutPath });
+
             if (shortcut == null)
                 return;
 
             var t = shortcut.GetType();
+            // Reflection slightly slower than direct, but fine for infrequent calls.
             t.InvokeMember("TargetPath", System.Reflection.BindingFlags.SetProperty, null, shortcut, new object[] { targetPath });
             t.InvokeMember("WorkingDirectory", System.Reflection.BindingFlags.SetProperty, null, shortcut, new object[] { workingDirectory });
             t.InvokeMember("Description", System.Reflection.BindingFlags.SetProperty, null, shortcut, new object[] { "Privacy Monitor – Privacy-first browser" });
+            // Save shortcut to disk
             t.InvokeMember("Save", System.Reflection.BindingFlags.InvokeMethod, null, shortcut, Array.Empty<object>());
         }
         finally
         {
+            // Release COM objects, safe for both regular and exceptional paths.
+            if (shortcut != null && Marshal.IsComObject(shortcut))
+                Marshal.ReleaseComObject(shortcut);
+
             if (shell is IDisposable d)
                 d.Dispose();
-            else if (Marshal.IsComObject(shell))
+            else if (shell != null && Marshal.IsComObject(shell))
                 Marshal.ReleaseComObject(shell);
         }
     }
 
+    /// <summary>
+    /// Gets the TargetPath of a shortcut (.lnk file), or null on error.
+    /// </summary>
     private static string? GetShortcutTargetPath(string shortcutPath)
     {
+        Type? shellType = null;
+        object? shell = null;
+        object? shortcut = null;
         try
         {
-            var shellType = Type.GetTypeFromProgID("WScript.Shell");
+            shellType = Type.GetTypeFromProgID("WScript.Shell", throwOnError: false);
             if (shellType == null) return null;
 
-            object? shell = Activator.CreateInstance(shellType);
+            shell = Activator.CreateInstance(shellType);
             if (shell == null) return null;
 
-            try
-            {
-                object? shortcut = shellType.InvokeMember("CreateShortcut", System.Reflection.BindingFlags.InvokeMethod, null, shell, new object[] { shortcutPath });
-                if (shortcut == null) return null;
-
-                var target = shortcut.GetType().InvokeMember("TargetPath", System.Reflection.BindingFlags.GetProperty, null, shortcut, null);
-                return target as string;
-            }
-            finally
-            {
-                if (shell is IDisposable d)
-                    d.Dispose();
-                else if (Marshal.IsComObject(shell))
-                    Marshal.ReleaseComObject(shell);
-            }
+            shortcut = shellType.InvokeMember(
+                "CreateShortcut",
+                System.Reflection.BindingFlags.InvokeMethod,
+                null,
+                shell,
+                new object[] { shortcutPath });
+            if (shortcut == null) return null;
+
+            var target = shortcut.GetType().InvokeMember(
+                "TargetPath",
+                System.Reflection.BindingFlags.GetProperty,
+                null,
+                shortcut,
+                null);
+            return target as string;
         }
         catch
         {
+            // Not critical: just means shortcut isn't valid or COM not available
             return null;
         }
+        finally
+        {
+            if (shortcut != null && Marshal.IsComObject(shortcut))
+                Marshal.ReleaseComObject(shortcut);
+
+            if (shell is IDisposable d)
+                d.Dispose();
+            else if (shell != null && Marshal.IsComObject(shell))
+                Marshal.ReleaseComObject(shell);
+        }
     }
 }