feat: replace debug view polling with real-time SignalR streaming

The debug view polled every 2s by re-subscribing for full snapshots. Now a
persistent DebugStreamBridgeActor on central subscribes once and receives
incremental Akka stream events from the site, forwarding them to the Blazor
component via callbacks and to the CLI via a new SignalR hub at
/hubs/debug-stream. Adds `debug stream` CLI command with auto-reconnect.

src/ScadaLink.Communication/DebugStreamService.cs

@@ -0,0 +1,146 @@
+using System.Collections.Concurrent;
+using Akka.Actor;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Messages.DebugView;
+using ScadaLink.Communication.Actors;
+
+namespace ScadaLink.Communication;
+
+/// <summary>
+/// Manages debug stream sessions by creating DebugStreamBridgeActors that persist
+/// as subscribers on the site side. Both the Blazor debug view and the SignalR hub
+/// use this service to start/stop streams.
+/// </summary>
+public class DebugStreamService
+{
+    private readonly CommunicationService _communicationService;
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ILogger<DebugStreamService> _logger;
+    private readonly ConcurrentDictionary<string, IActorRef> _sessions = new();
+    private ActorSystem? _actorSystem;
+
+    public DebugStreamService(
+        CommunicationService communicationService,
+        IServiceProvider serviceProvider,
+        ILogger<DebugStreamService> logger)
+    {
+        _communicationService = communicationService;
+        _serviceProvider = serviceProvider;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Sets the ActorSystem reference. Called during actor system startup (from AkkaHostedService).
+    /// </summary>
+    public void SetActorSystem(ActorSystem actorSystem)
+    {
+        _actorSystem = actorSystem;
+    }
+
+    /// <summary>
+    /// Starts a debug stream session. Returns the initial snapshot.
+    /// Ongoing events are delivered via the onEvent callback.
+    /// The onTerminated callback fires if the stream is killed (site disconnect, timeout).
+    /// </summary>
+    public async Task<DebugStreamSession> StartStreamAsync(
+        int instanceId,
+        Action<object> onEvent,
+        Action onTerminated,
+        CancellationToken ct = default)
+    {
+        var system = _actorSystem
+            ?? throw new InvalidOperationException("DebugStreamService not initialized. ActorSystem not set.");
+
+        // Resolve instance → unique name + site
+        string instanceUniqueName;
+        string siteIdentifier;
+
+        using (var scope = _serviceProvider.CreateScope())
+        {
+            var instanceRepo = scope.ServiceProvider.GetRequiredService<ITemplateEngineRepository>();
+            var instance = await instanceRepo.GetInstanceByIdAsync(instanceId)
+                ?? throw new InvalidOperationException($"Instance {instanceId} not found.");
+
+            var siteRepo = scope.ServiceProvider.GetRequiredService<ISiteRepository>();
+            var site = await siteRepo.GetSiteByIdAsync(instance.SiteId)
+                ?? throw new InvalidOperationException($"Site {instance.SiteId} not found.");
+
+            instanceUniqueName = instance.UniqueName;
+            siteIdentifier = site.SiteIdentifier;
+        }
+
+        var sessionId = Guid.NewGuid().ToString("N");
+
+        // Capture the initial snapshot via a TaskCompletionSource
+        var snapshotTcs = new TaskCompletionSource<DebugViewSnapshot>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        Action<object> onEventWrapper = evt =>
+        {
+            if (evt is DebugViewSnapshot snapshot && !snapshotTcs.Task.IsCompleted)
+            {
+                snapshotTcs.TrySetResult(snapshot);
+            }
+            else
+            {
+                onEvent(evt);
+            }
+        };
+
+        Action onTerminatedWrapper = () =>
+        {
+            _sessions.TryRemove(sessionId, out _);
+            snapshotTcs.TrySetException(new InvalidOperationException("Debug stream terminated before snapshot received."));
+            onTerminated();
+        };
+
+        // Create the bridge actor — use type-based Props to avoid expression tree limitations with closures
+        var commActor = _communicationService.GetCommunicationActor();
+
+        var props = Props.Create(typeof(DebugStreamBridgeActor),
+            siteIdentifier,
+            instanceUniqueName,
+            sessionId,
+            commActor,
+            onEventWrapper,
+            onTerminatedWrapper);
+
+        var bridgeActor = system.ActorOf(props, $"debug-stream-{sessionId}");
+
+        _sessions[sessionId] = bridgeActor;
+
+        // Wait for the initial snapshot (with timeout)
+        using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        timeoutCts.CancelAfter(TimeSpan.FromSeconds(30));
+
+        try
+        {
+            var snapshot = await snapshotTcs.Task.WaitAsync(timeoutCts.Token);
+
+            _logger.LogInformation("Debug stream {SessionId} started for {Instance} on site {Site}",
+                sessionId, instanceUniqueName, siteIdentifier);
+
+            return new DebugStreamSession(sessionId, snapshot);
+        }
+        catch (OperationCanceledException)
+        {
+            StopStream(sessionId);
+            throw new TimeoutException($"Timed out waiting for debug snapshot from {instanceUniqueName} on site {siteIdentifier}.");
+        }
+    }
+
+    /// <summary>
+    /// Stops an active debug stream session.
+    /// </summary>
+    public void StopStream(string sessionId)
+    {
+        if (_sessions.TryRemove(sessionId, out var bridgeActor))
+        {
+            bridgeActor.Tell(new StopDebugStream());
+            _logger.LogInformation("Debug stream {SessionId} stopped", sessionId);
+        }
+    }
+}
+
+public record DebugStreamSession(string SessionId, DebugViewSnapshot InitialSnapshot);