feat: scheduled backups, availability tracking, PoE power metrics (v0.11.2 Beta)

P1 — Scheduled Backups
- BackupService.createBackup() now accepts a `type` param (manual/scheduled)
- PollerService: cronMatchesNow() parser + runScheduledBackups() + Redis 1h gate
- Settings page: backup schedule toggle + cron expression input with examples

P2 — Uptime/Availability Tracking
- DB: device_availability table (went_offline_at, came_back_online_at, duration_seconds)
- PollerService: inserts outage rows on offline detection, closes them on recovery
- GET /api/metrics/device/:id/availability?range=30d endpoint
- /api/metrics/summary now includes fleet 30-day uptime %
- DeviceDetailPage: 30-day availability card (uptime %, outage count, longest outage)
- DashboardPage HealthBar: Uptime 30d mini-stat

P3 — PoE Power Draw Metrics
- DeviceCollector.collectPoePower() queries /interface/ethernet/poe/monitor for switches
- Writes poe_power measurement to InfluxDB (tags: device_id, port; fields: watts, current_ma, voltage_v)
- GET /api/metrics/device/:id/poe endpoint (current per-port + 1h history)
- SwitchPortDiagram: amber watt badge on PoE-active ports
- HardwareTab: PoE budget section showing active ports and total watts

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

backend/src/services/BackupService.ts

@@ -25,7 +25,7 @@ export class BackupService {
     }
   }
 
