Update notification service

AppImage/components/notification-settings.tsx

@@ -6,13 +6,13 @@ import { Tabs, TabsList, TabsTrigger, TabsContent } from "./ui/tabs"
 import { Input } from "./ui/input"
 import { Label } from "./ui/label"
 import { Badge } from "./ui/badge"
-import { Checkbox } from "./ui/checkbox"
+
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./ui/select"
 import { fetchApi } from "../lib/api-config"
 import {
   Bell, BellOff, Send, CheckCircle2, XCircle, Loader2,
   AlertTriangle, Info, Settings2, Zap, Eye, EyeOff,
-  Trash2, ChevronDown, ChevronUp, TestTube2, Mail, Webhook,
+  Trash2, ChevronDown, ChevronUp, ChevronRight, TestTube2, Mail, Webhook,
   Copy, Server, Shield
 } from "lucide-react"
 
@@ -34,11 +34,19 @@ interface ChannelConfig {
   subject_prefix?: string
 }
 
+interface EventTypeInfo {
+  type: string
+  title: string
+  default_enabled: boolean
+}
+
 interface NotificationConfig {
   enabled: boolean
   channels: Record<string, ChannelConfig>
   severity_filter: string
   event_categories: Record<string, boolean>
+  event_toggles: Record<string, boolean>
+  event_types_by_group: Record<string, EventTypeInfo[]>
   ai_enabled: boolean
   ai_provider: string
   ai_api_key: string
@@ -101,11 +109,13 @@ const DEFAULT_CONFIG: NotificationConfig = {
     discord: { enabled: false },
     email: { enabled: false },
   },
-  severity_filter: "warning",
+  severity_filter: "all",
   event_categories: {
     system: true, vm_ct: true, backup: true, resources: true,
     storage: true, network: true, security: true, cluster: true,
   },
+  event_toggles: {},
+  event_types_by_group: {},
   ai_enabled: false,
   ai_provider: "openai",
   ai_api_key: "",
@@ -132,6 +142,7 @@ export function NotificationSettings() {
   const [showSecrets, setShowSecrets] = useState<Record<string, boolean>>({})
   const [editMode, setEditMode] = useState(false)
   const [hasChanges, setHasChanges] = useState(false)
+  const [expandedCategories, setExpandedCategories] = useState<Set<string>>(new Set())
   const [originalConfig, setOriginalConfig] = useState<NotificationConfig>(DEFAULT_CONFIG)
   const [webhookSetup, setWebhookSetup] = useState<{
     status: "idle" | "running" | "success" | "failed"
@@ -228,6 +239,12 @@ export function NotificationSettings() {
     for (const [cat, enabled] of Object.entries(cfg.event_categories)) {
       flat[`events.${cat}`] = String(enabled)
     }
+    // Flatten event_toggles: { vm_start: true, vm_stop: false } -> event.vm_start, event.vm_stop
+    if (cfg.event_toggles) {
+      for (const [evt, enabled] of Object.entries(cfg.event_toggles)) {
+        flat[`event.${evt}`] = String(enabled)
+      }
+    }
     return flat
   }
 
@@ -1043,32 +1060,128 @@ matcher: proxmenux-pbs
               {/* Event Categories */}
               <div className="space-y-1.5 border-t border-border/30 pt-3">
                 <Label className="text-[11px] text-muted-foreground">Event Categories</Label>
-              <div className="grid grid-cols-1 sm:grid-cols-2 gap-1.5">
+              <div className="space-y-1.5">
-                {EVENT_CATEGORIES.map(cat => (
+                {EVENT_CATEGORIES.map(cat => {
-                  <label
+                  const isEnabled = config.event_categories[cat.key] ?? true
-                    key={cat.key}
+                  const isExpanded = expandedCategories.has(cat.key)
-                    className={`flex items-start gap-2.5 p-2 rounded-md border border-border/50 transition-colors ${
+                  const eventsForGroup = config.event_types_by_group?.[cat.key] || []
-                      editMode ? "hover:bg-muted/50 cursor-pointer" : "opacity-60"
+                  const enabledCount = eventsForGroup.filter(e => config.event_toggles?.[e.type] ?? e.default_enabled).length
-                    }`}
+                  
-                  >
+                  return (
-                    <Checkbox
+                    <div key={cat.key} className={`rounded-md border transition-colors ${
-                      checked={config.event_categories[cat.key] ?? true}
+                      isEnabled ? "border-green-500/30 bg-green-500/5" : "border-border/50 bg-transparent"
-                      onCheckedChange={checked => {
+                    }`}>
-                        if (!editMode) return
+                      {/* Category header row */}
-                        updateConfig(p => ({
+                      <div className="flex items-center gap-2.5 p-2.5">
-                          ...p,
+                        {/* Expand/collapse button */}
-                          event_categories: { ...p.event_categories, [cat.key]: !!checked },
+                        <button
-                        }))
+                          type="button"
-                      }}
+                          className={`shrink-0 transition-transform ${isExpanded ? "rotate-90" : ""} ${
-                      disabled={!editMode}
+                            !isEnabled ? "opacity-30 pointer-events-none" : "text-muted-foreground hover:text-foreground"
-                      className="mt-0.5"
+                          }`}
-                    />
+                          onClick={() => {
-                    <div className="min-w-0">
+                            if (!isEnabled) return
-                      <span className="text-xs font-medium block">{cat.label}</span>
+                            setExpandedCategories(prev => {
-                      <span className="text-[10px] text-muted-foreground">{cat.desc}</span>
+                              const next = new Set(prev)
+                              if (next.has(cat.key)) next.delete(cat.key)
+                              else next.add(cat.key)
+                              return next
+                            })
+                          }}
+                          aria-label={isExpanded ? "Collapse" : "Expand"}
+                        >
+                          <ChevronRight className="h-3.5 w-3.5" />
+                        </button>
+                        
+                        {/* Label + description */}
+                        <div className="flex-1 min-w-0">
+                          <span className={`text-xs font-medium block ${
+                            isEnabled ? "text-green-400" : "text-foreground"
+                          }`}>
+                            {cat.label}
+                          </span>
+                          <span className="text-[10px] text-muted-foreground">{cat.desc}</span>
+                        </div>
+                        
+                        {/* Count badge */}
+                        {isEnabled && eventsForGroup.length > 0 && (
+                          <span className="text-[10px] text-muted-foreground tabular-nums">
+                            {enabledCount}/{eventsForGroup.length}
+                          </span>
+                        )}
+                        
+                        {/* Category toggle */}
+                        <button
+                          type="button"
+                          role="switch"
+                          aria-checked={isEnabled}
+                          disabled={!editMode}
+                          className={`relative inline-flex h-5 w-9 shrink-0 items-center rounded-full transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ${
+                            !editMode ? "opacity-50 cursor-not-allowed" : "cursor-pointer"
+                          } ${isEnabled ? "bg-green-600" : "bg-muted-foreground/30"}`}
+                          onClick={() => {
+                            if (!editMode) return
+                            const newEnabled = !isEnabled
+                            updateConfig(p => {
+                              const newToggles = { ...(p.event_toggles || {}) }
+                              // When enabling a category, turn all its events on by default
+                              if (newEnabled && eventsForGroup.length > 0) {
+                                for (const evt of eventsForGroup) {
+                                  newToggles[evt.type] = true
+                                }
+                              }
+                              return {
+                                ...p,
+                                event_categories: { ...p.event_categories, [cat.key]: newEnabled },
+                                event_toggles: newToggles,
+                              }
+                            })
+                          }}
+                        >
+                          <span className={`pointer-events-none block h-4 w-4 rounded-full bg-background shadow-sm transition-transform ${
+                            isEnabled ? "translate-x-4" : "translate-x-0.5"
+                          }`} />
+                        </button>
+                      </div>
+                      
+                      {/* Per-event toggles (expanded) */}
+                      {isEnabled && isExpanded && eventsForGroup.length > 0 && (
+                        <div className="border-t border-border/30 px-2.5 py-2 space-y-0.5">
+                          {eventsForGroup.map(evt => {
+                            const evtEnabled = config.event_toggles?.[evt.type] ?? evt.default_enabled
+                            return (
+                              <div key={evt.type} className="flex items-center justify-between py-1 px-2 rounded hover:bg-muted/30 transition-colors">
+                                <span className={`text-[11px] ${evtEnabled ? "text-green-400" : "text-muted-foreground"}`}>
+                                  {evt.title}
+                                </span>
+                                <button
+                                  type="button"
+                                  role="switch"
+                                  aria-checked={evtEnabled}
+                                  disabled={!editMode}
+                                  className={`relative inline-flex h-4 w-7 shrink-0 items-center rounded-full transition-colors focus-visible:outline-none ${
+                                    !editMode ? "opacity-50 cursor-not-allowed" : "cursor-pointer"
+                                  } ${evtEnabled ? "bg-green-600" : "bg-muted-foreground/30"}`}
+                                  onClick={() => {
+                                    if (!editMode) return
+                                    updateConfig(p => ({
+                                      ...p,
+                                      event_toggles: { ...(p.event_toggles || {}), [evt.type]: !evtEnabled },
+                                    }))
+                                  }}
+                                >
+                                  <span className={`pointer-events-none block h-3 w-3 rounded-full bg-background shadow-sm transition-transform ${
+                                    evtEnabled ? "translate-x-3.5" : "translate-x-0.5"
+                                  }`} />
+                                </button>
+                              </div>
+                            )
+                          })}
+                        </div>
+                      )}
                     </div>
-                  </label>
+                  )
-                ))}
+                })}
               </div>
               </div>
               </div>{/* close bordered filters container */}

AppImage/scripts/flask_notification_routes.py

@@ -262,7 +262,7 @@ def setup_proxmox_webhook():
             "",
             f"matcher: {_PVE_MATCHER_ID}",
             f"\ttarget {_PVE_ENDPOINT_ID}",
-            "\tmatch-severity warning,error",
+            "\tmode all",
         ]
     
     try:
