fix: NaN-Metriken, Chart-Zeitachse und erweiterte Gerätedetails

Backend:
- AgentGrpcService: JSONB-Serialisierung auf camelCase umgestellt
  (JsonSerializer.SerializeToElement mit CamelCase-Options)
  → behebt NaN bei CPU, RAM, Disk-Anzeige in der Detailseite
- AgentGrpcService: Result-JSONB explizit camelCase (exitCode, stdout, stderr, success)
  → behebt fehlende Befehlsergebnisse im Frontend
- AgentGrpcService: SignalR-Payload enthält nun Disks und NetworkInterfaces
- Program.cs: SignalR JsonProtocol auf CamelCase konfiguriert

Agent (Go):
- Heartbeat sendet nun NetworkInterfaces aus dem Collector
  → Netzwerkschnittstellen werden im Frontend angezeigt

Frontend:
- useAgentSignalR: onLiveMetrics-Callback für direktes Live-Update
  (kein API-Roundtrip mehr, < 50ms Latenz)
- AgentDetailPage komplett überarbeitet:
  - Geräteinformationen-Karte (IP, MAC, OS, Version, Enrolled-At, Last-Seen)
  - Live-Indikator auf MetricCards (grüner Puls-Punkt bei SignalR-Verbindung)
  - NaN-Schutz für alle berechneten Werte (safePercent, memPercent)
  - Chart-Reihenfolge umgekehrt: älteste links, neueste rechts
  - X-Achse: adaptives Intervall verhindert Label-Überlappung
  - Netzwerkschnittstellen-Tabelle mit Traffic (RX/TX)
  - Festplatten mit Fortschrittsbalken + Filesystem-Typ
  - Strg+Enter für schnelle Befehlsausführung

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Agent/cmd/agent/main.go

@@ -208,6 +208,15 @@ func doHeartbeat(ctx context.Context, client *connection.GrpcClient, cfg *config
 			Filesystem: d.Filesystem,
 		})
 	}
+	for _, n := range metrics.Networks {
+		req.Metrics.NetworkInterfaces = append(req.Metrics.NetworkInterfaces, &pb.NetworkInterfaceInfo{
+			Name:       n.Name,
+			IpAddress:  n.IPAddress,
+			MacAddress: n.MAC,
+			BytesSent:  int64(n.BytesSent),
+			BytesRecv:  int64(n.BytesRecv),
+		})
+	}
 
 	resp, err := client.Client.Heartbeat(ctx, req)
 	if err != nil {

Backend/src/NexusRMM.Api/GrpcServices/AgentGrpcService.cs

@@ -14,6 +14,10 @@ namespace NexusRMM.Api.GrpcServices;
 
 public class AgentGrpcService : AgentService.AgentServiceBase
 {
+    private static readonly JsonSerializerOptions _camelCase = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
     private readonly RmmDbContext _db;
     private readonly ILogger<AgentGrpcService> _logger;
     private readonly IHubContext<RmmHub, IRmmHubClient> _hub;
@@ -81,7 +85,7 @@ public class AgentGrpcService : AgentService.AgentServiceBase
         {
             AgentId = agentId,
             Timestamp = DateTime.UtcNow,
-            Metrics = JsonSerializer.SerializeToElement(request.Metrics)
+            Metrics = JsonSerializer.SerializeToElement(request.Metrics, _camelCase)
         });
 
         var pendingTasks = await _db.Tasks
@@ -104,15 +108,30 @@ public class AgentGrpcService : AgentService.AgentServiceBase
 
         await _db.SaveChangesAsync();
 
-        // SignalR: Metriken an agent-Gruppe pushen
+        // SignalR: Metriken an agent-Gruppe pushen (camelCase durch AddJsonProtocol-Konfiguration)
         await _hub.Clients.Group($"agent-{agentId}")
             .AgentMetricsUpdated(request.AgentId, new
             {
-                CpuUsagePercent = request.Metrics?.CpuUsagePercent ?? 0,
-                MemoryUsagePercent = request.Metrics?.MemoryUsagePercent ?? 0,
-                MemoryTotalBytes = request.Metrics?.MemoryTotalBytes ?? 0,
-                MemoryAvailableBytes = request.Metrics?.MemoryAvailableBytes ?? 0,
-                UptimeSeconds = request.Metrics?.UptimeSeconds ?? 0,
+                cpuUsagePercent = request.Metrics?.CpuUsagePercent ?? 0,
+                memoryUsagePercent = request.Metrics?.MemoryUsagePercent ?? 0,
+                memoryTotalBytes = request.Metrics?.MemoryTotalBytes ?? 0,
+                memoryAvailableBytes = request.Metrics?.MemoryAvailableBytes ?? 0,
+                uptimeSeconds = request.Metrics?.UptimeSeconds ?? 0,
+                disks = request.Metrics?.Disks.Select(d => new
+                {
+                    mountPoint = d.MountPoint,
+                    totalBytes = d.TotalBytes,
+                    freeBytes = d.FreeBytes,
+                    filesystem = d.Filesystem,
+                }) ?? [],
+                networkInterfaces = request.Metrics?.NetworkInterfaces.Select(n => new
+                {
+                    name = n.Name,
+                    ipAddress = n.IpAddress,
+                    macAddress = n.MacAddress,
+                    bytesSent = n.BytesSent,
+                    bytesRecv = n.BytesRecv,
+                }) ?? [],
             });
 
         // SignalR: Status-Änderung an alle Clients pushen
@@ -135,11 +154,11 @@ public class AgentGrpcService : AgentService.AgentServiceBase
         taskItem.CompletedAt = DateTime.UtcNow;
         taskItem.Result = JsonSerializer.SerializeToElement(new
         {
-            request.ExitCode,
-            request.Stdout,
-            request.Stderr,
-            request.Success
-        });
+            exitCode = request.ExitCode,
+            stdout = request.Stdout,
+            stderr = request.Stderr,
+            success = request.Success,
+        }, _camelCase);
 
         await _db.SaveChangesAsync();
 

