Skip to content

An open source, self-hosted, real-time port monitoring and discovery tool.

76.4 KB
Raw Blame
import React, { useEffect, useState, useCallback, useMemo, useRef } from "react";
import { TooltipProvider } from "@/components/ui/tooltip";
import {
  Dialog,
  DialogContent,
  DialogHeader,
  DialogFooter,
  DialogTitle,
  DialogDescription,
} from "@/components/ui/dialog";
import { Input } from "@/components/ui/input";
import { Button } from "@/components/ui/button";
import { AppHeader } from "./components/layout/AppHeader";
import { ServerSection } from "./components/server/ServerSection";
import { AppSidebarLayout } from "./components/layout/AppSidebarLayout";
import { Label } from "@/components/ui/label";
import { MultipleServerSkeleton } from "./components/server/MultipleServerSkeleton";
import { WhatsNewModal } from "./components/ui/WhatsNewModal";
import { ServiceRenameModal } from "./components/server/ServiceRenameModal";
import { BatchOperationsBar } from "./components/server/BatchOperationsBar";
import { BatchRenameModal } from "./components/server/BatchRenameModal";
import { BatchHideModal } from "./components/server/BatchHideModal";
import { BatchNotesModal } from "./components/server/BatchNotesModal";
import { SettingsModal } from "./components/settings/SettingsModal";
import { ApiKeyModal } from "./components/settings/ApiKeyModal";
import { LoginPage } from "./components/auth/LoginPage";
import { ChangePasswordPage } from "./components/auth/ChangePasswordPage";
import { BarChart3 } from "lucide-react";
import Logger from "./lib/logger";
import { useWhatsNew } from "./lib/hooks/useWhatsNew";
import { useReorderServers } from "./hooks/useReorderServers";
import { useKeyboardShortcuts } from "./lib/hooks/useKeyboardShortcuts";
import { useSidebarLayout } from "./lib/hooks/useSidebarLayout";
import { useKonamiHackerMode } from "./lib/hooks/useKonamiHackerMode";
import { saveCustomServiceName, deleteCustomServiceName, getCustomServiceNames, batchCustomServiceNames } from "./lib/api/customServiceNames";
import { batchNotes, saveNote } from "./lib/api/notes";
import { getAutoxposeStatus, connectAutoxpose, disconnectAutoxpose, setAutoxposeDisplayMode, setAutoxposeUrlStyle, getAutoxposeServices, getAutoxposeDomain } from "./lib/api/autoxpose";
import { AutoxposeNudge } from "./components/autoxpose";
import { generatePortKey } from "./lib/utils/portUtils";
import { formatUptime } from "@/lib/utils";
import { useAuth } from "./contexts/AuthContext";
import { buildAutoRefreshMessages } from "@/lib/autoRefreshMessages";
import { ServiceHealthProvider } from "@/hooks/useServiceHealth";
import { OverridesProvider } from "@/hooks/useOverrides";

const keyOf = (srvId, p) => generatePortKey(srvId, p);

const logger = new Logger('App');