@@ -315,7 +315,7 @@ def setup_proxmox_webhook():
         matcher_block = (
             f"matcher: {_PVE_MATCHER_ID}\n"
             f"\ttarget {_PVE_ENDPOINT_ID}\n"
-            f"\tmatch-severity warning,error\n"
+            f"\tmode all\n"
         )
         
         # ── Step 7: Append our blocks to cleaned main config ──

AppImage/scripts/notification_events.py

@@ -835,6 +835,30 @@ class ProxmoxHookWatcher:
         body_lower = (body or '').lower()
         component_lower = (component or '').lower()
         
+        # VM / CT lifecycle events (if sent via webhook)
+        vmid = str(payload.get('vmid', ''))
+        if any(k in component_lower for k in ('qemu', 'lxc', 'vm', 'ct', 'container')):
+            if any(w in title_lower for w in ('start', 'running')):
+                etype = 'ct_start' if 'lxc' in component_lower or 'container' in component_lower else 'vm_start'
+                return etype, 'vm', vmid
+            if any(w in title_lower for w in ('stop', 'shutdown', 'down')):
+                etype = 'ct_stop' if 'lxc' in component_lower or 'container' in component_lower else 'vm_stop'
+                return etype, 'vm', vmid
+            if 'fail' in title_lower or 'crash' in title_lower or 'error' in body_lower:
+                return 'vm_fail', 'vm', vmid
+            if 'migrat' in title_lower:
+                return 'migration_complete', 'vm', vmid
+            return 'vm_start', 'vm', vmid
+        
+        # Also check title for VM keywords if component is not specific
+        if vmid or any(k in title_lower for k in ('vm ', 'ct ', 'qemu', 'lxc')):
+            if 'start' in title_lower:
+                return 'vm_start', 'vm', vmid
+            if any(w in title_lower for w in ('stop', 'shutdown')):
+                return 'vm_stop', 'vm', vmid
+            if 'fail' in title_lower or 'crash' in title_lower:
+                return 'vm_fail', 'vm', vmid
+        
         # Storage / SMART / ZFS / Ceph
         if any(k in component_lower for k in ('smart', 'disk', 'zfs', 'ceph')):
             entity_id = payload.get('device', payload.get('pool', ''))

