[Init] Initial commit - NetMesh terminal manager

infrastructure/systemMonitor/systemMonitorAdapters.ts

@@ -0,0 +1,617 @@
+// System monitor adapter interface and implementations
+// These adapters parse command output into structured metrics data.
+// The actual command execution happens via IPC (netcatty:ssh:exec).
+
+import type {
+  CpuUsage,
+  MemoryUsage,
+  DiskUsage,
+  NetworkTraffic,
+  SystemLoad,
+  ProcessInfo,
+  DockerContainer,
+  ListeningPort,
+  SystemService,
+  SystemMetricsSnapshot,
+} from '../../domain/systemMonitor';
+
+/**
+ * Adapter interface for collecting system metrics from a remote host.
+ * Each OS/device type has its own implementation.
+ */
+export interface SystemMonitorAdapter {
+  /** OS family this adapter handles */
+  readonly osFamily: 'linux' | 'windows' | 'network';
+
+  /** Build a single command that collects all fast metrics (CPU, mem, load, uptime) */
+  buildFastMetricsCommand(): string;
+
+  /** Parse the output of fast metrics command */
+  parseFastMetrics(output: string): Partial<SystemMetricsSnapshot>;
+
+  /** Build command for disk usage */
+  buildDiskCommand(): string;
+  /** Parse disk usage output */
+  parseDiskOutput(output: string): DiskUsage[];
+
+  /** Build command for network traffic (current snapshot) */
+  buildNetworkCommand(): string;
+  /** Parse network output, needs prev snapshot for speed calc */
+  parseNetworkOutput(output: string, prev?: NetworkTraffic[], intervalMs?: number): NetworkTraffic[];
+
+  /** Build command for process list */
+  buildProcessCommand(limit?: number): string;
+  /** Parse process list output */
+  parseProcessOutput(output: string): ProcessInfo[];
+
+  /** Build command for docker containers */
+  buildDockerCommand(): string;
+  /** Parse docker output */
+  parseDockerOutput(output: string): DockerContainer[];
+
+  /** Build command for listening ports */
+  buildPortsCommand(): string;
+  /** Parse listening ports output */
+  parsePortsOutput(output: string): ListeningPort[];
+
+  /** Build command for system services */
+  buildServicesCommand(): string;
+  /** Parse services output */
+  parseServicesOutput(output: string): SystemService[];
+}
+
+// ============================================================================
+// Linux adapter
+// ============================================================================
+
+export class LinuxMonitorAdapter implements SystemMonitorAdapter {
+  readonly osFamily = 'linux' as const;
+
+  buildFastMetricsCommand(): string {
+    // Collect CPU, memory, load, uptime, hostname in one shot
+    // Using /proc for reliable parsing, plus uptime and hostname
+    return `cat /proc/stat | head -1; echo "---MEM---"; cat /proc/meminfo; echo "---LOAD---"; cat /proc/loadavg; echo "---UPTIME---"; cat /proc/uptime; echo "---HOST---"; hostname; echo "---OS---"; cat /etc/os-release 2>/dev/null | head -5 || uname -r`;
+  }
+
+  parseFastMetrics(output: string): Partial<SystemMetricsSnapshot> {
+    const result: Partial<SystemMetricsSnapshot> = {};
+    const sections = output.split(/^---[A-Z]+---$/m);
+
+    // CPU from /proc/stat (first line)
+    const cpuLine = sections[0]?.trim().split('\n')[0];
+    if (cpuLine) {
+      const parts = cpuLine.trim().split(/\s+/);
+      // cpu user nice system idle iowait irq softirq steal guest guest_nice
+      if (parts.length >= 5) {
+        const user = parseInt(parts[1]) || 0;
+        const nice = parseInt(parts[2]) || 0;
+        const system = parseInt(parts[3]) || 0;
+        const idle = parseInt(parts[4]) || 0;
+        const iowait = parts[5] ? parseInt(parts[5]) : 0;
+        const total = user + nice + system + idle + iowait +
+          (parts[6] ? parseInt(parts[6]) : 0) +
+          (parts[7] ? parseInt(parts[7]) : 0) +
+          (parts[8] ? parseInt(parts[8]) : 0);
+        // We can't compute percentage without previous sample, so we store raw
+        // For single snapshot, try to use more clever approach
+        result.cpu = {
+          totalPercent: 0, // will be calculated with delta
+          cores: [],
+          userPercent: 0,
+          systemPercent: 0,
+          idlePercent: 0,
+        };
+        (result.cpu as any)._rawTotal = total;
+        (result.cpu as any)._rawIdle = idle;
+        (result.cpu as any)._rawUser = user;
+        (result.cpu as any)._rawSystem = system;
+      }
+    }
+
+    // Memory from /proc/meminfo
+    const memSection = sections[1];
+    if (memSection) {
+      const memInfo = this.parseMemInfo(memSection);
+      if (memInfo) result.memory = memInfo;
+    }
+
+    // Load average
+    const loadSection = sections[2];
+    if (loadSection) {
+      const loadParts = loadSection.trim().split(/\s+/);
+      if (loadParts.length >= 3) {
+        result.load = {
+          load1: parseFloat(loadParts[0]) || 0,
+          load5: parseFloat(loadParts[1]) || 0,
+          load15: parseFloat(loadParts[2]) || 0,
+        };
+      }
+    }
+
+    // Uptime
+    const uptimeSection = sections[3];
+    if (uptimeSection) {
+      const uptimeVal = parseFloat(uptimeSection.trim().split(/\s+/)[0]);
+      if (!isNaN(uptimeVal)) result.uptimeSeconds = Math.floor(uptimeVal);
+    }
+
+    // Hostname
+    const hostSection = sections[4];
+    if (hostSection) {
+      result.hostname = hostSection.trim();
+    }
+
+    // OS info
+    const osSection = sections[5];
+    if (osSection) {
+      const prettyMatch = osSection.match(/PRETTY_NAME="?([^"\n]+)"?/);
+      if (prettyMatch) result.osName = prettyMatch[1];
+    }
+
+    return result;
+  }
+
+  private parseMemInfo(output: string): MemoryUsage | null {
+    const lines = output.trim().split('\n');
+    const info: Record<string, number> = {};
+    for (const line of lines) {
+      const m = line.match(/^(\S+):\s+(\d+)/);
+      if (m) info[m[1]] = parseInt(m[2]) * 1024; // kB -> bytes
+    }
+    const total = info['MemTotal'] || 0;
+    const free = info['MemFree'] || 0;
+    const buffers = info['Buffers'] || 0;
+    const cached = info['Cached'] || 0;
+    const sreclaimable = info['SReclaimable'] || 0;
+    const used = total - free - buffers - cached - sreclaimable;
+    const percent = total > 0 ? (used / total) * 100 : 0;
+
+    return {
+      totalBytes: total,
+      usedBytes: used,
+      freeBytes: free + buffers + cached + sreclaimable,
+      percent,
+      cachedBytes: cached + buffers + sreclaimable,
+      swapUsedBytes: (info['SwapTotal'] || 0) - (info['SwapFree'] || 0),
+      swapTotalBytes: info['SwapTotal'] || 0,
+    };
+  }
+
+  buildDiskCommand(): string {
+    return `df -PT -x tmpfs -x devtmpfs -x overlay -x squashfs 2>/dev/null | tail -n +2`;
+  }
+
+  parseDiskOutput(output: string): DiskUsage[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const disks: DiskUsage[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      // Filesystem Type Size Used Avail Use% Mounted on
+      if (parts.length >= 7) {
+        const total = parseInt(parts[2]) * 1024; // KB -> bytes
+        const used = parseInt(parts[3]) * 1024;
+        const avail = parseInt(parts[4]) * 1024;
+        const usePercent = parseInt(parts[5]);
+        const mountPoint = parts.slice(6).join(' ');
+        disks.push({
+          filesystem: parts[0],
+          mountPoint,
+          totalBytes: total,
+          usedBytes: used,
+          freeBytes: avail,
+          percent: usePercent,
+        });
+      }
+    }
+    return disks;
+  }
+
+  buildNetworkCommand(): string {
+    return `cat /proc/net/dev | tail -n +3`;
+  }
+
+  parseNetworkOutput(output: string, prev?: NetworkTraffic[], intervalMs: number = 2000): NetworkTraffic[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const current: Map<string, { rx: number; tx: number }> = new Map();
+
+    for (const line of lines) {
+      const parts = line.trim().split(/[:\s]+/);
+      if (parts.length >= 10) {
+        const iface = parts[0];
+        if (iface === 'lo' || !iface) continue;
+        const rxBytes = parseInt(parts[1]) || 0;
+        const txBytes = parseInt(parts[9]) || 0;
+        current.set(iface, { rx: rxBytes, tx: txBytes });
+      }
+    }
+
+    const results: NetworkTraffic[] = [];
+    const intervalSec = intervalMs / 1000;
+
+    for (const [iface, curr] of current) {
+      const prevItem = prev?.find(p => p.interfaceName === iface);
+      let rxSpeed = 0;
+      let txSpeed = 0;
+      if (prevItem && prevItem.rxTotalBytes !== undefined && prevItem.txTotalBytes !== undefined) {
+        rxSpeed = Math.max(0, (curr.rx - prevItem.rxTotalBytes) / intervalSec);
+        txSpeed = Math.max(0, (curr.tx - prevItem.txTotalBytes) / intervalSec);
+      }
+      results.push({
+        interfaceName: iface,
+        rxBytesPerSec: rxSpeed,
+        txBytesPerSec: txSpeed,
+        rxTotalBytes: curr.rx,
+        txTotalBytes: curr.tx,
+      });
+    }
+
+    return results;
+  }
+
+  buildProcessCommand(limit: number = 20): string {
+    return `ps -eo pid,user,%cpu,%mem,rss,comm,stat --sort=-%cpu --no-headers | head -${limit}`;
+  }
+
+  parseProcessOutput(output: string): ProcessInfo[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const processes: ProcessInfo[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 7) {
+        processes.push({
+          pid: parseInt(parts[0]) || 0,
+          user: parts[1],
+          cpuPercent: parseFloat(parts[2]) || 0,
+          memPercent: parseFloat(parts[3]) || 0,
+          memBytes: (parseInt(parts[4]) || 0) * 1024, // KB -> bytes
+          name: parts[5],
+          status: parts[6],
+        });
+      }
+    }
+    return processes;
+  }
+
+  buildDockerCommand(): string {
+    return `docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.State}}" 2>/dev/null || echo "DOCKER_NOT_FOUND"`;
+  }
+
+  parseDockerOutput(output: string): DockerContainer[] {
+    if (output.includes('DOCKER_NOT_FOUND') || output.trim() === '') return [];
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const containers: DockerContainer[] = [];
+    for (const line of lines) {
+      const parts = line.split('|');
+      if (parts.length >= 5) {
+        containers.push({
+          id: parts[0],
+          name: parts[1],
+          image: parts[2],
+          status: parts[3],
+          state: (parts[4].toLowerCase() as DockerContainer['state']) || 'unknown',
+        });
+      }
+    }
+    return containers;
+  }
+
+  buildPortsCommand(): string {
+    return `ss -tulnp 2>/dev/null || netstat -tulnp 2>/dev/null || echo "PORTS_NOT_AVAILABLE"`;
+  }
+
+  parsePortsOutput(output: string): ListeningPort[] {
+    if (output.includes('PORTS_NOT_AVAILABLE')) return [];
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const ports: ListeningPort[] = [];
+    const seen = new Set<string>();
+
+    for (const line of lines) {
+      if (line.startsWith('State') || line.startsWith('Proto')) continue;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 5) continue;
+
+      const proto = parts[0].toLowerCase().includes('tcp') ? 'tcp' :
+                    parts[0].toLowerCase().includes('udp') ? 'udp' : 'tcp';
+      const localAddr = parts.find(p => p.includes(':') && !p.startsWith('0x'));
+      if (!localAddr) continue;
+
+      const lastColonIdx = localAddr.lastIndexOf(':');
+      const addr = localAddr.substring(0, lastColonIdx).replace(/^\[|\]$/g, '');
+      const portStr = localAddr.substring(lastColonIdx + 1);
+      const port = parseInt(portStr);
+      if (!port || isNaN(port)) continue;
+
+      const key = `${proto}:${port}:${addr}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      // Try to find process info
+      let processName = '';
+      let pid: number | undefined;
+      const procMatch = line.match(/users:\(\("([^"]+)"/);
+      const pidMatch = line.match(/pid=(\d+)/);
+      if (procMatch) processName = procMatch[1];
+      if (pidMatch) pid = parseInt(pidMatch[1]);
+
+      ports.push({
+        port,
+        protocol: proto as 'tcp' | 'udp',
+        address: addr || '0.0.0.0',
+        process: processName || undefined,
+        pid,
+        state: parts[1] || undefined,
+      });
+    }
+
+    return ports.sort((a, b) => a.port - b.port);
+  }
+
+  buildServicesCommand(): string {
+    return `systemctl list-units --type=service --all --no-pager --no-legend 2>/dev/null || echo "SYSTEMD_NOT_FOUND"`;
+  }
+
+  parseServicesOutput(output: string): SystemService[] {
+    if (output.includes('SYSTEMD_NOT_FOUND')) return [];
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const services: SystemService[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 4) continue;
+      const name = parts[0];
+      const load = parts[1];
+      const active = parts[2];
+      const sub = parts[3];
+      const desc = parts.slice(4).join(' ');
+
+      let state: SystemService['state'] = 'unknown';
+      if (active === 'active' && (sub === 'running' || sub === 'exited')) state = 'running';
+      else if (active === 'inactive' || active === 'failed') state = active === 'failed' ? 'failed' : 'stopped';
+
+      services.push({
+        name,
+        state,
+        description: desc,
+      });
+    }
+    return services.slice(0, 50); // limit
+  }
+}
+
+// ============================================================================
+// Windows adapter (for SSH-connected Windows servers)
+// ============================================================================
+
+export class WindowsMonitorAdapter implements SystemMonitorAdapter {
+  readonly osFamily = 'windows' as const;
+
+  buildFastMetricsCommand(): string {
+    return `powershell -NoProfile -Command "
+      $cpu = Get-WmiObject Win32_Processor | Measure-Object -Property LoadPercentage -Average | Select-Object -ExpandProperty Average;
+      $os = Get-WmiObject Win32_OperatingSystem;
+      $memTotal = $os.TotalVisibleMemorySize * 1024;
+      $memFree = $os.FreePhysicalMemory * 1024;
+      $memUsed = $memTotal - $memFree;
+      $memPct = if ($memTotal -gt 0) { [math]::Round(($memUsed / $memTotal) * 100, 1) } else { 0 };
+      $uptime = (Get-Date) - $os.ConvertToDateTime($os.LastBootUpTime);
+      $hostName = $env:COMPUTERNAME;
+      $osName = $os.Caption;
+      Write-Output \"CPU:$cpu\";
+      Write-Output \"MEM_TOTAL:$memTotal\";
+      Write-Output \"MEM_USED:$memUsed\";
+      Write-Output \"MEM_FREE:$memFree\";
+      Write-Output \"MEM_PCT:$memPct\";
+      Write-Output \"UPTIME:$([int]$uptime.TotalSeconds)\";
+      Write-Output \"HOSTNAME:$hostName\";
+      Write-Output \"OS:$osName\";
+    " 2>$null`;
+  }
+
+  parseFastMetrics(output: string): Partial<SystemMetricsSnapshot> {
+    const result: Partial<SystemMetricsSnapshot> = {};
+    const lines = output.trim().split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('CPU:')) {
+        const val = parseFloat(trimmed.substring(4)) || 0;
+        result.cpu = { totalPercent: val, cores: [] };
+      } else if (trimmed.startsWith('MEM_TOTAL:')) {
+        if (!result.memory) result.memory = { totalBytes: 0, usedBytes: 0, freeBytes: 0, percent: 0 };
+        result.memory.totalBytes = parseInt(trimmed.substring(10)) || 0;
+      } else if (trimmed.startsWith('MEM_USED:')) {
+        if (!result.memory) result.memory = { totalBytes: 0, usedBytes: 0, freeBytes: 0, percent: 0 };
+        result.memory.usedBytes = parseInt(trimmed.substring(9)) || 0;
+      } else if (trimmed.startsWith('MEM_FREE:')) {
+        if (!result.memory) result.memory = { totalBytes: 0, usedBytes: 0, freeBytes: 0, percent: 0 };
+        result.memory.freeBytes = parseInt(trimmed.substring(9)) || 0;
+      } else if (trimmed.startsWith('MEM_PCT:')) {
+        if (!result.memory) result.memory = { totalBytes: 0, usedBytes: 0, freeBytes: 0, percent: 0 };
+        result.memory.percent = parseFloat(trimmed.substring(8)) || 0;
+      } else if (trimmed.startsWith('UPTIME:')) {
+        result.uptimeSeconds = parseInt(trimmed.substring(7)) || 0;
+      } else if (trimmed.startsWith('HOSTNAME:')) {
+        result.hostname = trimmed.substring(9);
+      } else if (trimmed.startsWith('OS:')) {
+        result.osName = trimmed.substring(3);
+      }
+    }
+
+    return result;
+  }
+
+  buildDiskCommand(): string {
+    return `powershell -NoProfile -Command "Get-PSDrive -PSProvider FileSystem | Where-Object { $_.Used -gt 0 } | ForEach-Object { $total = $_.Used + $_.Free; $pct = if ($total -gt 0) { [math]::Round(($_.Used / $total) * 100, 1) } else { 0 }; Write-Output '$($_.Name)|$total|$($_.Used)|$($_.Free)|$pct|$($_.Root)' }" 2>$null`;
+  }
+
+  parseDiskOutput(output: string): DiskUsage[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const disks: DiskUsage[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split('|');
+      if (parts.length >= 6) {
+        disks.push({
+          filesystem: parts[0],
+          mountPoint: parts[5],
+          totalBytes: parseInt(parts[1]) || 0,
+          usedBytes: parseInt(parts[2]) || 0,
+          freeBytes: parseInt(parts[3]) || 0,
+          percent: parseFloat(parts[4]) || 0,
+        });
+      }
+    }
+    return disks;
+  }
+
+  buildNetworkCommand(): string {
+    return `powershell -NoProfile -Command "Get-NetAdapterStatistics -ErrorAction SilentlyContinue | ForEach-Object { Write-Output '$($_.Name)|$($_.ReceivedBytes)|$($_.SentBytes)' }" 2>$null`;
+  }
+
+  parseNetworkOutput(output: string, prev?: NetworkTraffic[], intervalMs: number = 2000): NetworkTraffic[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const current: Map<string, { rx: number; tx: number }> = new Map();
+
+    for (const line of lines) {
+      const parts = line.trim().split('|');
+      if (parts.length >= 3) {
+        current.set(parts[0], {
+          rx: parseInt(parts[1]) || 0,
+          tx: parseInt(parts[2]) || 0,
+        });
+      }
+    }
+
+    const results: NetworkTraffic[] = [];
+    const intervalSec = intervalMs / 1000;
+
+    for (const [iface, curr] of current) {
+      const prevItem = prev?.find(p => p.interfaceName === iface);
+      let rxSpeed = 0;
+      let txSpeed = 0;
+      if (prevItem && prevItem.rxTotalBytes !== undefined && prevItem.txTotalBytes !== undefined) {
+        rxSpeed = Math.max(0, (curr.rx - prevItem.rxTotalBytes) / intervalSec);
+        txSpeed = Math.max(0, (curr.tx - prevItem.txTotalBytes) / intervalSec);
+      }
+      results.push({
+        interfaceName: iface,
+        rxBytesPerSec: rxSpeed,
+        txBytesPerSec: txSpeed,
+        rxTotalBytes: curr.rx,
+        txTotalBytes: curr.tx,
+      });
+    }
+    return results;
+  }
+
+  buildProcessCommand(limit: number = 20): string {
+    return `powershell -NoProfile -Command "Get-Process | Sort-Object CPU -Descending | Select-Object -First ${limit} | ForEach-Object { $cpuPct = if ($_.CPU -ne $null) { [math]::Round($_.CPU, 1) } else { 0 }; $memPct = 0; $name = $_.ProcessName; Write-Output '$($_.Id)|$($_.UserName ?? '')|$cpuPct|$memPct|$($_.WorkingSet64)|$name|$($_.StartTime)' }" 2>$null`;
+  }
+
+  parseProcessOutput(output: string): ProcessInfo[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const processes: ProcessInfo[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split('|');
+      if (parts.length >= 6) {
+        processes.push({
+          pid: parseInt(parts[0]) || 0,
+          user: parts[1] || undefined,
+          cpuPercent: parseFloat(parts[2]) || 0,
+          memPercent: parseFloat(parts[3]) || 0,
+          memBytes: parseInt(parts[4]) || 0,
+          name: parts[5],
+        });
+      }
+    }
+    return processes;
+  }
+
+  buildDockerCommand(): string {
+    return `docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.State}}" 2>$null`;
+  }
+
+  parseDockerOutput(output: string): DockerContainer[] {
+    if (output.trim() === '' || output.includes('not found')) return [];
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const containers: DockerContainer[] = [];
+    for (const line of lines) {
+      const parts = line.split('|');
+      if (parts.length >= 5) {
+        containers.push({
+          id: parts[0],
+          name: parts[1],
+          image: parts[2],
+          status: parts[3],
+          state: (parts[4].toLowerCase().trim() as DockerContainer['state']) || 'unknown',
+        });
+      }
+    }
+    return containers;
+  }
+
+  buildPortsCommand(): string {
+    return `powershell -NoProfile -Command "Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue | ForEach-Object { Write-Output '$($_.LocalAddress)|$($_.LocalPort)|TCP|$($_.OwningProcess)' }; Get-NetUDPEndpoint -ErrorAction SilentlyContinue | ForEach-Object { Write-Output '$($_.LocalAddress)|$($_.LocalPort)|UDP|$($_.OwningProcess)' }" 2>$null`;
+  }
+
+  parsePortsOutput(output: string): ListeningPort[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const ports: ListeningPort[] = [];
+    const seen = new Set<string>();
+
+    for (const line of lines) {
+      const parts = line.trim().split('|');
+      if (parts.length >= 4) {
+        const addr = parts[0].replace(/^\[|\]$/g, '');
+        const port = parseInt(parts[1]);
+        const proto = parts[2].toLowerCase() as 'tcp' | 'udp';
+        const pid = parseInt(parts[3]);
+
+        const key = `${proto}:${port}:${addr}`;
+        if (seen.has(key) || !port) continue;
+        seen.add(key);
+
+        ports.push({
+          port,
+          protocol: proto,
+          address: addr || '0.0.0.0',
+          pid: pid || undefined,
+        });
+      }
+    }
+    return ports.sort((a, b) => a.port - b.port);
+  }
+
+  buildServicesCommand(): string {
+    return `powershell -NoProfile -Command "Get-Service | ForEach-Object { $state = switch ($_.Status) { 'Running' { 'running' } 'Stopped' { 'stopped' } default { 'unknown' } }; $startType = switch ($_.StartType) { 'Automatic' { 'auto' } 'Manual' { 'manual' } 'Disabled' { 'disabled' } default { 'manual' } }; Write-Output '$($_.Name)|$state|$($_.DisplayName)|$startType' }" 2>$null`;
+  }
+
+  parseServicesOutput(output: string): SystemService[] {
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    const services: SystemService[] = [];
+    for (const line of lines) {
+      const parts = line.trim().split('|');
+      if (parts.length >= 4) {
+        services.push({
+          name: parts[0],
+          state: parts[1] as SystemService['state'],
+          description: parts[2],
+          startupType: parts[3] as SystemService['startupType'],
+        });
+      }
+    }
+    return services.slice(0, 50);
+  }
+}
+
+/**
+ * Get the appropriate monitor adapter based on OS type.
+ */
+export function getMonitorAdapter(osType: 'linux' | 'windows' | 'macos' | string): SystemMonitorAdapter {
+  switch (osType) {
+    case 'windows':
+      return new WindowsMonitorAdapter();
+    case 'linux':
+    case 'macos':
+    default:
+      return new LinuxMonitorAdapter();
+  }
+}