feat: enhance backup management with interactive calendar and improved failure tracking

- Add comprehensive PBS task failure detection and processing
- Implement interactive backup calendar heatmap with detail cards
- Enhance backup filtering with guest type and health status options
- Improve keyboard navigation and search functionality across tabs
- Add backup detail card component for granular backup information
- Update test coverage for enhanced backup data fetching
- Clean up debug logging and improve console output clarity

🤖 Generated with [Claude Code](https://claude.ai/code)

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

Author: rcourtman

data/acknowledgements.json

@@ -549,6 +549,55 @@ async function fetchAllPbsTasksForProcessing({ client, config }, nodeName) {
                 }
             });
 
+            // Add individual guest failure tasks from real backup tasks that didn't match synthetic runs
+            // These represent failed backup attempts where no snapshot was created
+            realBackupTasks.forEach(task => {
+                if (!usedUPIDs.has(task.upid) && task.status !== 'OK') {
+                    // Extract guest info from worker_id (format: "datastore:backup-type/backup-id")
+                    if (task.worker_id) {
+                        const parts = task.worker_id.split(':');
+                        if (parts.length >= 2) {
+                            const guestPart = parts[1];
+                            const guestMatch = guestPart.match(/^([^/]+)\/(.+)$/);
+                            if (guestMatch) {
+                                const guestType = guestMatch[1];
+                                const guestId = guestMatch[2];
+                                const datastoreName = parts[0] || 'unknown';
+                                
+                                // Create a failed backup task entry
+                                const failedBackupRun = {
+                                    type: 'backup',
+                                    status: task.status,
+                                    starttime: task.starttime,
+                                    endtime: task.endtime,
+                                    node: nodeName,
+                                    guest: `${guestType}/${guestId}`,
+                                    guestType: guestType,
+                                    guestId: guestId,
+                                    upid: task.upid,
+                                    comment: task.comment || '',
+                                    size: 0, // No snapshot created
+                                    owner: task.user || 'unknown',
+                                    datastore: datastoreName,
+                                    // PBS-specific fields
+                                    pbsBackupRun: true,
+                                    backupDate: new Date(task.starttime * 1000).toISOString().split('T')[0],
+                                    snapshotCount: 0, // Failed, so no snapshots
+                                    protected: false,
+                                    // Failure details
+                                    failureTask: true,
+                                    exitcode: task.exitcode,
+                                    user: task.user
+                                };
+                                
+                                enhancedBackupRuns.push(failedBackupRun);
+                                usedUPIDs.add(task.upid);
+                            }
+                        }
+                    }
+                }
+            });
+            
             // Add enhanced synthetic backup runs and non-backup admin tasks
             allBackupTasks.push(...enhancedBackupRuns);
             allBackupTasks.push(...nonBackupAdminTasks);