AppImage/scripts/notification_manager.py

@@ -460,13 +460,28 @@ class NotificationManager:
         if not self._enabled:
             return
         
-        # Check if this event type is enabled in settings
+        # Check if this event's GROUP is enabled in settings.
-        event_setting = f'events.{event.event_type}'
+        # The UI saves categories by group key: events.vm_ct, events.backup, etc.
-        if self._config.get(event_setting, 'true') == 'false':
+        template = TEMPLATES.get(event.event_type, {})
+        event_group = template.get('group', 'system')
+        group_setting = f'events.{event_group}'
+        if self._config.get(group_setting, 'true') == 'false':
             return
         
-        # Check severity filter
+        # Check if this SPECIFIC event type is enabled (granular per-event toggle).
-        min_severity = self._config.get('filter.min_severity', 'INFO')
+        # Key format: event.{event_type} = "true"/"false"
+        # Default comes from the template's default_enabled field.
+        default_enabled = 'true' if template.get('default_enabled', True) else 'false'
+        event_specific = f'event.{event.event_type}'
+        if self._config.get(event_specific, default_enabled) == 'false':
+            return
+        
+        # Check severity filter.
+        # The UI saves severity_filter as: "all", "warning", "critical".
+        # Map to our internal severity names for comparison.
+        severity_map = {'all': 'INFO', 'warning': 'WARNING', 'critical': 'CRITICAL'}
+        raw_filter = self._config.get('severity_filter', 'all')
+        min_severity = severity_map.get(raw_filter.lower(), 'INFO')
         if not self._meets_severity(event.severity, min_severity):
             return
         