export default function App() {
  const auth = useAuth();
  const { shouldShowButton: shouldShowWhatsNewButton, handleShow: handleShowWhatsNew, getModalProps: getWhatsNewModalProps } = useWhatsNew();
  const [groups, setGroups] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [hostOverride, setHostOverride] = useState(null);
  const [noteModalOpen, setNoteModalOpen] = useState(false);
  const [modalSrvId, setModalSrvId] = useState("");
  const [modalPort, setModalPort] = useState(null);
  const [draftNote, setDraftNote] = useState("");

  const [renameModalOpen, setRenameModalOpen] = useState(false);
  const [renameSrvId, setRenameSrvId] = useState("");
  const [renamePort, setRenamePort] = useState(null);

  const [batchRenameModalOpen, setBatchRenameModalOpen] = useState(false);
  const [batchHideModalOpen, setBatchHideModalOpen] = useState(false);
  const [batchNotesModalOpen, setBatchNotesModalOpen] = useState(false);
  const [settingsModalOpen, setSettingsModalOpen] = useState(false);
  const [apiKeyModalOpen, setApiKeyModalOpen] = useState(false);
  const [refreshInterval, setRefreshInterval] = useState(() => {
    try {
      const saved = localStorage.getItem("refreshInterval");
      return saved ? parseInt(saved, 10) : 30000;
    } catch {
      return 30000;
    }
  });
  const [includeUdp, setIncludeUdp] = useState(() => {
    try {
      return localStorage.getItem("includeUdp") === "true";
    } catch {
      return false;
    }
  });
  const [disableCache, setDisableCache] = useState(() => {
    try {
      return localStorage.getItem("disableCache") === "true";
    } catch {
      return false;
    }
  });
  const [batchLoading, setBatchLoading] = useState(false);
  const [renameLoading, setRenameLoading] = useState(false);
  const [healthToast, setHealthToast] = useState(null);
  const healthToastTimeoutRef = useRef(null);

  useEffect(() => () => {
    if (healthToastTimeoutRef.current) {
      clearTimeout(healthToastTimeoutRef.current);
    }
  }, []);

  const pushHealthToast = useCallback((payload) => {
    setHealthToast(payload);
    if (healthToastTimeoutRef.current) {
      clearTimeout(healthToastTimeoutRef.current);
    }
    healthToastTimeoutRef.current = setTimeout(() => setHealthToast(null), 4000);
  }, []);

  const { hackerMode, konamiHint, disableHackerMode } = useKonamiHackerMode({ pushHealthToast });

  const [actionFeedback, setActionFeedback] = useState({
    copy: null,
    edit: null,
    hide: null,
    unhide: null,
  });

  const [isDarkMode, setIsDarkMode] = useState(() => {
    if (localStorage.theme === "dark") {
      return true;
    }
    if (localStorage.theme === "light") {
      return false;
    }
    return window.matchMedia("(prefers-color-scheme: dark)").matches;
  });

  const [themePreference, setThemePreference] = useState(() => {
    const stored = localStorage.theme;
    if (stored === "dark" || stored === "light") return stored;
    return "system";
  });

  const handleThemeChange = useCallback((newTheme) => {
    setThemePreference(newTheme);
    if (newTheme === "system") {
      localStorage.removeItem("theme");
      setIsDarkMode(window.matchMedia("(prefers-color-scheme: dark)").matches);
    } else if (newTheme === "dark") {
      localStorage.theme = "dark";
      setIsDarkMode(true);
    } else {
      localStorage.theme = "light";
      setIsDarkMode(false);
    }
  }, []);

  const [servers, setServers] = useState([]);
  const [selectedServer, setSelectedServer] = useState(
    () => localStorage.getItem("selectedServerId") || null
  );

  const [searchTerm, setSearchTerm] = useState("");
  const [searchScope, setSearchScope] = useState(() => {
    try {
      const saved = localStorage.getItem("searchScope");
      if (saved === "all") return "all";
      return "server";
    } catch {
      return "server";
    }
  });
  const [searchHighlighting, setSearchHighlighting] = useState(() => {
    try {
      const saved = localStorage.getItem("searchHighlighting");
      return saved ? JSON.parse(saved) : true;
    } catch {
      return true;
    }
  });
  const [filters, setFilters] = useState(() => {
    try {
      const saved = localStorage.getItem("portFilters");
      return saved
        ? JSON.parse(saved)
        : {
            docker: true,
            system: false,
          };
    } catch {
      return {
        docker: true,
        system: false,
      };
    }
  });

  const [expandedServers, setExpandedServers] = useState(() => {
    try {
      const saved = localStorage.getItem("expandedServers");
      return saved ? JSON.parse(saved) : {};
    } catch {
      return {};
    }
  });

  const [openAccordions, setOpenAccordions] = useState(() => {
    try {
      const saved = localStorage.getItem("openAccordions");
      return saved ? JSON.parse(saved) : {};
    } catch {
      return {};
    }
  });

  const [infoCardLayout, setInfoCardLayout] = useState(() => {
    try {
      const saved = localStorage.getItem("infoCardLayout");
      return saved || "grid";
    } catch {
      return "grid";
    }
  });

  const [portLayout, setPortLayout] = useState(() => {
    try {
      const saved = localStorage.getItem("portLayout");
      return saved || "list";
    } catch {
      return "list";
    }
  });

  const [groupingMode, setGroupingMode] = useState(() => {
    try {
      const saved = localStorage.getItem("groupingMode");
      return saved === "ports" ? "ports" : "services";
    } catch {
      return "services";
    }
  });

  const [showIcons, setShowIcons] = useState(() => {
    try {
      const saved = localStorage.getItem("showIcons");
      return saved !== "false";
    } catch {
      return true;
    }
  });

  const [isSidebarOpen, setSidebarOpen] = useState(false);
  const [deepLinkContainer, setDeepLinkContainer] = useState(null);
  const [deepLinkServer, setDeepLinkServer] = useState(null);
  const [appliedDeepLink, setAppliedDeepLink] = useState(false);

  const [selectionMode, setSelectionMode] = useState(false);
  const [selectedPorts, setSelectedPorts] = useState(new Set());

  const [autoRefreshEnabled, setAutoRefreshEnabled] = useState(() => {
    try {
      const saved = localStorage.getItem("autoRefreshEnabled");
      return saved === "true";
    } catch {
      return false;
    }
  });
  const [portSuggestions, setPortSuggestions] = useState({});

  const [autoxposeStatus, setAutoxposeStatus] = useState({
    enabled: false,
    configured: false,
    connected: false,
    url: null
  });
  const [autoxposeDisplayMode, setAutoxposeDisplayModeState] = useState("url");
  const [autoxposeUrlStyle, setAutoxposeUrlStyleState] = useState("compact");
  const [autoxposePorts, setAutoxposePorts] = useState(null);

  useEffect(() => {
    if (auth.loading || (auth.authEnabled && !auth.authenticated)) {
      return undefined;
    }

    let active = true;
    getAutoxposeStatus()
      .then((status) => {
        if (!active) return;
        setAutoxposeStatus(status);
        if (status.displayMode) {
          setAutoxposeDisplayModeState(status.displayMode);
        }
        if (status.urlStyle) {
          setAutoxposeUrlStyleState(status.urlStyle);
        }
      })
      .catch(() => {});
    return () => {
      active = false;
    };
  }, [auth.loading, auth.authEnabled, auth.authenticated]);

  useEffect(() => {
    if (!autoxposeStatus.connected) {
      setAutoxposePorts(null);
      return;
    }
    const fetchServices = async () => {
      try {
        const [servicesData, domainData] = await Promise.all([
          getAutoxposeServices(),
          getAutoxposeDomain(),
        ]);
        const services = servicesData?.services || [];
        const domain = domainData?.domain;
        
        if (!domain || !services.length) {
          setAutoxposePorts(new Map());
          return;
        }
        
        const portsMap = new Map();
        services.forEach((svc) => {
          if (svc.port && svc.enabled && svc.exposedSubdomain) {
            const containerIdKey = svc.sourceId ? `${svc.sourceId.substring(0, 12)}:${svc.port}` : null;
            const hostname = `${svc.exposedSubdomain}.${domain}`;
            const url = `https://${hostname}`;
            
            let sslStatus = "none";
            if (svc.sslPending) {
              sslStatus = "pending";
            } else if (svc.sslError) {
              sslStatus = "error";
            } else if (svc.exposedSubdomain) {
              sslStatus = "active";
            }
            
            const data = { url, hostname, sslStatus };
            if (containerIdKey) {
              portsMap.set(containerIdKey, data);
            }
          }
        });
        setAutoxposePorts(portsMap);
      } catch (err) {
        logger.warn("Failed to fetch autoxpose services:", err);
        setAutoxposePorts(null);
      }
    };
    
    fetchServices();
  }, [autoxposeStatus.connected]);

  const handleAutoxposeConnect = useCallback(async (url) => {
    const result = await connectAutoxpose(url);
    if (result.success) {
      setAutoxposeStatus((prev) => ({ ...prev, connected: true, url }));
    }
    return result;
  }, []);

  const handleAutoxposeDisconnect = useCallback(async () => {
    await disconnectAutoxpose();
    setAutoxposeStatus((prev) => ({ ...prev, connected: false, url: null }));
  }, []);

  const handleAutoxposeDisplayModeChange = useCallback(async (mode) => {
    await setAutoxposeDisplayMode(mode);
    setAutoxposeDisplayModeState(mode);
  }, []);

  const handleAutoxposeUrlStyleChange = useCallback(async (style) => {
    await setAutoxposeUrlStyle(style);
    setAutoxposeUrlStyleState(style);
  }, []);

  useEffect(() => {
    if (isDarkMode) {
      document.documentElement.classList.add("dark");
      localStorage.theme = "dark";
    } else {
      document.documentElement.classList.remove("dark");
      localStorage.theme = "light";
    }
  }, [isDarkMode]);

  useEffect(() => {
    try {
      localStorage.setItem("portFilters", JSON.stringify(filters));
    } catch (error) {
      logger.warn("Failed to save filter settings:", error);
    }
  }, [filters]);

  useEffect(() => {
    try {
      localStorage.setItem("expandedServers", JSON.stringify(expandedServers));
    } catch (error) {
      logger.warn("Failed to save expanded servers state:", error);
    }
  }, [expandedServers]);

  useEffect(() => {
    try {
      localStorage.setItem("openAccordions", JSON.stringify(openAccordions));
    } catch (error) {
      logger.warn("Failed to save open accordions state:", error);
    }
  }, [openAccordions]);

  useEffect(() => {
    try {
      localStorage.setItem("infoCardLayout", infoCardLayout);
    } catch (error) {
      logger.warn("Failed to save info card layout setting:", error);
    }
  }, [infoCardLayout]);

  useEffect(() => {
    try {
      localStorage.setItem("portLayout", portLayout);
    } catch (error) {
      logger.warn("Failed to save port layout setting:", error);
    }
  }, [portLayout]);

  useEffect(() => {
    try {
      localStorage.setItem("groupingMode", groupingMode);
    } catch (error) {
      logger.warn("Failed to save grouping mode setting:", error);
    }
  }, [groupingMode]);

  useEffect(() => {
    try {
      localStorage.setItem("showIcons", showIcons.toString());
    } catch (error) {
      logger.warn("Failed to save show icons setting:", error);
    }
  }, [showIcons]);

  useEffect(() => {
    if (selectedServer) {
      localStorage.setItem("selectedServerId", selectedServer);
    } else {
      localStorage.removeItem("selectedServerId");
    }
  }, [selectedServer]);

  useEffect(() => {
    try {
      localStorage.setItem(
        "searchHighlighting",
        JSON.stringify(searchHighlighting)
      );
    } catch (error) {
      logger.warn("Failed to save search highlighting setting:", error);
    }
  }, [searchHighlighting]);

  useEffect(() => {
    try {
      localStorage.setItem("searchScope", searchScope);
    } catch (error) {
      logger.warn("Failed to save search scope setting:", error);
    }
  }, [searchScope]);

  useEffect(() => {
    try {
      localStorage.setItem("autoRefreshEnabled", autoRefreshEnabled.toString());
    } catch (error) {
      logger.warn("Failed to save auto-refresh setting:", error);
    }
  }, [autoRefreshEnabled]);

  const generatePortForServer = useCallback(async (serverId) => {
    setPortSuggestions((prev) => ({
      ...prev,
      [serverId]: { ...(prev[serverId] || {}), loading: true, error: null },
    }));

    try {
      const response = await fetch(`/api/servers/${encodeURIComponent(serverId)}/generate-port`, {
        method: "POST",
      });

      if (!response.ok) {
        const text = await response.text().catch(() => "");
        throw new Error(text || `Failed to generate port (HTTP ${response.status})`);
      }

      const payload = await response.json();
      setPortSuggestions((prev) => ({
        ...prev,
        [serverId]: {
          port: payload.port,
          meta: payload.meta || null,
          generatedAt: Date.now(),
          loading: false,
          error: null,
        },
      }));
    } catch (error) {
      logger.error("Failed to generate unused port:", error);
      setPortSuggestions((prev) => ({
        ...prev,
        [serverId]: {
          ...(prev[serverId] || {}),
          loading: false,
          error: error.message || "Failed to generate port",
        },
      }));
    }
  }, []);

  const handleSelectServer = useCallback((serverId) => {
    setSelectedServer(serverId);
    if (window.innerWidth < 768) {
      setSidebarOpen(false);
    }
  }, []);

  const toggleServerExpanded = useCallback((serverId) => {
    setExpandedServers((prev) => ({
      ...prev,
      [serverId]: !prev[serverId],
    }));
  }, []);

  const handleAccordionChange = useCallback((serverId, openItems) => {
    setOpenAccordions((prev) => ({
      ...prev,
      [serverId]: openItems,
    }));
  }, []);

  const transformCollectorData = useCallback(
    async (collectorData, serverId, serverUrl = null) => {
      if (!collectorData.ports || !Array.isArray(collectorData.ports)) {
        logger.warn(
          `transformCollectorData: No ports array in collectorData for serverId ${serverId}`,
          collectorData
        );
        return [];
      }

      const transformedPorts = collectorData.ports
        .filter((port) => {
          if (
            port.host_ip &&
            (port.host_ip.includes("::") || port.host_ip === "[::]")
          ) {
            return false;
          }
          if (!port.host_port || port.host_port <= 0) return false;
          return true;
        })
        .map((port) => ({
          source: port.source || null,
          owner: port.owner || null,
          protocol: port.protocol || null,
          host_ip: port.host_ip || null,
          host_port: port.host_port || null,
          target: port.target || null,
          container_id: port.container_id || null,
          vm_id: port.vm_id || null,
          app_id: port.app_id || null,
          note: port.note || null,
          ignored: !!port.ignored,
          created: port.created || null,
          internal: port.internal || false,
          compose_project: port.compose_project || null,
          compose_service: port.compose_service || null,
          autoxpose: port.autoxpose || null,
        }));

      const uniquePorts = [];
      const seenKeys = new Set();

      transformedPorts.forEach((port) => {
        const key = generatePortKey(serverId, port);
        if (!seenKeys.has(key)) {
          seenKeys.add(key);
          uniquePorts.push(port);
        } else {
          logger.debug(`DUPLICATE DETECTED - Filtering out port with key: ${key}`, port);
        }
      });

      let customServiceNames = [];
      try {
        customServiceNames = await getCustomServiceNames(serverId, serverUrl);
        logger.debug(`Loaded ${customServiceNames.length} custom service names for ${serverId}`);
      } catch (error) {
        logger.warn(`Failed to load custom service names for ${serverId}:`, error);
      }

      const customNameMap = new Map();
      customServiceNames.forEach(item => {
        const key = `${item.host_ip}:${item.host_port}:${item.container_id || ''}:${item.internal || 0}`;
        customNameMap.set(key, {
          customServiceName: item.custom_name,
          originalServiceName: item.original_name
        });
      });

      const groupMap = new Map();

      uniquePorts.forEach((port) => {
        let customNameData = null;
        
        const customNameKey = `${port.host_ip}:${port.host_port}:${port.container_id || ''}:${port.internal || false ? 1 : 0}`;
        customNameData = customNameMap.get(customNameKey);
        
        if (!customNameData) {
          const fallbackKeys = [
            `0.0.0.0:${port.host_port}:${port.container_id || ''}:${port.internal || false ? 1 : 0}`,
            `[::]:${port.host_port}:${port.container_id || ''}:${port.internal || false ? 1 : 0}`,
            `host.docker.internal:${port.host_port}:${port.container_id || ''}:${port.internal || false ? 1 : 0}`
          ];
          
          for (const key of fallbackKeys) {
            customNameData = customNameMap.get(key);
            if (customNameData) {
              break;
            }
          }
        }
        
        if (customNameData) {
          port.customServiceName = customNameData.customServiceName;
          port.originalServiceName = customNameData.originalServiceName;
        }

        if (port.source === "docker") {
          const groupKey = `${port.container_id || port.app_id || port.owner}${port.internal ? '-internal' : ''}`;
          if (!groupMap.has(groupKey)) {
            groupMap.set(groupKey, []);
          }
          groupMap.get(groupKey).push(port);
        } else {
          const uniqueKey = `${port.source}-${port.host_ip}-${port.host_port}-${
            port.owner
          }-${port.pid || Math.random()}`;
          groupMap.set(uniqueKey, [port]);
        }
      });

      const portsWithGroupInfo = [];

      groupMap.forEach((portsInGroup) => {
        portsInGroup.sort((a, b) => a.host_port - b.host_port);

        portsInGroup.forEach((port) => {
          portsWithGroupInfo.push(port);
        });
      });

      logger.debug(
        `Final result: Transformed ${collectorData.ports.length} raw ports into ${portsWithGroupInfo.length} unique valid ports with grouping`
      );
      return portsWithGroupInfo;
    },
    []
  );

  const whatsNewModalProps = getWhatsNewModalProps();

  const sidebarLayout = useSidebarLayout({
    pushHealthToast,
    isWhatsNewOpen: whatsNewModalProps.isOpen,
    loading,
    groupCount: groups.length,
    logger,
  });
  const { stampRefreshed, onOpenAddServer: handleOpenAddServer } = sidebarLayout;

  const fetchAll = useCallback(async () => {
    setLoading(true);
    setError(null);
    setPortSuggestions({});

    const scanParams = new URLSearchParams();
    if (includeUdp) scanParams.set('includeUdp', 'true');
    if (disableCache) scanParams.set('disableCache', 'true');
    const scanQueryString = scanParams.toString();

    try {
      const serversResponse = await fetch("/api/servers");
      if (!serversResponse.ok) {
        throw new Error(`Failed to fetch servers: ${serversResponse.status}`);
      }
      const currentServers = await serversResponse.json();

      const enrichedServers = await Promise.all(
        currentServers.map(async (server) => {
          if (server.id === "local") {
            try {
              const scanUrl = `/api/servers/${server.id}/scan${scanQueryString ? `?${scanQueryString}` : ''}`;
              const scanResponse = await fetch(scanUrl);
              if (scanResponse.ok) {
                const scanData = await scanResponse.json();
                const transformedPorts = await transformCollectorData(
                  scanData,
                  server.id,
                  null
                );
                return {
                  id: server.id,
                  server: server.label,
                  ok: true,
                  platform: scanData.platform,
                  platformName: scanData.platformName,
                  data: transformedPorts,
                  systemInfo: scanData.systemInfo,
                  vms: scanData.vms,
                  parentId: server.parentId,
                  platform_type: server.platform_type || scanData.platform,
                  enhancedFeaturesEnabled: scanData.enhancedFeaturesEnabled ?? true,
                };
              } else {
                const errorData = await scanResponse
                  .json()
                  .catch(() => ({
                    error: `Local scan failed with status ${scanResponse.status}`,
                  }));
                logger.warn(
                  `Local scan API for ${server.id} failed:`,
                  errorData.error
                );
                return {
                  id: server.id,
                  server: server.label,
                  ok: false,
                  error: errorData.error || "Local server data unavailable",
                  data: [],
                  parentId: server.parentId,
                  platform_type: server.platform_type || "unknown",
                };
              }
            } catch (error) {
              logger.error("Error scanning local server:", error);
              return {
                id: server.id,
                server: server.label,
                ok: false,
                error: error.message,
                data: [],
                parentId: server.parentId,
                platform_type: server.platform_type || "unknown",
              };
            }
          }

          if (server.type === "peer" && server.url) {
            try {
              const scanUrl = `/api/servers/${server.id}/scan${scanQueryString ? `?${scanQueryString}` : ''}`;
              const scanResponse = await fetch(scanUrl);
              if (scanResponse.ok) {
                const scanData = await scanResponse.json();
                const transformedPorts = await transformCollectorData(
                  scanData,
                  server.id,
                  server.url
                );
                return {
                  id: server.id,
                  server: server.label,
                  ok: true,
                  url: server.url,
                  platform: scanData.platform,
                  platformName: scanData.platformName,
                  data: transformedPorts,
                  systemInfo: scanData.systemInfo,
                  vms: scanData.vms,
                  parentId: server.parentId,
                  platform_type: server.platform_type || scanData.platform,
                  enhancedFeaturesEnabled: scanData.enhancedFeaturesEnabled ?? true,
                };
              } else {
                const errorData = await scanResponse.json().catch(() => ({
                  error: `Failed to scan peer '${server.label}' via backend. Status: ${scanResponse.status}`,
                }));
                logger.warn(
                  `Failed to scan peer ${server.id} (${server.label}):`,
                  errorData.details || errorData.error
                );
                return {
                  id: server.id,
                  server: server.label,
                  ok: false,
                  error:
                    errorData.details ||
                    errorData.error ||
                    `Scan failed (status ${scanResponse.status})`,
                  data: [],
                  parentId: server.parentId,
                  platform_type: server.platform_type || "unknown",
                };
              }
            } catch (error) {
              logger.error(
                `Error fetching scan for peer ${server.id} (${server.label}):`,
                error
              );
              return {
                id: server.id,
                server: server.label,
                ok: false,
                error: `Network error fetching scan: ${error.message}`,
                data: [],
                parentId: server.parentId,
                platform_type: server.platform_type || "unknown",
              };
            }
          }

          return {
            id: server.id,
            server: server.label,
            ok: false,
            error: "Server type not scannable or misconfigured",
            data: [],
            parentId: server.parentId,
            platform_type: server.platform_type || "unknown",
          };
        })
      );

      setGroups(enrichedServers);
      stampRefreshed(enrichedServers);
      setTimeout(() => setLoading(false), 300);
    } catch (error) {
      logger.error("Error in fetchAll:", error);

      try {
        logger.warn(
          "Primary fetch failed, attempting complete fallback to legacy API"
        );
        const fallbackResponse = await fetch("/api/all-ports");
        if (fallbackResponse.ok) {
          const legacyData = await fallbackResponse.json();
          setGroups(legacyData);
          stampRefreshed(legacyData);
          setTimeout(() => setLoading(false), 300);
          return;
        }
      } catch (fallbackError) {
        logger.error("Even fallback API failed:", fallbackError);
      }

      setError(error.toString());
      setLoading(false);
    }
  }, [transformCollectorData, includeUdp, disableCache, stampRefreshed]);

  const handleLogoClick = useCallback(() => {
    fetchAll();
    if (window.innerWidth < 768) {
      setSidebarOpen(false);
    }
  }, [fetchAll]);

  

  useEffect(() => {
    if (auth.loading || (auth.authEnabled && !auth.authenticated)) {
      return;
    }
    fetchAll();
  }, [fetchAll, auth.loading, auth.authEnabled, auth.authenticated]);

  useEffect(() => {
    fetch("/api/config")
      .then(res => res.ok ? res.json() : null)
      .then(data => { if (data?.hostOverride) setHostOverride(data.hostOverride); })
      .catch(() => {});
  }, []);

  useEffect(() => {
    try {
      const params = new URLSearchParams(window.location.search);
      const c = params.get('container');
      const s = params.get('server');
      if (c) setDeepLinkContainer(c);
      if (s) setDeepLinkServer(s);
  } catch { void 0; }
  }, []);

  useEffect(() => {
    if (auth.authenticated && !auth.loading && groups.length === 0) {
      fetchAll();
    }
  }, [auth.authenticated, auth.loading, fetchAll, groups.length]);

  useEffect(() => {
    if (!autoRefreshEnabled || auth.loading || (auth.authEnabled && !auth.authenticated)) {
      return;
    }

    const intervalId = setInterval(() => {
      logger.debug('Auto-refresh triggered');
      fetchAll();
    }, refreshInterval);

    return () => clearInterval(intervalId);
  }, [autoRefreshEnabled, fetchAll, auth.loading, auth.authEnabled, auth.authenticated, refreshInterval]);

  useEffect(() => {
    if (!loading && groups.length > 0) {
      const selectionIsValid =
        selectedServer && groups.some((g) => g.id === selectedServer);
      if (!selectionIsValid) {
        setSelectedServer(groups[0].id);
      }
      if (!appliedDeepLink && deepLinkServer && groups.some(g => g.id === deepLinkServer)) {
        setSelectedServer(deepLinkServer);
      }
    } else if (!loading && groups.length === 0 && selectedServer) {
      setSelectedServer(null);
    }
  }, [groups, loading, selectedServer, deepLinkServer, appliedDeepLink]);

  useEffect(() => {
    if (!appliedDeepLink && deepLinkServer && selectedServer === deepLinkServer) {
      setAppliedDeepLink(true);
    }
  }, [appliedDeepLink, deepLinkServer, selectedServer]);

  useEffect(() => {
    try {
      const url = new URL(window.location.href);
      if (selectedServer) url.searchParams.set('server', selectedServer); else url.searchParams.delete('server');
      if (deepLinkContainer) url.searchParams.set('container', deepLinkContainer);
      window.history.replaceState({}, '', url.toString());
  } catch { void 0; }
  }, [selectedServer, deepLinkContainer]);

  const searchInputRef = useRef(null);

  useKeyboardShortcuts({
    onFocusSearch: () => searchInputRef.current?.focus(),
    onClearSearch: () => { setSearchTerm(""); },
    onToggleSidebar: sidebarLayout.onCollapseToggle,
    onSelectServerByIndex: (index) => {
      if (groups[index]) handleSelectServer(groups[index].id);
    },
    onRefresh: fetchAll,
  });

  const handleContainerOpen = useCallback((serverId, containerId) => {
    setDeepLinkContainer(containerId);
    try {
      const url = new URL(window.location.href);
      url.searchParams.set('container', containerId);
      url.searchParams.set('server', serverId);
      window.history.replaceState({}, '', url.toString());
  } catch { void 0; }
  }, []);

  const handleContainerClose = useCallback(() => {
    setDeepLinkContainer(null);
    try {
      const url = new URL(window.location.href);
      url.searchParams.delete('container');
      window.history.replaceState({}, '', url.toString());
  } catch { void 0; }
  }, []);

  const toggleIgnore = useCallback(
    (srvId, p) => {
      
      const newIgnoredState = !p.ignored;
      const portKey = generatePortKey(srvId, p);
      const actionType = newIgnoredState ? 'hide' : 'unhide';
      
      if (actionFeedback[actionType]?.id === portKey) {
        return;
      }
      
      setActionFeedback(prev => ({ 
        ...prev, 
        [actionType]: { id: portKey, status: 'loading' } 
      }));

      setGroups((currentGroups) =>
        currentGroups.map((group) => {
          if (group.id === srvId) {
            const updatedData = group.data.map((port) => {
              if (
                port.host_ip === p.host_ip &&
                port.host_port === p.host_port &&
                (port.container_id || null) === (p.container_id || null) &&
                (port.internal || false) === (p.internal || false)
              ) {
                return { ...port, ignored: newIgnoredState };
              }
              return port;
            });
            return { ...group, data: updatedData };
          }
          return group;
        })
      );

      let targetUrl = "/api/ignores";
      let isPeer = false;

      if (srvId !== "local") {
        const server = servers.find((s) => s.id === srvId);
        if (server && server.url) {
          targetUrl = `${server.url.replace(/\/+$/, "")}/api/ignores`;
          isPeer = true;
        }
      }

      fetch(targetUrl, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          server_id: isPeer ? "local" : srvId,
          host_ip: p.host_ip,
          host_port: p.host_port,
          protocol: p.protocol,
          container_id: p.container_id || null,
          internal: p.internal || false,
          ignored: newIgnoredState,
        }),
      })
        .then((response) => {
          if (!response.ok)
            throw new Error("Failed to update ignore status on backend.");
          
          setActionFeedback(prev => ({ 
            ...prev, 
            [actionType]: { id: portKey, status: 'success' } 
          }));
          
          setTimeout(() => setActionFeedback(prev => ({ 
            ...prev, 
            [actionType]: null 
          })), 2000);
        })
        .catch((error) => {
          logger.error("Error toggling ignore:", error);
          
          setActionFeedback(prev => ({ 
            ...prev, 
            [actionType]: { id: portKey, status: 'error' } 
          }));
          
          setTimeout(() => setActionFeedback(prev => ({ 
            ...prev, 
            [actionType]: null 
          })), 3000);
          
          setGroups((currentGroups) =>
            currentGroups.map((group) => {
              if (group.id === srvId) {
                const revertedData = group.data.map((port) => {
                  if (
                    port.host_ip === p.host_ip &&
                    port.host_port === p.host_port &&
                    (port.container_id || null) === (p.container_id || null) &&
                    (port.internal || false) === (p.internal || false)
                  ) {
                    return { ...port, ignored: p.ignored };
                  }
                  return port;
                });
                return { ...group, data: revertedData };
              }
              return group;
            })
          );
        });
    },
    [servers, actionFeedback, setGroups, setActionFeedback]
  );

  const openNoteModal = useCallback((srvId, p) => {
    setModalSrvId(srvId);
    setModalPort(p);
    setDraftNote(p.note || "");
    setNoteModalOpen(true);
  }, []);

  const openRenameModal = useCallback((srvId, p) => {
    setRenameSrvId(srvId);
    setRenamePort(p);
    setRenameModalOpen(true);
  }, []);

  const saveNoteModal = useCallback(() => {
    if (!modalPort) return;
    const originalNote = modalPort.note || "";

    setGroups((currentGroups) =>
      currentGroups.map((group) => {
        if (group.id === modalSrvId) {
          const updatedData = group.data.map((port) => {
            if (
              port.host_ip === modalPort.host_ip &&
              port.host_port === modalPort.host_port &&
              (port.container_id || null) === (modalPort.container_id || null) &&
              (port.internal || false) === (modalPort.internal || false)
            ) {
              return { ...port, note: draftNote };
            }
            return port;
          });
          return { ...group, data: updatedData };
        }
        return group;
      })
    );
    setNoteModalOpen(false);

    const currentServerIdForNote = modalSrvId;
    const serverForNote = servers.find((s) => s.id === currentServerIdForNote);
    const serverUrl = currentServerIdForNote !== "local" && serverForNote ? serverForNote.url : null;

    saveNote(currentServerIdForNote, modalPort.host_ip, modalPort.host_port, modalPort.protocol, draftNote, serverUrl, modalPort.container_id, modalPort.internal)
      .catch((error) => {
        logger.error("Error saving note:", error);
        setGroups((currentGroups) =>
          currentGroups.map((group) => {
            if (group.id === modalSrvId) {
              const revertedData = group.data.map((port) => {
                if (
                  port.host_ip === modalPort.host_ip &&
                  port.host_port === modalPort.host_port &&
                  (port.container_id || null) === (modalPort.container_id || null) &&
                  (port.internal || false) === (modalPort.internal || false)
                ) {
                  return { ...port, note: originalNote };
                }
                return port;
              });
              return { ...group, data: revertedData };
            }
            return group;
          })
        );
      });
  }, [modalSrvId, modalPort, draftNote, servers]);

  const handleServiceRename = useCallback(async (renameData) => {
    const { serverId, hostIp, hostPort, customName, originalName, serverUrl, isReset, containerId, internal } = renameData;
    
    setRenameLoading(true);

    try {
      if (isReset || !customName) {
        try {
          await deleteCustomServiceName(serverId, hostIp, hostPort, renameData.protocol, serverUrl, containerId, internal || false);
        } catch (error) {
          if (!error.message.includes('not found')) {
            throw error;
          }
          logger.info('Custom service name already deleted or did not exist, proceeding with reset');
        }
        
        setGroups((currentGroups) =>
          currentGroups.map((group) => {
            if (group.id === serverId) {
              const updatedData = group.data.map((port) => {
                const matchesPort = port.host_ip === hostIp && port.host_port === hostPort;
                const matchesContainer = containerId ? port.container_id === containerId : !port.container_id;
                const matchesInternal = (port.internal || false) === (internal || false);
                
                if (matchesPort && matchesContainer && matchesInternal) {
                  return { 
                    ...port, 
                    customServiceName: null,
                    originalServiceName: null
                  };
                }
                return port;
              });
              return { ...group, data: updatedData };
            }
            return group;
          })
        );
      } else {
        await saveCustomServiceName(serverId, hostIp, hostPort, renameData.protocol, customName, originalName, serverUrl, containerId, internal || false);
        
        setGroups((currentGroups) =>
          currentGroups.map((group) => {
            if (group.id === serverId) {
              const updatedData = group.data.map((port) => {
                const matchesPort = port.host_ip === hostIp && port.host_port === hostPort;
                const matchesContainer = containerId ? port.container_id === containerId : !port.container_id;
                const matchesInternal = (port.internal || false) === (internal || false);
                
                if (matchesPort && matchesContainer && matchesInternal) {
                  return { 
                    ...port, 
                    customServiceName: customName,
                    originalServiceName: originalName || port.owner
                  };
                }
                return port;
              });
              return { ...group, data: updatedData };
            }
            return group;
          })
        );
      }

      setRenameModalOpen(false);
    } catch (error) {
      logger.error("Error updating service name:", error);
    } finally {
      setRenameLoading(false);
    }
  }, []);

  const clearSelection = useCallback(() => {
    setSelectedPorts(new Set());
    setSelectionMode(false);
  }, []);

  const handleBatchRenameSave = useCallback(async (data) => {
    const { customName, selectedPorts, isReset } = data;
    setBatchLoading(true);

    try {
      const portsByServer = new Map();
      
      selectedPorts.forEach(portKey => {
        const parts = portKey.split('-');
        if (parts.length < 3) return;
        
        const serverId = parts[0];
        const isInternal = parts[parts.length - 1] === 'internal';
        const containerIdIndex = isInternal ? parts.length - 2 : parts.length - 1;
        const hostPortIndex = isInternal ? parts.length - 3 : parts.length - 2;
        
        const containerId = parts[containerIdIndex];
        const hostPort = parts[hostPortIndex];
        const hostIp = parts.slice(1, hostPortIndex).join('-');
        
        if (!portsByServer.has(serverId)) {
          portsByServer.set(serverId, []);
        }
        
        const server = groups.find(g => g.id === serverId);
        const port = server?.data.find(p => 
          p.host_ip === hostIp && 
          p.host_port === parseInt(hostPort) && 
          (p.container_id || '') === (containerId || '') &&
          (p.internal || false) === isInternal
        );
        
        if (port) {
          portsByServer.get(serverId).push({
            action: isReset ? "delete" : "set",
            host_ip: hostIp,
            host_port: parseInt(hostPort),
            protocol: port.protocol,
            custom_name: isReset ? null : customName,
            original_name: port.originalServiceName || port.owner,
            container_id: containerId || null,
            internal: isInternal,
          });
          
          if (!port.internal) {
            const relatedPorts = server.data.filter(p => 
              p.host_port === parseInt(hostPort) && 
              p.owner === port.owner &&
              (p.container_id || '') === (containerId || '') &&
              p.host_ip !== hostIp &&
              !p.internal
            );
            
            relatedPorts.forEach(relatedPort => {
              portsByServer.get(serverId).push({
                action: isReset ? "delete" : "set",
                host_ip: relatedPort.host_ip,
                host_port: parseInt(hostPort),
                protocol: relatedPort.protocol,
                custom_name: isReset ? null : customName,
                original_name: relatedPort.originalServiceName || relatedPort.owner,
                container_id: containerId || null,
                internal: false,
              });
            });
          }
        }
      });

      const serverUrl = groups.find(g => g.id !== 'local')?.serverUrl;
      
      for (const [serverId, operations] of portsByServer) {
        await batchCustomServiceNames(serverId, operations, serverUrl);
      }

      setGroups((currentGroups) =>
        currentGroups.map((group) => {
          const serverPorts = portsByServer.get(group.id);
          if (!serverPorts) return group;
          
          const updatedData = group.data.map((port) => {
            const operation = serverPorts.find(op => 
              op.host_ip === port.host_ip && 
              op.host_port === port.host_port &&
              op.protocol === port.protocol &&
              (op.container_id || '') === (port.container_id || '') &&
              (op.internal || false) === (port.internal || false)
            );
            
            if (operation) {
              return {
                ...port,
                customServiceName: isReset ? null : customName,
                originalServiceName: isReset ? null : (operation.original_name || port.owner)
              };
            }
            return port;
          });
          
          return { ...group, data: updatedData };
        })
      );

      setBatchRenameModalOpen(false);
      clearSelection();
    } catch (error) {
      logger.error("Error updating service names:", error);
    } finally {
      setBatchLoading(false);
    }
  }, [groups, clearSelection]);

  const handleBatchHideSave = useCallback(async (data) => {
    const { selectedPorts, action } = data;
    setBatchLoading(true);

    try {
      const portsByServer = new Map();
      
      selectedPorts.forEach(portKey => {
        const parts = portKey.split('-');
        if (parts.length < 3) return;
        
        const serverId = parts[0];
        const isInternal = parts[parts.length - 1] === 'internal';
        const containerIdIndex = isInternal ? parts.length - 2 : parts.length - 1;
        const hostPortIndex = isInternal ? parts.length - 3 : parts.length - 2;
        
        const containerId = parts[containerIdIndex];
        const hostPort = parts[hostPortIndex];
        const hostIp = parts.slice(1, hostPortIndex).join('-');
        
        if (!portsByServer.has(serverId)) {
          portsByServer.set(serverId, []);
        }
        
        const server = groups.find(g => g.id === serverId);
        const port = server?.data.find(p => 
          p.host_ip === hostIp && 
          p.host_port === parseInt(hostPort) && 
          (p.container_id || '') === (containerId || '') &&
          (p.internal || false) === isInternal
        );
        
        if (port) {
          portsByServer.get(serverId).push(port);
        }
      });

      setGroups((currentGroups) =>
        currentGroups.map((group) => {
          const serverPorts = portsByServer.get(group.id);
          if (!serverPorts) return group;
          
          const updatedData = group.data.map((port) => {
            const shouldHide = serverPorts.some(sp => 
              sp.host_ip === port.host_ip && 
              sp.host_port === port.host_port &&
              (sp.container_id || '') === (port.container_id || '') &&
              (sp.internal || false) === (port.internal || false)
            );
            
            if (shouldHide) {
              return {
                ...port,
                ignored: action === 'hide'
              };
            }
            return port;
          });
          
          return { ...group, data: updatedData };
        })
      );

      const promises = [];
      for (const [serverId, serverPorts] of portsByServer) {
        for (const port of serverPorts) {
          let targetUrl = "/api/ignores";
          let isPeer = false;

          if (serverId !== "local") {
            const server = servers.find((s) => s.id === serverId);
            if (server && server.url) {
              targetUrl = `${server.url.replace(/\/+$/, "")}/api/ignores`;
              isPeer = true;
            }
          }

          const promise = fetch(targetUrl, {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
              server_id: isPeer ? "local" : serverId,
              host_ip: port.host_ip,
              host_port: port.host_port,
              protocol: port.protocol,
              container_id: port.container_id || null,
              internal: port.internal || false,
              ignored: action === 'hide',
            }),
          });
          promises.push(promise);
        }
      }

      await Promise.all(promises);
      
      setBatchHideModalOpen(false);
      clearSelection();
    } catch (error) {
      logger.error(`Error ${action}ing ports:`, error);
    } finally {
      setBatchLoading(false);
    }
  }, [groups, servers, clearSelection]);

  const handleBatchNotesSave = useCallback(async (data) => {
    const { note, selectedPorts, isClear } = data;
    setBatchLoading(true);

    try {
      const portsByServer = new Map();
      
      selectedPorts.forEach(portKey => {
        let matchedPort = null;
        let serverId = null;
        
        for (const group of groups) {
          const port = group.data.find(p => generatePortKey(group.id, p) === portKey);
          if (port) {
            matchedPort = port;
            serverId = group.id;
            break;
          }
        }
        
        if (!matchedPort || !serverId) return;
        
        if (!portsByServer.has(serverId)) {
          portsByServer.set(serverId, []);
        }
        
        portsByServer.get(serverId).push({
          action: isClear ? "delete" : "set",
          host_ip: matchedPort.host_ip,
          host_port: matchedPort.host_port,
          protocol: matchedPort.protocol || "tcp",
          note: isClear ? null : note,
          container_id: matchedPort.container_id || null,
          internal: matchedPort.internal || false,
        });
      });

      const serverUrl = groups.find(g => g.id !== 'local')?.serverUrl;
      
      for (const [serverId, operations] of portsByServer) {
        await batchNotes(serverId, operations, serverUrl);
      }

      setGroups((currentGroups) =>
        currentGroups.map((group) => {
          const serverPorts = portsByServer.get(group.id);
          if (!serverPorts) return group;
          
          const updatedData = group.data.map((port) => {
            const operation = serverPorts.find(op => 
              op.host_ip === port.host_ip && 
              op.host_port === port.host_port &&
              op.protocol === port.protocol &&
              (op.container_id || '') === (port.container_id || '') &&
              (op.internal || false) === (port.internal || false)
            );
            
            if (operation) {
              return {
                ...port,
                note: isClear ? null : note
              };
            }
            return port;
          });
          
          return { ...group, data: updatedData };
        })
      );
      
      setBatchNotesModalOpen(false);
      clearSelection();
    } catch (error) {
      logger.error("Error updating port notes:", error);
    } finally {
      setBatchLoading(false);
    }
  }, [groups, clearSelection]);

  const fetchServers = useCallback(() => {
    fetch("/api/servers")
      .then((r) => r.json())
      .then(setServers)
      .catch(logger.error);
  }, []);

  const handleReorder = useReorderServers({ servers, groups, setServers, setGroups });
  const addServer = useCallback(
    async (serverData, isUpdate = false) => {
      if (isUpdate) {
        const originalGroups = groups;
        const updatedGroups = groups.map((g) => {
          if (g.id === serverData.id) {
            return {
              ...g,
              server: serverData.label,
              label: serverData.label,
              url: serverData.url,
              parentId: serverData.parentId || null,
              platform_type: serverData.platform_type,
            };
          }
          return g;
        });
        setGroups(updatedGroups);

        try {
          const serverPayload = {
            id: serverData.id,
            label: serverData.label,
            url: serverData.url,
            parentId: serverData.parentId || null,
            type: serverData.type || "peer",
            unreachable: serverData.unreachable || false,
            platform_type: serverData.platform_type || "unknown",
          };
          if (serverData.apiKey) {
            serverPayload.apiKey = serverData.apiKey;
          }
          
          const response = await fetch("/api/servers", {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify(serverPayload),
          });

          if (!response.ok) {
            const errorData = await response.json();
            throw new Error(errorData.error || "Validation failed");
          }
        } catch (error) {
          setGroups(originalGroups);
          logger.error("Failed to save server:", error);
          throw error;
        }
      } else {
        const placeholderServer = {
          id: serverData.id,
          server: serverData.label,
          label: serverData.label,
          url: serverData.url,
          parentId: serverData.parentId || null,
          platform_type: serverData.platform_type,
          ok: null,
          data: [],
          systemInfo: {},
          vms: [],
        };

        setGroups((currentGroups) => [...currentGroups, placeholderServer]);

        try {
          const response = await fetch("/api/servers", {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
              id: serverData.id,
              label: serverData.label,
              url: serverData.url,
              parentId: serverData.parentId || null,
              type: serverData.type || "peer",
              unreachable: serverData.unreachable || false,
              platform_type: serverData.platform_type || "unknown",
              apiKey: serverData.apiKey || null,
            }),
          });

          if (!response.ok) {
            const errorData = await response.json();
            throw new Error(errorData.error || "Validation failed");
          }

          const scanResponse = await fetch(
            `/api/servers/${serverData.id}/scan`
          );
          if (scanResponse.ok) {
            const scanData = await scanResponse.json();
            const transformedPorts = await transformCollectorData(
              scanData,
              serverData.id,
              serverData.url
            );

            const finalServerData = {
              id: serverData.id,
              server: serverData.label,
              label: serverData.label,
              ok: true,
              url: serverData.url,
              platform: scanData.platform,
              platformName: scanData.platformName,
              data: transformedPorts,
              systemInfo: scanData.systemInfo,
              vms: scanData.vms,
              parentId: serverData.parentId,
              platform_type: serverData.platform_type || scanData.platform,
              enhancedFeaturesEnabled: scanData.enhancedFeaturesEnabled ?? true,
            };

            setGroups((currentGroups) =>
              currentGroups.map((g) =>
                g.id === serverData.id ? finalServerData : g
              )
            );
          } else {
            const errorData = await scanResponse
              .json()
              .catch(() => ({ error: `Scan failed` }));
            setGroups((currentGroups) =>
              currentGroups.map((g) => {
                if (g.id === serverData.id) {
                  return {
                    ...g,
                    ok: false,
                    error: errorData.details || errorData.error,
                  };
                }
                return g;
              })
            );
          }
        } catch (error) {
          logger.error("Failed to add server:", error);
          setGroups((currentGroups) =>
            currentGroups.filter((g) => g.id !== serverData.id)
          );
          throw error;
        }
      }
    },
    [groups, transformCollectorData]
  );

  const deleteServer = useCallback(
    async (id) => {
      const originalServers = servers;
      const originalGroups = groups;

      setServers((currentServers) => currentServers.filter((s) => s.id !== id));
      setGroups((currentGroups) => currentGroups.filter((g) => g.id !== id));

      if (selectedServer === id) {
        setSelectedServer(null);
      }

      try {
        const response = await fetch(`/api/servers/${id}`, {
          method: "DELETE",
        });

        if (!response.ok) {
          throw new Error(`Failed to delete server: ${response.status}`);
        }

        await fetchServers();
      } catch (error) {
        setServers(originalServers);
        setGroups(originalGroups);
        logger.error("Failed to delete server:", error);
      }
    },
    [servers, groups, selectedServer, fetchServers]
  );

  const toggleServerSelectionMode = useCallback((_serverId) => {
    if (selectionMode) {
      setSelectionMode(false);
      setSelectedPorts(new Set());
    } else {
      setSelectionMode(true);
    }
  }, [selectionMode]);

  const togglePortSelection = useCallback((port, serverId) => {
    const portKey = generatePortKey(serverId, port);
    setSelectedPorts(prev => {
      const newSet = new Set(prev);
      if (newSet.has(portKey)) {
        newSet.delete(portKey);
      } else {
        newSet.add(portKey);
      }
      
      if (newSet.size === 0) {
        setSelectionMode(false);
      }
      
      return newSet;
    });
  }, []);

  const selectAllPortsForServer = useCallback((serverId, ports) => {
    const portKeys = ports.map(port => generatePortKey(serverId, port));
    setSelectedPorts(prev => {
      const newSet = new Set(prev);
      portKeys.forEach(key => newSet.add(key));
      return newSet;
    });
    setSelectionMode(true);
  }, []);

  const handleLogoHealthCheck = useCallback(async () => {
    const started = performance.now();
    try {
      const response = await fetch("/api/health");
      const latency = Math.round(performance.now() - started);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      const data = await response.json();
      const uptimeSeconds = data?.uptimeSeconds ?? Math.floor(data?.uptime || 0);
      const uptimeLabel = uptimeSeconds ? formatUptime(uptimeSeconds) : "unknown";
      pushHealthToast({
        type: "success",
        message: `Heartbeat steady: ${latency}ms - uptime ${uptimeLabel}`,
      });
    } catch (error) {
      pushHealthToast({
        type: "error",
        message: `Health check failed: ${error.message}`,
      });
    }
  }, [pushHealthToast]);

  const handleBatchRename = useCallback(() => {
    setBatchRenameModalOpen(true);
  }, []);

  const handleBatchHide = useCallback(() => {
    setBatchHideModalOpen(true);
  }, []);

  const handleBatchNote = useCallback(() => {
    setBatchNotesModalOpen(true);
  }, []);

  useEffect(() => {
    if (auth.loading || (auth.authEnabled && !auth.authenticated)) {
      return;
    }
    fetchServers();
  }, [fetchServers, auth.loading, auth.authEnabled, auth.authenticated]);

  const selectedServerData = useMemo(() => {
    if (!selectedServer) return null;
    return groups.find((g) => g.id === selectedServer) || null;
  }, [groups, selectedServer]);

  const appPort = useMemo(() => {
    if (typeof window === "undefined") {
      return "4999";
    }
    return window.location.port || "4999";
  }, []);

  const autoRefreshMessages = useMemo(() => {
    const isTrueNAS = Boolean(
      selectedServerData?.platformName?.toLowerCase().includes("truenas")
    );
    return buildAutoRefreshMessages({
      isTrueNAS,
      currentPort: appPort || "4999",
    });
  }, [selectedServerData, appPort]);

  if (auth.loading) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-slate-50 dark:bg-slate-950">
        <div className="text-center">
          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
          <p className="text-slate-600 dark:text-slate-400">Loading...</p>
        </div>
      </div>
    );
  }

  if (auth.authEnabled && !auth.authenticated) {
    return <LoginPage />;
  }

  if (auth.requirePasswordChange) {
    return <ChangePasswordPage />;
  }

  const filterPorts = (group) => {
    if (!group.ok || !group.data) return group;

    const filteredData = group.data.filter((port) => {
      const matchesSourceFilter =
        (port.source === "docker" && filters.docker) ||
        (port.source === "system" && filters.system);

      if (!matchesSourceFilter) return false;

      if (!searchTerm) return true;

      const searchLower = searchTerm.toLowerCase();
      return (
        port.host_port.toString().includes(searchLower) ||
        (port.owner && port.owner.toLowerCase().includes(searchLower)) ||
        (port.customServiceName && port.customServiceName.toLowerCase().includes(searchLower)) ||
        (port.host_ip && port.host_ip.includes(searchLower)) ||
        port.target?.includes?.(searchLower) ||
        (port.note && port.note.toLowerCase().includes(searchLower))
      );
    });

    return {
      ...group,
      data: filteredData,
    };
  };

  function renderServer(server) {
    const filteredServer = filterPorts(server);

    return (
  <ServerSection
        key={server.id}
        id={server.id}
        server={server.server}
        ok={server.ok}
        data={filteredServer.data || []}
        error={server.error}
        errorType={server.errorType}
        searchTerm={searchHighlighting ? searchTerm : ""}
        actionFeedback={actionFeedback}
        onNote={openNoteModal}
        onToggleIgnore={toggleIgnore}
        onRename={openRenameModal}
        onCopy={(p, portProtocol) => {
          let hostForCopy;
          if (p.host_ip === "127.0.0.1" || p.host_ip === "[::1]") {
            hostForCopy = p.host_ip === "[::1]" ? "[::1]" : "127.0.0.1";
          }
          else if (server.id === "local" &&
              (p.host_ip === "0.0.0.0" || p.host_ip === "[::]")) {
            hostForCopy = hostOverride || window.location.hostname;
          }
          else if (
            server.id !== "local" &&
            server.url &&
            (p.host_ip === "0.0.0.0" || p.host_ip === "[::]")
          ) {
            try {
              hostForCopy = new URL(server.url).hostname;
            } catch {
              hostForCopy = "localhost";
            }
          }
          else {
            hostForCopy = p.host_ip;
          }

          const actualProtocol = portProtocol || "http";
          const urlToCopy = `${actualProtocol}://${hostForCopy}:${p.host_port}`;

          if (navigator.clipboard && navigator.clipboard.writeText) {
            navigator.clipboard
              .writeText(urlToCopy)
              .then(() => {
                setActionFeedback(prev => ({ 
                  ...prev, 
                  copy: { id: keyOf(server.id, p) } 
                }));
                setTimeout(
                  () => setActionFeedback(prev => ({ 
                    ...prev, 
                    copy: null 
                  })),
                  1500
                );
              })
              .catch((err) => {
                logger.warn("Clipboard write failed, using fallback:", err);
                copyToClipboardFallback(urlToCopy, server.id, p);
              });
          } else {
            copyToClipboardFallback(urlToCopy, server.id, p);
          }
        }}
        serverUrl={server.url}
        hostOverride={hostOverride}
        platformName={server.platformName}
        systemInfo={server.systemInfo}
        vms={server.vms}
        enhancedFeaturesEnabled={server.enhancedFeaturesEnabled}
        infoCardLayout={infoCardLayout}
        onInfoCardLayoutChange={setInfoCardLayout}
        portLayout={portLayout}
        onPortLayoutChange={setPortLayout}
        groupingMode={groupingMode}
        onGroupingModeChange={setGroupingMode}
        showIcons={showIcons}
        onShowIconsChange={setShowIcons}
        isExpanded={!!expandedServers[server.id]}
        onToggleExpanded={() => toggleServerExpanded(server.id)}
        openAccordionItems={openAccordions[server.id] ?? ["system-info", "vms"]}
  onAccordionChange={(items) => handleAccordionChange(server.id, items)}
        deepLinkContainerId={selectedServer === server.id ? deepLinkContainer : null}
        onOpenContainerDetails={(containerId) => handleContainerOpen(server.id, containerId)}
        onCloseContainerDetails={handleContainerClose}
        selectionMode={selectionMode}
        selectedPorts={selectedPorts}
        onToggleSelection={togglePortSelection}
        onToggleServerSelectionMode={() => toggleServerSelectionMode(server.id)}
        onSelectAllPorts={(ports) => selectAllPortsForServer(server.id, ports)}
        portSuggestion={portSuggestions[server.id]}
        onGeneratePort={generatePortForServer}
        autoxposeDisplayMode={autoxposeDisplayMode}
        autoxposeUrlStyle={autoxposeUrlStyle}
        autoxposePorts={autoxposePorts}
      />
    );
  }

  function renderAllMatchingServers() {
    const matching = groups
      .map((srv) => filterPorts(srv))
      .filter((srv) => srv.ok && Array.isArray(srv.data) && srv.data.length > 0);

    if (matching.length === 0) {
      return (
        <div className="text-center py-12 text-gray-500 dark:text-slate-400">
          No matches across servers.
        </div>
      );
    }

    return matching.map((srv) => (
      <div key={srv.id} className="space-y-8">
        {renderServer(srv)}
      </div>
    ));
  }

  const serverToRender = selectedServerData;
  const noDataForSelection = selectedServer && !serverToRender && !loading;

  return (
    <TooltipProvider>
      <OverridesProvider>
      <ServiceHealthProvider>
      {konamiHint && (
        <div className="fixed top-20 left-1/2 -translate-x-1/2 z-50 px-4 py-2 rounded-lg shadow-lg border backdrop-blur-sm pointer-events-none animate-in fade-in-0 slide-in-from-top-2 duration-200 bg-white/95 dark:bg-slate-800/95 border-slate-200 dark:border-slate-700 text-slate-900 dark:text-slate-100">
          <div className="flex items-center gap-2">
            <div className="flex-shrink-0 w-1.5 h-1.5 rounded-full bg-indigo-500 dark:bg-indigo-400 animate-pulse" />
            <span className="text-sm font-medium">{konamiHint}</span>
          </div>
        </div>
      )}
      <AutoxposeNudge
        servers={groups}
        autoxposeConnected={autoxposeStatus?.connected}
        onOpenSettings={() => setSettingsModalOpen(true)}
      />
      {healthToast && (
        <div
          className={`fixed top-20 right-6 z-50 px-4 py-2.5 rounded-lg shadow-lg border backdrop-blur-sm animate-in fade-in-0 slide-in-from-top-2 duration-200 ${
            healthToast.type === "error"
              ? "bg-rose-50/95 dark:bg-rose-900/95 border-rose-200 dark:border-rose-800 text-rose-900 dark:text-rose-100"
              : "bg-white/95 dark:bg-slate-800/95 border-slate-200 dark:border-slate-700 text-slate-900 dark:text-slate-100"
          }`}
        >
          <div className="flex items-center gap-2">
            {healthToast.type === "error" ? (
              <div className="flex-shrink-0 w-1.5 h-1.5 rounded-full bg-rose-500 dark:bg-rose-400" />
            ) : (
              <div className="flex-shrink-0 w-1.5 h-1.5 rounded-full bg-indigo-500 dark:bg-indigo-400" />
            )}
            <span className="text-sm font-medium">{healthToast.message}</span>
          </div>
        </div>
      )}
      <div className={`flex flex-col h-screen bg-slate-50 dark:bg-slate-950 ${hackerMode ? "hacker-mode-active" : ""}`}>
        <AppHeader
          groups={groups}
          loading={loading}
          onRefresh={fetchAll}
          
          searchTerm={searchTerm}
          onSearchChange={setSearchTerm}
          searchScope={searchScope}
          onSearchScopeChange={setSearchScope}
          searchHighlighting={searchHighlighting}
          onSearchHighlightingChange={setSearchHighlighting}
          filters={filters}
          onFilterChange={setFilters}
          selectedServer={selectedServer}
          isDarkMode={isDarkMode}
          onThemeToggle={() => setIsDarkMode(!isDarkMode)}
          onGoHome={handleLogoClick}
          onToggleSidebar={() => setSidebarOpen(!isSidebarOpen)}
          onShowWhatsNew={shouldShowWhatsNewButton ? handleShowWhatsNew : null}
          hasNewFeatures={shouldShowWhatsNewButton}
          autoRefreshEnabled={autoRefreshEnabled}
          onAutoRefreshToggle={() => setAutoRefreshEnabled(!autoRefreshEnabled)}
          onLogoLongPress={handleLogoHealthCheck}
          hackerMode={hackerMode}
          onDisableHackerMode={disableHackerMode}
          autoRefreshMessages={autoRefreshMessages}
          onOpenSettings={() => setSettingsModalOpen(true)}
          onOpenApiKey={() => setApiKeyModalOpen(true)}
          refreshInterval={refreshInterval}
          autoxposeStatus={autoxposeStatus}
          searchInputRef={searchInputRef}
        />
        <AppSidebarLayout
          isSidebarOpen={isSidebarOpen}
          onCloseSidebar={() => setSidebarOpen(false)}
          servers={groups}
          selectedId={selectedServer}
          onSelect={handleSelectServer}
          addServer={addServer}
          deleteServer={deleteServer}
          onReorder={handleReorder}
          loading={loading}
          hostOverride={hostOverride}
          sidebarLayout={sidebarLayout}
          onOpenAddServer={handleOpenAddServer}
        >
          <main className="flex-1 overflow-auto">
            <div className="p-6">
              {loading && (
                <MultipleServerSkeleton count={selectedServer ? 1 : 2} />
              )}

              {error && !loading && (
                <div className="bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg p-4 mb-6">
                  <p className="text-red-800 dark:text-red-200">{error}</p>
                </div>
              )}

              {!loading && !selectedServer && (
                searchTerm && searchScope === "all" ? (
                  <div className="space-y-8">{renderAllMatchingServers()}</div>
                ) : (
                  <div className="text-center py-24 text-slate-500 dark:text-slate-400 flex flex-col items-center animate-in fade-in-0 duration-300">
                    <BarChart3 className="h-16 w-16 mb-4 text-slate-400" />
                    <h2 className="text-xl font-semibold text-slate-700 dark:text-slate-300">
                      Dashboard Home
                    </h2>
                    <p className="mt-2 max-w-md">
                      Select a server from the sidebar to view its ports, system
                      information, and more. Use the "Add Server" button to
                      connect to new local or remote environments.
                    </p>
                  </div>
                )
              )}

              {!loading && noDataForSelection && (
                <div className="text-center py-12 text-gray-500 dark:text-slate-400">
                  No data available for the selected server. It might be offline
                  or misconfigured.
                </div>
              )}

              {!loading && serverToRender && !(searchTerm && searchScope === "all") && (
                <div className="space-y-8 animate-in fade-in-0 duration-300">{renderServer(serverToRender)}</div>
              )}

              {!loading && selectedServer && searchTerm && searchScope === "all" && (
                <div className="space-y-8 animate-in fade-in-0 duration-300">{renderAllMatchingServers()}</div>
              )}
            </div>
          </main>
        </AppSidebarLayout>
      </div>

      <Dialog open={noteModalOpen} onOpenChange={setNoteModalOpen}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>Edit Port Note</DialogTitle>
            <DialogDescription>
              Add or edit a note for this port to help remember its purpose or
              configuration.
            </DialogDescription>
          </DialogHeader>
          <div className="space-y-4 py-4">
            <div className="space-y-2">
              <Label htmlFor="note">Note</Label>
              <Input
                id="note"
                value={draftNote}
                onChange={(e) => setDraftNote(e.target.value)}
                placeholder="Add a note..."
              />
            </div>
          </div>
          <DialogFooter>
            <Button variant="outline" onClick={() => setNoteModalOpen(false)}>
              Cancel
            </Button>
            <Button onClick={saveNoteModal}>Save</Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>

      <WhatsNewModal
        {...whatsNewModalProps}
        onOpenSettings={() => setSettingsModalOpen(true)}
      />

      <ServiceRenameModal
        isOpen={renameModalOpen}
        onClose={() => setRenameModalOpen(false)}
        port={renamePort}
        serverId={renameSrvId}
        serverUrl={groups.find(g => g.id === renameSrvId)?.url}
        onSave={handleServiceRename}
        loading={renameLoading}
      />

      <BatchRenameModal
        isOpen={batchRenameModalOpen}
        onClose={() => setBatchRenameModalOpen(false)}
        selectedPorts={selectedPorts}
        onSave={handleBatchRenameSave}
        loading={batchLoading}
      />

      <BatchHideModal
        isOpen={batchHideModalOpen}
        onClose={() => setBatchHideModalOpen(false)}
        selectedPorts={selectedPorts}
        onConfirm={handleBatchHideSave}
        loading={batchLoading}
        action="hide"
      />

      <BatchNotesModal
        isOpen={batchNotesModalOpen}
        onClose={() => setBatchNotesModalOpen(false)}
        selectedPorts={selectedPorts}
        onSave={handleBatchNotesSave}
        loading={batchLoading}
      />

      <SettingsModal
        isOpen={settingsModalOpen}
        onClose={() => setSettingsModalOpen(false)}
        theme={themePreference}
        onThemeChange={handleThemeChange}
        showIcons={showIcons}
        onShowIconsChange={setShowIcons}
        refreshInterval={refreshInterval}
        onRefreshIntervalChange={(val) => {
          setRefreshInterval(val);
          localStorage.setItem("refreshInterval", val.toString());
        }}
        includeUdp={includeUdp}
        onIncludeUdpChange={(val) => {
          setIncludeUdp(val);
          localStorage.setItem("includeUdp", val.toString());
        }}
        disableCache={disableCache}
        onDisableCacheChange={(val) => {
          setDisableCache(val);
          localStorage.setItem("disableCache", val.toString());
        }}
        autoxposeStatus={autoxposeStatus}
        autoxposeDisplayMode={autoxposeDisplayMode}
        autoxposeUrlStyle={autoxposeUrlStyle}
        onAutoxposeConnect={handleAutoxposeConnect}
        onAutoxposeDisconnect={handleAutoxposeDisconnect}
        onAutoxposeDisplayModeChange={handleAutoxposeDisplayModeChange}
        onAutoxposeUrlStyleChange={handleAutoxposeUrlStyleChange}
      />

      <ApiKeyModal
        isOpen={apiKeyModalOpen}
        onClose={() => setApiKeyModalOpen(false)}
      />

      <BatchOperationsBar
        selectedCount={selectedPorts.size}
        onBatchRename={handleBatchRename}
        onBatchHide={handleBatchHide}
        onBatchNote={handleBatchNote}
        onClearSelection={clearSelection}
        onSelectAll={() => {
          const currentGroup = selectedServer 
            ? groups.find(g => g.id === selectedServer)
            : null;
          
          if (currentGroup) {
            let showInternal = false;
            try {
              const saved = localStorage.getItem(`showInternalPorts:${currentGroup.id}`);
              showInternal = saved ? JSON.parse(saved) : false;
            } catch {
              showInternal = false;
            }
            
            const filteredPorts = filterPorts(currentGroup).data || [];
            const visiblePorts = filteredPorts.filter(port => 
              !port.ignored && (showInternal || !port.internal)
            );
            
            const portKeys = visiblePorts.map(port => 
              generatePortKey(currentGroup.id, port)
            );
            setSelectedPorts(new Set(portKeys));
            setSelectionMode(true);
          }
        }}
        showSelectAll={(() => {
          const currentGroup = selectedServer 
            ? groups.find(g => g.id === selectedServer)
            : null;
          
          if (!currentGroup) return false;
          
          let showInternal = false;
          try {
            const saved = localStorage.getItem(`showInternalPorts:${currentGroup.id}`);
            showInternal = saved ? JSON.parse(saved) : false;
          } catch {
            showInternal = false;
          }
          
          const filteredPorts = filterPorts(currentGroup).data || [];
          const visiblePortsCount = filteredPorts.filter(port => 
            !port.ignored && (showInternal || !port.internal)
          ).length;
          
          return selectedPorts.size > 0 && selectedPorts.size < visiblePortsCount;
        })()}
        loading={false}
      />
      </ServiceHealthProvider>
      </OverridesProvider>
    </TooltipProvider>
  );

  function copyToClipboardFallback(text, serverId, port) {
    const textArea = document.createElement("textarea");
    textArea.value = text;
    textArea.style.position = "fixed";
    textArea.style.left = "-999999px";
    textArea.style.top = "-999999px";
    document.body.appendChild(textArea);
    textArea.focus();
    textArea.select();

    try {
      const successful = document.execCommand("copy");
      if (successful) {
        setActionFeedback(prev => ({ 
          ...prev, 
          copy: { id: keyOf(serverId, port) } 
        }));
        setTimeout(() => setActionFeedback(prev => ({ 
          ...prev, 
          copy: null 
        })), 1500);
      } else {
        prompt("Copy this URL:", text);
      }
    } catch (err) {
      logger.warn("Copy failed:", err);
      prompt("Copy this URL:", text);
    } finally {
      document.body.removeChild(textArea);
    }
  }
}