@@ -570,6 +619,23 @@ async function fetchAllPbsTasksForProcessing({ client, config }, nodeName) {
 
         const deduplicatedTasks = Array.from(finalTasksMap.values());
 
+        // Debug logging for PBS task processing
+        const failedTasks = deduplicatedTasks.filter(task => task.status !== 'OK');
+        if (failedTasks.length > 0) {
+            console.log(`[PBS Tasks Debug] Found ${failedTasks.length} failed tasks for ${config.name}:`, 
+                failedTasks.map(task => ({
+                    guestId: task.guestId,
+                    guestType: task.guestType,
+                    status: task.status,
+                    starttime: task.starttime,
+                    upid: task.upid,
+                    failureTask: task.failureTask || false
+                }))
+            );
+        } else {
+            console.log(`[PBS Tasks Debug] No failed tasks found for ${config.name}. Total tasks: ${deduplicatedTasks.length}`);
+        }
+        
         // console.log(`[DataFetcher] Final task count for ${config.name}: ${allBackupTasks.length} -> ${deduplicatedTasks.length} (removed ${allBackupTasks.length - deduplicatedTasks.length} duplicates)`); // Removed verbose log
 
         return { 

server/dataFetcher.js

@@ -53,7 +53,7 @@ function processPbsTasks(allTasks) {
         upid: task.upid,
         node: task.node,
         type: task.worker_type || task.type,
-        id: task.worker_id || task.id,
+        id: task.worker_id || task.id || task.guest, // Include guest as fallback for ID
         status: task.status,
         startTime: task.starttime,
         endTime: task.endtime,
@@ -63,7 +63,10 @@ function processPbsTasks(allTasks) {
         exitStatus: task.exitstatus,
         saved: task.saved || false,
         guest: task.guest || task.worker_id,
-        pbsBackupRun: task.pbsBackupRun
+        pbsBackupRun: task.pbsBackupRun,
+        // Add guest identification fields
+        guestId: task.guestId,
+        guestType: task.guestType
     });
 
     const sortTasksDesc = (a, b) => (b.startTime || 0) - (a.startTime || 0);
@@ -84,6 +87,7 @@ function processPbsTasks(allTasks) {
     const recentVerifyTasks = getRecentTasksList(taskResults.verify.list, createDetailedTask, sortTasksDesc);
     const recentSyncTasks = getRecentTasksList(taskResults.sync.list, createDetailedTask, sortTasksDesc);
     const recentPruneGcTasks = getRecentTasksList(taskResults.pruneGc.list, createDetailedTask, sortTasksDesc);
+    
 
     // Helper function to create the summary object
     const createSummary = (category) => ({ 

server/pbsUtils.js

@@ -109,7 +109,7 @@ describe('Data Fetcher', () => {
       expect(result.vms).toEqual([]);
       expect(result.containers).toEqual([]);
       expect(result.pbs).toEqual([]); // PBS fetch should still run
-      expect(consoleLogSpy).toHaveBeenCalledWith("[DataFetcher] Discovery cycle completed. Found: 0 PVE nodes, 0 VMs, 0 CTs, 0 PBS instances.");
+      expect(consoleLogSpy).toHaveBeenCalledWith("[DataFetcher] Discovery cycle completed. Found: 0 PVE nodes, 0 VMs, 0 CTs, 0 PBS instances, 0 PVE backup tasks, 0 guest snapshots.");
       expect(mockPbsFunction).toHaveBeenCalled(); // Ensure PBS was still called
 
       consoleLogSpy.mockRestore();
@@ -132,20 +132,27 @@ describe('Data Fetcher', () => {
           .mockResolvedValueOnce({ data: { data: { cpu: 0.1, mem: 2 * 1024**3, rootfs: { total: 100*1024**3, used: 20*1024**3 }, uptime: 12345 } } }) // 4. /nodes/mock-node/status
           .mockResolvedValueOnce({ data: { data: [ { storage: 'local-lvm', type: 'lvmthin', content: 'images,rootdir', total: 500*1024**3, used: 150*1024**3 } ] } }) // 5. /nodes/mock-node/storage
           .mockResolvedValueOnce({ data: { data: [ { vmid: vmId, name: 'test-vm', status: 'running', cpu: 0.5, mem: 1 * 1024**3, maxmem: 2 * 1024**3, maxdisk: 32*1024**3 } ] } }) // 6. /nodes/mock-node/qemu
-          .mockResolvedValueOnce({ data: { data: [ { vmid: ctId, name: 'test-ct', status: 'running', cpu: 0.2, mem: 512 * 1024**2, maxmem: 1 * 1024**3, maxdisk: 8*1024**3 } ] } }); // 7. /nodes/mock-node/lxc
+          .mockResolvedValueOnce({ data: { data: [ { vmid: ctId, name: 'test-ct', status: 'running', cpu: 0.2, mem: 512 * 1024**2, maxmem: 1 * 1024**3, maxdisk: 8*1024**3 } ] } }) // 7. /nodes/mock-node/lxc
+          // Additional calls for backup data
+          .mockResolvedValueOnce({ data: { data: [] } }) // 8. /nodes/mock-node/tasks (backup tasks)
+          .mockResolvedValueOnce({ data: { data: [] } }) // 9. /nodes/mock-node/qemu/100/snapshot (VM snapshots)
+          .mockResolvedValueOnce({ data: { data: [] } }); // 10. /nodes/mock-node/lxc/101/snapshot (CT snapshots)
 
       // Act: Call function with the clients provided by the (mocked) default setup
       const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
 
       // Assert
-      expect(mockPveClientInstance.get).toHaveBeenCalledTimes(7); // Updated to 7
+      expect(mockPveClientInstance.get).toHaveBeenCalledTimes(10); // Updated to 10 for backup calls
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(1, '/cluster/status');
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(2, '/nodes'); // For standaloneNodeName
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(3, '/nodes'); // Main nodes call
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(4, `/nodes/${nodeName}/status`);
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(5, `/nodes/${nodeName}/storage`);
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(6, `/nodes/${nodeName}/qemu`);
       expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(7, `/nodes/${nodeName}/lxc`);
+      expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(8, `/nodes/${nodeName}/tasks`, { params: { typefilter: 'vzdump', limit: 1000 } });
+      expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(9, `/nodes/${nodeName}/qemu/${vmId}/snapshot`);
+      expect(mockPveClientInstance.get).toHaveBeenNthCalledWith(10, `/nodes/${nodeName}/lxc/${ctId}/snapshot`);
 
       // Assert Nodes
       expect(result.nodes).toHaveLength(1);
@@ -189,6 +196,12 @@ describe('Data Fetcher', () => {
         id: `${endpointId}-${nodeName}-${ctId}` // Check constructed ID
       });
 
+      // Assert PVE Backups
+      expect(result.pveBackups).toBeDefined();
+      expect(result.pveBackups.backupTasks).toEqual([]);
+      expect(result.pveBackups.storageBackups).toEqual([]);
+      expect(result.pveBackups.guestSnapshots).toEqual([]);
+
       // Assert PBS (should be empty)
       expect(result.pbs).toBeDefined();
       expect(result.pbs).toHaveLength(0);
@@ -289,7 +302,8 @@ describe('Data Fetcher', () => {
         .mockResolvedValueOnce({ data: { data: { cpu: 0.1, uptime: 10 } } })                          // 4. /nodes/node-pve2/status
         .mockResolvedValueOnce({ data: { data: [] } })                                                 // 5. /nodes/node-pve2/storage
         .mockResolvedValueOnce({ data: { data: [] } })                                                 // 6. /nodes/node-pve2/qemu
-        .mockResolvedValueOnce({ data: { data: [] } });                                                // 7. /nodes/node-pve2/lxc  <<< SHOULD BE EMPTY
+        .mockResolvedValueOnce({ data: { data: [] } })                                                // 7. /nodes/node-pve2/lxc  <<< SHOULD BE EMPTY
+        .mockResolvedValueOnce({ data: { data: [] } });                                                // 8. /nodes/node-pve2/tasks (backup tasks)
 
       const result = await fetchDiscoveryData(mockClients, {}); // Pass custom clients
 
@@ -300,7 +314,7 @@ describe('Data Fetcher', () => {
       //  );
 
       // Assert mockPveClientInstance2 (successful endpoint)
-      expect(mockPveClientInstance2.get).toHaveBeenCalledTimes(7);
+      expect(mockPveClientInstance2.get).toHaveBeenCalledTimes(8);
 
       // Should still return data from the successful endpoint (pve2)
       expect(result.nodes).toHaveLength(1);
@@ -700,7 +714,8 @@ describe('Data Fetcher', () => {
         .mockRejectedValueOnce(statusFetchError)                                                          // 4. /nodes/${nodeName}/status << THIS FAILS
         .mockResolvedValueOnce({ data: { data: [] } })                                                   // 5. /nodes/${nodeName}/storage (subsequent calls should still be mocked)
         .mockResolvedValueOnce({ data: { data: [] } })                                                   // 6. /nodes/${nodeName}/qemu
-        .mockResolvedValueOnce({ data: { data: [] } });                                                  // 7. /nodes/${nodeName}/lxc
+        .mockResolvedValueOnce({ data: { data: [] } })                                                  // 7. /nodes/${nodeName}/lxc
+        .mockResolvedValueOnce({ data: { data: [] } });                                                  // 8. /nodes/${nodeName}/tasks (backup tasks)
 
       const result = await fetchDiscoveryData(mockPveApiClient, mockPbsApiClient);
 
@@ -801,7 +816,12 @@ describe('Data Fetcher', () => {
         nodes: [],
         vms: [],
         containers: [],
-        pbs: []
+        pbs: [],
+        pveBackups: {
+          backupTasks: [],
+          guestSnapshots: [],
+          storageBackups: []
+        }
       });
 
       consoleErrorSpy.mockRestore();