-  async createBackup(device: BackupDevice, notes?: string): Promise<number> {
+  async createBackup(device: BackupDevice, notes?: string, type: string = 'manual'): Promise<number> {
     const sshUser = device.ssh_username || device.api_username;
     const sshPass = device.ssh_password_encrypted
       ? decrypt(device.ssh_password_encrypted)
@@ -53,8 +53,8 @@ export class BackupService {
 
     const rows = await query<{ id: number }>(
       `INSERT INTO backups (device_id, filename, file_path, size_bytes, backup_type, notes)
-       VALUES ($1,$2,$3,$4,'manual',$5) RETURNING id`,
-      [device.id, filename, filePath, stats.size, notes || null]
+       VALUES ($1,$2,$3,$4,$5,$6) RETURNING id`,
+      [device.id, filename, filePath, stats.size, type, notes || null]
     );
 
     return rows[0].id;

backend/src/services/PollerService.ts

@@ -96,6 +96,8 @@ export class PollerService {
       const spectralIntervalHours = (appSettings['spectral_scan_interval_hours'] as number) || 24;
       const apScanEnabled         = appSettings['ap_scan_enabled'] === true;
       const apScanIntervalHours   = (appSettings['ap_scan_interval_hours'] as number) || 24;
+      const backupScheduleEnabled = appSettings['backup_schedule_enabled'] === true;
+      const backupScheduleCron    = (appSettings['backup_schedule_cron'] as string) || '0 2 * * *';
 
       const devices = await query<DeviceRow>(
         `SELECT * FROM devices WHERE status != 'disabled'`
@@ -197,6 +199,19 @@ export class PollerService {
           console.error('[Poller] Client prune error:', e)
         );
       }
+
+      // Scheduled backups — fire when the cron expression matches the current minute/hour.
+      // Redis key with 1-hour TTL prevents double-firing within the same cron window.
+      if (backupScheduleEnabled && this.cronMatchesNow(backupScheduleCron)) {
+        const backupKey = 'task:scheduled_backup';
+        const lastBackup = await this.getTimestamp(backupKey);
+        if (now - lastBackup > 3_600_000) {
+          await this.setTimestamp(backupKey, now);
+          this.runScheduledBackups().catch((e) =>
+            console.error('[Poller] Scheduled backup error:', e)
+          );
+        }
+      }
     } catch (err) {
       console.error('Scheduler error:', err);
     }
@@ -209,7 +224,8 @@ export class PollerService {
          WHERE key IN ('mac_scan_enabled', 'mac_scan_interval', 'reverse_dns_enabled',
                        'retention_clients_days', 'spectral_scan_enabled',
                        'spectral_scan_interval_hours', 'ap_scan_enabled',
-                       'ap_scan_interval_hours')`
+                       'ap_scan_interval_hours', 'backup_schedule_enabled',
+                       'backup_schedule_cron')`
       );
       const map: Record<string, unknown> = {};
       for (const row of rows) map[row.key] = row.value;
@@ -219,6 +235,49 @@ export class PollerService {
     }
   }
 
+  // Returns true if the 5-part cron expression matches the current minute/hour.
+  // Supports: *, exact numbers, comma lists, ranges (a-b), and step values (*/n).
+  private cronMatchesNow(cron: string): boolean {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length < 5) return false;
+    const [minuteField, hourField] = parts;
+    const now = new Date();
+    const matchField = (field: string, val: number): boolean => {
+      if (field === '*') return true;
+      return field.split(',').some((f) => {
+        if (f.includes('/')) {
+          const [base, step] = f.split('/');
+          const start = base === '*' ? 0 : Number(base);
+          return val >= start && (val - start) % Number(step) === 0;
+        }
+        if (f.includes('-')) {
+          const [lo, hi] = f.split('-').map(Number);
+          return val >= lo && val <= hi;
+        }
+        return Number(f) === val;
+      });
+    };
+    return matchField(minuteField, now.getMinutes()) && matchField(hourField, now.getHours());
+  }
+
+  private async runScheduledBackups(): Promise<void> {
+    const { BackupService } = await import('./BackupService');
+    const backupService = new BackupService();
+    const devices = await query<{
+      id: number; name: string; ip_address: string; ssh_port: number;
+      ssh_username: string; ssh_password_encrypted: string;
+      api_username: string; api_password_encrypted: string;
+    }>(`SELECT id, name, ip_address, ssh_port, ssh_username, ssh_password_encrypted,
+               api_username, api_password_encrypted
+        FROM devices WHERE status = 'online'`);
+    console.log(`[Poller] Starting scheduled backup for ${devices.length} online device(s)`);
+    const results = await Promise.allSettled(
+      devices.map((d) => backupService.createBackup(d, 'Scheduled backup', 'scheduled'))
+    );
+    const succeeded = results.filter((r) => r.status === 'fulfilled').length;
+    console.log(`[Poller] Scheduled backup complete: ${succeeded}/${devices.length} succeeded`);
+  }
+
   private async resolveClientHostnames(): Promise<void> {
     const { reverse } = await import('dns/promises');
 
@@ -376,6 +435,16 @@ export class PollerService {
           deviceId: device.id,
           deviceName: device.name,
         }).catch(() => {});
+        // Close the open outage row if one exists
+        if (prevStatus === 'offline') {
+          query(
+            `UPDATE device_availability
+             SET came_back_online_at = NOW(),
+                 duration_seconds = EXTRACT(EPOCH FROM (NOW() - went_offline_at))::INTEGER
+             WHERE device_id = $1 AND came_back_online_at IS NULL`,
+            [device.id]
+          ).catch(() => {});
+        }
       }
 
       this.io?.emit('device:updated', { deviceId: device.id });
@@ -620,6 +689,11 @@ export class PollerService {
         deviceId,
         deviceName: device?.name,
       }).catch(() => {});
+      // Open a new availability outage row
+      query(
+        `INSERT INTO device_availability (device_id, went_offline_at) VALUES ($1, NOW())`,
+        [deviceId]
+      ).catch(() => {});
     }
     // Mark all clients for this device inactive — updateClients() never ran because connect() failed.
     await query(`UPDATE clients SET active = FALSE WHERE device_id = $1`, [deviceId]);

backend/src/services/mikrotik/DeviceCollector.ts

@@ -71,6 +71,9 @@ export class DeviceCollector {
     if (this.device.device_type === 'wireless_ap') {
       await this.collectWirelessStats();
     }
+    if (this.device.device_type === 'switch') {
+      await this.collectPoePower();
+    }
     await this.updateDeviceStatus('online');
   }
 
@@ -1727,6 +1730,37 @@ export class DeviceCollector {
     return this.client.execute('/interface/ethernet/poe/print', { detail: '' }).catch(() => []);
   }
 
+  async collectPoePower(): Promise<void> {
+    try {
+      const ports = await this.client
+        .execute('/interface/ethernet/poe/monitor', { once: '' })
+        .catch(() => [] as Record<string, string>[]);
+      if (ports.length === 0) return;
+
+      const writeApi = getWriteApi();
+      for (const port of ports) {
+        const name = port['name'] || port['port-name'] || '';
+        if (!name) continue;
+        const watts = parseFloat(port['poe-out-voltage'] || '0') * parseFloat(port['poe-out-current'] || '0') / 1000;
+        const currentMa = parseFloat(port['poe-out-current'] || '0');
+        const voltageV = parseFloat(port['poe-out-voltage'] || '0');
+        writeApi.writePoint(
+          new Point('poe_power')
+            .tag('device_id', String(this.device.id))
+            .tag('device_name', this.device.name)
+            .tag('port', name)
+            .floatField('watts', parseFloat(watts.toFixed(2)))
+            .floatField('current_ma', currentMa)
+            .floatField('voltage_v', voltageV)
+            .timestamp(new Date())
+        );
+      }
+      await writeApi.flush().catch((e) => console.error('InfluxDB PoE flush error:', e));
+    } catch (err) {
+      console.error(`[${this.device.name}] Failed to collect PoE power:`, err);
+    }
+  }
+
   // ─── Port VLAN config ─────────────────────────────────────────────────────
 
   async setPortVlanConfig(