@@ -484,8 +499,10 @@ class NotificationManager:
         if not self._enabled:
             return
         
-        # Check severity filter
+        # Check severity filter (same mapping as _process_event)
-        min_severity = self._config.get('filter.min_severity', 'INFO')
+        severity_map = {'all': 'INFO', 'warning': 'WARNING', 'critical': 'CRITICAL'}
+        raw_filter = self._config.get('severity_filter', 'all')
+        min_severity = severity_map.get(raw_filter.lower(), 'INFO')
         if not self._meets_severity(event.severity, min_severity):
             return
         
@@ -955,17 +972,32 @@ class NotificationManager:
                 ch_cfg[config_key] = self._config.get(f'{ch_type}.{config_key}', '')
             channels[ch_type] = ch_cfg
         
-        # Build event_categories dict
+        # Build event_categories dict (group-level toggle)
         # EVENT_GROUPS is a dict: { 'system': {...}, 'vm_ct': {...}, ... }
         event_categories = {}
         for group_key in EVENT_GROUPS:
             event_categories[group_key] = self._config.get(f'events.{group_key}', 'true') == 'true'
         
+        # Build per-event toggles: { 'vm_start': true, 'vm_stop': false, ... }
+        event_toggles = {}
+        for event_type, tmpl in TEMPLATES.items():
+            default = tmpl.get('default_enabled', True)
+            saved = self._config.get(f'event.{event_type}', None)
+            if saved is not None:
+                event_toggles[event_type] = saved == 'true'
+            else:
+                event_toggles[event_type] = default
+        
+        # Build event_types_by_group for UI rendering
+        event_types_by_group = get_event_types_by_group()
+        
         config = {
             'enabled': self._enabled,
             'channels': channels,
-            'severity_filter': self._config.get('severity_filter', 'warning'),
+            'severity_filter': self._config.get('severity_filter', 'all'),
             'event_categories': event_categories,
+            'event_toggles': event_toggles,
+            'event_types_by_group': event_types_by_group,
             'ai_enabled': self._config.get('ai_enabled', 'false') == 'true',
             'ai_provider': self._config.get('ai_provider', 'openai'),
             'ai_api_key': self._config.get('ai_api_key', ''),
@@ -1008,9 +1040,16 @@ class NotificationManager:
             conn.close()
             
             # Rebuild channels with new config
+            was_enabled = self._enabled
             self._enabled = self._config.get('enabled', 'false') == 'true'
             self._rebuild_channels()
             
+            # Start/stop service if enabled state changed
+            if self._enabled and not self._running:
+                self.start()
+            elif not self._enabled and self._running:
+                self.stop()
+            
             return {'success': True, 'channels_active': list(self._channels.keys())}
         except Exception as e:
             return {'success': False, 'error': str(e)}

AppImage/scripts/notification_templates.py

@@ -470,9 +470,15 @@ def get_event_types_by_group() -> Dict[str, list]:
         group = template.get('group', 'system')
         if group not in result:
             result[group] = []
+        import re
+        # Clean title: remove {hostname}: prefix and any remaining {placeholders}
+        title = template['title'].replace('{hostname}', '').strip(': ')
+        title = re.sub(r'\s*\{[^}]+\}', '', title).strip(' -:')
+        if not title:
+            title = event_type.replace('_', ' ').title()
         result[group].append({
             'type': event_type,
-            'title': template['title'].replace('{hostname}', '').strip(': '),
+            'title': title,
             'default_enabled': template.get('default_enabled', True),
         })
     return result