Backend/src/NexusRMM.Api/Program.cs

@@ -19,7 +19,12 @@ builder.Services.AddDbContext<RmmDbContext>(options =>
     options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
 
 builder.Services.AddGrpc();
-builder.Services.AddSignalR();
+builder.Services.AddSignalR()
+    .AddJsonProtocol(options =>
+    {
+        options.PayloadSerializerOptions.PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase;
+        options.PayloadSerializerOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter());
+    });
 builder.Services.AddControllers()
     .AddJsonOptions(options =>
     {

Frontend/src/hooks/useAgentSignalR.ts

@@ -1,31 +1,23 @@
-import { useEffect, useRef } from 'react'
+import { useEffect, useRef, useCallback } from 'react'
 import { useQueryClient } from '@tanstack/react-query'
 import * as signalR from '@microsoft/signalr'
 import { useSignalR } from './useSignalR'
+import type { SystemMetrics } from '../api/types'
 
 const HUB_URL = '/hubs/rmm'
 
-/**
- * Verbindet mit dem SignalR Hub und hört auf globale Agent-Events.
- * Invalidiert TanStack Query-Caches bei Updates.
- */
 export function useGlobalSignalR() {
   const queryClient = useQueryClient()
 
   const { status } = useSignalR({
     url: HUB_URL,
     onConnected: (connection) => {
-      connection.on('AgentStatusChanged', (agentId: string, status: string, _lastSeen: string) => {
-        console.debug('[SignalR] AgentStatusChanged', agentId, status)
-        // Agents-Liste invalidieren damit Dashboard aktuell bleibt
+      connection.on('AgentStatusChanged', (agentId: string, _status: string, _lastSeen: string) => {
         queryClient.invalidateQueries({ queryKey: ['agents'] })
-        // Einzelnen Agent-Cache aktualisieren
         queryClient.invalidateQueries({ queryKey: ['agent', agentId] })
       })
 
-      connection.on('AlertTriggered', (_agentId: string, agentHostname: string, ruleName: string, _message: string, _severity: string) => {
-        console.debug('[SignalR] AlertTriggered', agentHostname, ruleName)
-        // Alerts-Liste invalidieren
+      connection.on('AlertTriggered', () => {
         queryClient.invalidateQueries({ queryKey: ['alerts'] })
       })
     },
@@ -35,36 +27,47 @@ export function useGlobalSignalR() {
 }
 
 /**
- * Tritt der Agent-spezifischen Gruppe bei und hört auf Metriken + Command-Results.
- * Wird in AgentDetailPage verwendet.
+ * Tritt der Agent-Gruppe bei und empfängt Live-Metriken via SignalR.
+ * onLiveMetrics wird mit den aktuellen Metriken aufgerufen (direkt, ohne API-Roundtrip).
  */
-export function useAgentSignalR(agentId: string) {
+export function useAgentSignalR(
+  agentId: string,
+  onLiveMetrics?: (metrics: SystemMetrics) => void,
+) {
   const queryClient = useQueryClient()
   const connectionRef = useRef<signalR.HubConnection | null>(null)
+  const onLiveMetricsRef = useRef(onLiveMetrics)
+
+  // Ref aktuell halten ohne Re-Subscribe zu triggern
+  useEffect(() => {
+    onLiveMetricsRef.current = onLiveMetrics
+  }, [onLiveMetrics])
+
+  const handleMetrics = useCallback((id: string, metrics: SystemMetrics) => {
+    if (id !== agentId) return
+    // Live-Callback aufrufen (kein API-Call nötig)
+    onLiveMetricsRef.current?.(metrics)
+    // Query-Cache auch invalidieren damit historische Daten aktuell bleiben
+    queryClient.invalidateQueries({ queryKey: ['agentMetrics', agentId] })
+  }, [agentId, queryClient])
 
   const { status } = useSignalR({
     url: HUB_URL,
     onConnected: async (connection) => {
       connectionRef.current = connection
 
-      // Gruppe beitreten
       try {
         await connection.invoke('JoinAgentGroup', agentId)
       } catch (err) {
         console.warn('[SignalR] JoinAgentGroup failed:', err)
       }
 
-      connection.on('AgentMetricsUpdated', (id: string) => {
-        if (id === agentId) {
-          // Metriken neu laden
-          queryClient.invalidateQueries({ queryKey: ['agentMetrics', agentId] })
-        }
-      })
+      connection.on('AgentMetricsUpdated', handleMetrics)
 
       connection.on('CommandResultUpdated', (_taskId: string, id: string) => {
         if (id === agentId) {
-          // Tasks neu laden
           queryClient.invalidateQueries({ queryKey: ['agentTasks', agentId] })
+          queryClient.invalidateQueries({ queryKey: ['agent', agentId] })
         }
       })
     },
@@ -73,7 +76,6 @@ export function useAgentSignalR(agentId: string) {
     },
   })
 
-  // Gruppe verlassen wenn Komponente unmountet
   useEffect(() => {
     return () => {
       connectionRef.current?.invoke('LeaveAgentGroup', agentId).catch(() => {})