feat: Windows compatibility (#836)

* feat: win compatibility

* fix

* fix: uptime parse

* opt.: linux uptime accuracy

* fix: windows temperature fetching

* opt.

* opt.: powershell exec

* refactor: address PR review feedback and improve code quality

### Major Improvements:
- **Refactored Windows status parsing**: Broke down large `_getWindowsStatus` method into 13 smaller, focused helper methods for better maintainability and readability
- **Extracted system detection logic**: Created dedicated `SystemDetector` helper class to separate OS detection concerns from ServerProvider
- **Improved concurrency handling**: Implemented proper synchronization for server updates using Future-based locks to prevent race conditions

### Bug Fixes:
- **Fixed CPU percentage parsing**: Removed incorrect '*100' multiplication in BSD CPU parsing (values were already percentages)
- **Enhanced memory parsing**: Added validation and error handling to BSD memory fallback parsing with proper logging
- **Improved uptime parsing**: Added support for multiple Windows date formats and robust error handling with validation
- **Fixed division by zero**: Added safety checks in Swap.usedPercent getter

### Code Quality Enhancements:
- **Added comprehensive documentation**: Documented Windows CPU counter limitations and approach
- **Strengthened error handling**: Added detailed logging and validation throughout parsing methods
- **Improved robustness**: Enhanced BSD CPU parsing with percentage validation and warnings
- **Better separation of concerns**: Each parsing method now has single responsibility

### Files Changed:
- `lib/data/helper/system_detector.dart` (new): System detection helper
- `lib/data/model/server/cpu.dart`: Fixed percentage parsing and added validation
- `lib/data/model/server/memory.dart`: Enhanced fallback parsing and division-by-zero protection
- `lib/data/model/server/server_status_update_req.dart`: Refactored into 13 focused parsing methods
- `lib/data/provider/server.dart`: Improved synchronization and extracted system detection

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

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

* refactor: parse & shell fn struct

---------

Co-authored-by: Claude <noreply@anthropic.com>

lib/data/model/server/cpu.dart

@@ -200,22 +200,98 @@ final class CpuBrand {
 }
 
 final _bsdCpuPercentReg = RegExp(r'(\d+\.\d+)%');
+final _macCpuPercentReg = RegExp(
+    r'CPU usage: ([\d.]+)% user, ([\d.]+)% sys, ([\d.]+)% idle');
+final _freebsdCpuPercentReg = RegExp(
+    r'CPU: ([\d.]+)% user, ([\d.]+)% nice, ([\d.]+)% system, '
+    r'([\d.]+)% interrupt, ([\d.]+)% idle');
 
-/// TODO: Change this implementation to parse cpu status on BSD system
+/// Parse CPU status on BSD system with support for different BSD variants
 ///
-/// [raw]:
-/// CPU usage: 14.70% user, 12.76% sys, 72.52% idle
+/// Supports multiple formats:
+/// - macOS: "CPU usage: 14.70% user, 12.76% sys, 72.52% idle"
+/// - FreeBSD: "CPU: 5.2% user, 0.0% nice, 3.1% system, 0.1% interrupt, 91.6% idle"
+/// - Generic BSD: fallback to percentage extraction
 Cpus parseBsdCpu(String raw) {
+  final init = InitStatus.cpus;
+  
+  // Try macOS format first
+  final macMatch = _macCpuPercentReg.firstMatch(raw);
+  if (macMatch != null) {
+    final userPercent = double.parse(macMatch.group(1)!).toInt();
+    final sysPercent = double.parse(macMatch.group(2)!).toInt();
+    final idlePercent = double.parse(macMatch.group(3)!).toInt();
+    
+    init.add([
+      SingleCpuCore(
+        'cpu0',
+        userPercent,
+        sysPercent,
+        0, // nice
+        idlePercent,
+        0, // iowait
+        0, // irq
+        0, // softirq
+      ),
+    ]);
+    return init;
+  }
+  
+  // Try FreeBSD format
+  final freebsdMatch = _freebsdCpuPercentReg.firstMatch(raw);
+  if (freebsdMatch != null) {
+    final userPercent = double.parse(freebsdMatch.group(1)!).toInt();
+    final nicePercent = double.parse(freebsdMatch.group(2)!).toInt();
+    final sysPercent = double.parse(freebsdMatch.group(3)!).toInt();
+    final irqPercent = double.parse(freebsdMatch.group(4)!).toInt();
+    final idlePercent = double.parse(freebsdMatch.group(5)!).toInt();
+    
+    init.add([
+      SingleCpuCore(
+        'cpu0',
+        userPercent,
+        sysPercent,
+        nicePercent,
+        idlePercent,
+        0, // iowait
+        irqPercent,
+        0, // softirq
+      ),
+    ]);
+    return init;
+  }
+  
+  // Fallback to generic percentage extraction
   final percents = _bsdCpuPercentReg
       .allMatches(raw)
-      .map((e) => double.parse(e.group(1) ?? '0') * 100)
+      .map((e) => double.parse(e.group(1) ?? '0'))
       .toList();
-  if (percents.length != 3) return InitStatus.cpus;
-
-  final init = InitStatus.cpus;
-  init.add([
-    SingleCpuCore('cpu', percents[0].toInt(), 0, 0,
-        percents[2].toInt() + percents[1].toInt(), 0, 0, 0),
-  ]);
+  
+  if (percents.length >= 3) {
+    // Validate that percentages are reasonable (0-100 range)
+    final validPercents = percents.where((p) => p >= 0 && p <= 100).toList();
+    if (validPercents.length != percents.length) {
+      Loggers.app.warning('BSD CPU fallback parsing found invalid percentages in: $raw');
+    }
+    
+    init.add([
+      SingleCpuCore(
+        'cpu0',
+        percents[0].toInt(), // user
+        percents.length > 1 ? percents[1].toInt() : 0, // sys
+        0, // nice
+        percents.length > 2 ? percents[2].toInt() : 0, // idle
+        0, // iowait
+        0, // irq
+        0, // softirq
+      ),
+    ]);
+    return init;
+  } else if (percents.isNotEmpty) {
+    Loggers.app.warning('BSD CPU fallback parsing found ${percents.length} percentages (expected at least 3) in: $raw');
+  } else {
+    Loggers.app.warning('BSD CPU fallback parsing found no percentages in: $raw');
+  }
+  
   return init;
 }