[Init] Initial commit - NetMesh terminal manager

application/state/useServerStats.ts

@@ -0,0 +1,415 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+export interface DiskInfo {
+  capacityKey?: string;       // Filesystem or shared-pool identity for deduplication
+  filesystemType?: string;    // Filesystem type reported by df (for network/FUSE filtering)
+  mountPoint: string;
+  used: number;               // Used in GB
+  total: number;              // Total in GB
+  percent: number;            // Usage percentage
+}
+
+export interface NetInterfaceInfo {
+  name: string;               // Interface name (e.g., eth0, ens33)
+  rxBytes: number;            // Total received bytes
+  txBytes: number;            // Total transmitted bytes
+  rxSpeed: number;            // Receive speed (bytes/sec)
+  txSpeed: number;            // Transmit speed (bytes/sec)
+}
+
+export interface ProcessInfo {
+  pid: string;
+  memPercent: number;
+  command: string;
+}
+
+export interface ServerStats {
+  hostname?: string;            // Remote hostname
+  osName?: string;              // Remote operating system name
+  kernelRelease?: string;       // Remote kernel release
+  uptimeSeconds?: number | null;// Remote uptime in seconds
+  loadAverage?: number[];       // 1/5/15 minute load average
+  cpu: number | null;           // CPU usage percentage (0-100)
+  cpuCores: number | null;      // Number of CPU cores
+  cpuPerCore: number[];         // Per-core CPU usage array
+  memTotal: number | null;      // Total memory in MB
+  memUsed: number | null;       // Used memory in MB (excluding buffers/cache)
+  memFree: number | null;       // Free memory in MB
+  memBuffers: number | null;    // Buffers in MB
+  memCached: number | null;     // Cached in MB
+  swapTotal: number | null;     // Total swap in MB
+  swapUsed: number | null;      // Used swap in MB
+  topProcesses: ProcessInfo[];  // Top 10 processes by memory
+  diskPercent: number | null;   // Disk usage percentage for root partition
+  diskUsed: number | null;      // Disk used in GB
+  diskTotal: number | null;     // Total disk in GB
+  disks: DiskInfo[];            // All mounted disks
+  netRxSpeed: number;           // Total network receive speed (bytes/sec)
+  netTxSpeed: number;           // Total network transmit speed (bytes/sec)
+  latencyMs: number | null;     // TCP connection establishment latency to the SSH endpoint
+  netInterfaces: NetInterfaceInfo[];  // Per-interface network stats
+  lastUpdated: number | null;   // Timestamp of last successful update
+}
+
+interface UseServerStatsOptions {
+  sessionId: string;
+  enabled: boolean;           // Whether stats collection is enabled (from settings)
+  refreshInterval: number;    // Refresh interval in seconds
+  isSupportedOs: boolean;     // Only collect stats for Linux/macOS servers
+  isConnected: boolean;       // Only collect when connected
+}
+
+interface ServerStatsState {
+  stats: ServerStats;
+  isLoading: boolean;
+  error: string | null;
+}
+
+interface ServerStatsClient {
+  enabled: boolean;
+  refreshInterval: number;
+  isSupportedOs: boolean;
+  isConnected: boolean;
+}
+
+type ServerStatsListener = (state: ServerStatsState) => void;
+
+interface SharedServerStatsSession {
+  sessionId: string;
+  state: ServerStatsState;
+  listeners: Set<ServerStatsListener>;
+  clients: Map<number, ServerStatsClient>;
+  intervalRef: ReturnType<typeof setInterval> | null;
+  initialTimerRef: ReturnType<typeof setTimeout> | null;
+  connectedAt: number;
+  hasFetched: boolean;
+  fetchGeneration: number;
+  consecutiveFailures: number;
+  givenUp: boolean;
+  pollIntervalMs: number | null;
+  pollingActive: boolean;
+  inflight: Promise<void> | null;
+  inflightGeneration: number | null;
+}
+
+const CONSECUTIVE_FAILURE_LIMIT = 3;
+const serverStatsSessions = new Map<string, SharedServerStatsSession>();
+let nextClientId = 1;
+
+function createEmptyServerStats(): ServerStats {
+  return {
+    hostname: undefined,
+    osName: undefined,
+    kernelRelease: undefined,
+    uptimeSeconds: null,
+    loadAverage: [],
+    cpu: null,
+    cpuCores: null,
+    cpuPerCore: [],
+    memTotal: null,
+    memUsed: null,
+    memFree: null,
+    memBuffers: null,
+    memCached: null,
+    swapTotal: null,
+    swapUsed: null,
+    topProcesses: [],
+    diskPercent: null,
+    diskUsed: null,
+    diskTotal: null,
+    disks: [],
+    netRxSpeed: 0,
+    netTxSpeed: 0,
+    latencyMs: null,
+    netInterfaces: [],
+    lastUpdated: null,
+  };
+}
+
+function createInitialState(): ServerStatsState {
+  return {
+    stats: createEmptyServerStats(),
+    isLoading: false,
+    error: null,
+  };
+}
+
+function getSharedServerStatsSession(sessionId: string): SharedServerStatsSession {
+  const existing = serverStatsSessions.get(sessionId);
+  if (existing) return existing;
+
+  const session: SharedServerStatsSession = {
+    sessionId,
+    state: createInitialState(),
+    listeners: new Set(),
+    clients: new Map(),
+    intervalRef: null,
+    initialTimerRef: null,
+    connectedAt: 0,
+    hasFetched: false,
+    fetchGeneration: 0,
+    consecutiveFailures: 0,
+    givenUp: false,
+    pollIntervalMs: null,
+    pollingActive: false,
+    inflight: null,
+    inflightGeneration: null,
+  };
+  serverStatsSessions.set(sessionId, session);
+  return session;
+}
+
+function emitServerStatsState(session: SharedServerStatsSession): void {
+  for (const listener of session.listeners) {
+    listener(session.state);
+  }
+}
+
+function updateServerStatsState(session: SharedServerStatsSession, patch: Partial<ServerStatsState>): void {
+  session.state = { ...session.state, ...patch };
+  emitServerStatsState(session);
+}
+
+function clearServerStatsTimers(session: SharedServerStatsSession): void {
+  if (session.initialTimerRef) {
+    clearTimeout(session.initialTimerRef);
+    session.initialTimerRef = null;
+  }
+  if (session.intervalRef) {
+    clearInterval(session.intervalRef);
+    session.intervalRef = null;
+  }
+  session.pollingActive = false;
+  session.pollIntervalMs = null;
+}
+
+function getActiveServerStatsClients(session: SharedServerStatsSession): ServerStatsClient[] {
+  return Array.from(session.clients.values()).filter((client) => (
+    client.enabled && client.isSupportedOs && client.isConnected
+  ));
+}
+
+function normalizeServerStats(stats: Partial<ServerStats>): ServerStats {
+  return {
+    hostname: stats.hostname,
+    osName: stats.osName,
+    kernelRelease: stats.kernelRelease,
+    uptimeSeconds: Number.isFinite(stats.uptimeSeconds) ? Number(stats.uptimeSeconds) : null,
+    loadAverage: Array.isArray(stats.loadAverage) ? stats.loadAverage : [],
+    cpu: stats.cpu ?? null,
+    cpuCores: stats.cpuCores ?? null,
+    cpuPerCore: stats.cpuPerCore || [],
+    memTotal: stats.memTotal ?? null,
+    memUsed: stats.memUsed ?? null,
+    memFree: stats.memFree ?? null,
+    memBuffers: stats.memBuffers ?? null,
+    memCached: stats.memCached ?? null,
+    swapTotal: stats.swapTotal ?? null,
+    swapUsed: stats.swapUsed ?? null,
+    topProcesses: stats.topProcesses || [],
+    diskPercent: stats.diskPercent ?? null,
+    diskUsed: stats.diskUsed ?? null,
+    diskTotal: stats.diskTotal ?? null,
+    disks: stats.disks || [],
+    netRxSpeed: stats.netRxSpeed || 0,
+    netTxSpeed: stats.netTxSpeed || 0,
+    latencyMs: Number.isFinite(stats.latencyMs) ? Number(stats.latencyMs) : null,
+    netInterfaces: stats.netInterfaces || [],
+    lastUpdated: Date.now(),
+  };
+}
+
+function markServerStatsFailure(session: SharedServerStatsSession, message: string): void {
+  session.consecutiveFailures += 1;
+  updateServerStatsState(session, { error: message });
+  if (session.consecutiveFailures >= CONSECUTIVE_FAILURE_LIMIT) {
+    // Stop polling this session. This covers network devices that advertise
+    // OpenSSH but do not support the POSIX stats shell command.
+    session.givenUp = true;
+    clearServerStatsTimers(session);
+  }
+}
+
+async function fetchSharedServerStats(session: SharedServerStatsSession, force = false): Promise<void> {
+  if (!session.sessionId) return;
+  if (session.inflight && session.inflightGeneration === session.fetchGeneration) {
+    await session.inflight;
+    return;
+  }
+  if (session.givenUp && !force) return;
+  if (getActiveServerStatsClients(session).length === 0) return;
+
+  const bridge = netcattyBridge.get();
+  if (!bridge?.getServerStats) return;
+
+  if (force) {
+    session.givenUp = false;
+    session.consecutiveFailures = 0;
+  }
+
+  const generation = session.fetchGeneration;
+  session.inflightGeneration = generation;
+  updateServerStatsState(session, { isLoading: true, error: null });
+
+  const request = (async () => {
+    try {
+      const result = await bridge.getServerStats(session.sessionId);
+
+      // Discard stale responses from before a polling restart or reconnect.
+      if (generation !== session.fetchGeneration) return;
+
+      if (result.pending) {
+        // Transient "not ready yet", e.g. a Mosh session whose SSH handshake
+        // has not finished. Do not count this toward the hard-failure cutoff.
+        return;
+      }
+
+      if (result.success && result.stats) {
+        session.hasFetched = true;
+        session.consecutiveFailures = 0;
+        updateServerStatsState(session, {
+          stats: normalizeServerStats(result.stats),
+          error: null,
+        });
+      } else if (result.error) {
+        markServerStatsFailure(session, result.error);
+      } else {
+        markServerStatsFailure(session, 'No stats returned');
+      }
+    } catch (err) {
+      if (generation === session.fetchGeneration) {
+        markServerStatsFailure(session, err instanceof Error ? err.message : 'Unknown error');
+      }
+    } finally {
+      if (generation === session.fetchGeneration) {
+        updateServerStatsState(session, { isLoading: false });
+      }
+    }
+  })();
+
+  session.inflight = request;
+  try {
+    await request;
+  } finally {
+    if (session.inflight === request) {
+      session.inflight = null;
+      session.inflightGeneration = null;
+    }
+  }
+}
+
+function reconcileSharedServerStatsSession(session: SharedServerStatsSession): void {
+  const activeClients = getActiveServerStatsClients(session);
+
+  if (activeClients.length === 0) {
+    // Pause polling only. Keep the last successful stats so remounting Overview
+    // (or re-enabling a terminal stats strip) can paint immediately instead of
+    // flashing "No system overview data yet." Still clear give-up / failure so a
+    // later resume can auto-retry (old reset wiped stats + flags together).
+    clearServerStatsTimers(session);
+    session.givenUp = false;
+    session.consecutiveFailures = 0;
+    if (session.state.isLoading) {
+      updateServerStatsState(session, { isLoading: false });
+    }
+    return;
+  }
+
+  if (session.connectedAt === 0) {
+    session.connectedAt = Date.now();
+  }
+
+  const intervalMs = Math.max(5, Math.min(...activeClients.map((client) => client.refreshInterval))) * 1000;
+  const shouldRestartPolling = !session.pollingActive || session.pollIntervalMs !== intervalMs;
+  if (!shouldRestartPolling) return;
+  if (session.givenUp) return;
+
+  clearServerStatsTimers(session);
+  session.fetchGeneration += 1;
+  session.pollingActive = true;
+  session.pollIntervalMs = intervalMs;
+
+  const connectionAge = Date.now() - session.connectedAt;
+  const needsWarmup = !session.hasFetched && connectionAge < 2000;
+
+  session.initialTimerRef = setTimeout(() => {
+    session.initialTimerRef = null;
+    void fetchSharedServerStats(session);
+  }, needsWarmup ? 2000 : 0);
+  session.intervalRef = setInterval(() => {
+    void fetchSharedServerStats(session);
+  }, intervalMs);
+}
+
+function maybeDisposeSharedServerStatsSession(session: SharedServerStatsSession): void {
+  if (session.clients.size > 0 || session.listeners.size > 0) return;
+  clearServerStatsTimers(session);
+  session.fetchGeneration += 1;
+  serverStatsSessions.delete(session.sessionId);
+}
+
+export function useServerStats({
+  sessionId,
+  enabled,
+  refreshInterval,
+  isSupportedOs,
+  isConnected,
+}: UseServerStatsOptions) {
+  const clientIdRef = useRef<number | null>(null);
+  if (clientIdRef.current === null) {
+    clientIdRef.current = nextClientId;
+    nextClientId += 1;
+  }
+
+  const [state, setState] = useState<ServerStatsState>(() => getSharedServerStatsSession(sessionId).state);
+
+  useEffect(() => {
+    const session = getSharedServerStatsSession(sessionId);
+    const clientId = clientIdRef.current;
+    if (clientId === null) return;
+
+    const listener: ServerStatsListener = (nextState) => {
+      setState(nextState);
+    };
+
+    session.listeners.add(listener);
+    setState(session.state);
+
+    return () => {
+      session.listeners.delete(listener);
+      session.clients.delete(clientId);
+      reconcileSharedServerStatsSession(session);
+      maybeDisposeSharedServerStatsSession(session);
+    };
+  }, [sessionId]);
+
+  useEffect(() => {
+    const session = getSharedServerStatsSession(sessionId);
+    const clientId = clientIdRef.current;
+    if (clientId === null) return;
+
+    session.clients.set(clientId, {
+      enabled,
+      refreshInterval,
+      isSupportedOs,
+      isConnected,
+    });
+    setState(session.state);
+    reconcileSharedServerStatsSession(session);
+  }, [sessionId, enabled, refreshInterval, isSupportedOs, isConnected]);
+
+  const refresh = useCallback(() => {
+    const session = getSharedServerStatsSession(sessionId);
+    void fetchSharedServerStats(session, true).finally(() => {
+      reconcileSharedServerStatsSession(session);
+    });
+  }, [sessionId]);
+
+  return {
+    stats: state.stats,
+    isLoading: state.isLoading,
+    error: state.error,
+    refresh,
+  };
+}