Skip to content

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

20.2 KB
Raw Blame
import React, { useState, useEffect, useRef } from "react";
import {
  Plus,
  Check,
  X,
  BarChart3,
  Loader2,
  AlertCircle,
} from "lucide-react";
import { DndContext, PointerSensor, KeyboardSensor, useSensor, useSensors, closestCenter } from "@dnd-kit/core";
import { SortableContext, sortableKeyboardCoordinates, verticalListSortingStrategy } from "@dnd-kit/sortable";
import { Input } from "@/components/ui/input";
import { Button } from "@/components/ui/button";
import { Label } from "@/components/ui/label";
import {
  AlertDialog,
  AlertDialogContent,
  AlertDialogHeader,
  AlertDialogTitle,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogCancel,
  AlertDialogAction,
} from "@/components/ui/alert-dialog";
import { SidebarSkeleton } from "./SidebarSkeleton";
import { SortableServerCard } from "./SortableServerCard";
import { SidebarSortChip } from "./SidebarSortChip";
import { buildSidebarTree, sortByLabel, computeReorderItems } from "@/lib/sidebar-tree";
import { useSidebarSortMode } from "@/hooks/useSidebarSortMode";

const generateServerId = (label) => {
  if (!label || !label.trim()) {
    return `server-${Date.now()}`;
  }
  const cleanId = label
    .trim()
    .toLowerCase()
    .replace(/[\s\-_.,;:!?()[\]{}'"]+/g, "-")
    .replace(/[^\p{L}\p{N}-]/gu, "")
    .replace(/-+/g, "-")
    .replace(/^-+|-+$/g, "");
  if (!cleanId || cleanId.length === 0) {
    return `server-${Date.now()}`;
  }
  return cleanId.substring(0, 50);
};

export function Sidebar({
  servers,
  selectedId,
  onSelect,
  onAdd,
  onDelete,
  onReorder,
  loading,
  hostOverride,
  lastRefreshedAt = {},
  requestedMode,
  onRequestedModeHandled,
}) {
  const [mode, setMode] = useState("list");
  const [form, setForm] = useState({
    label: "",
    url: "",
    parentId: "",
    type: "peer",
    apiKey: "",
    hasExistingKey: false,
  });
  const [error, setError] = useState("");
  const [urlValid, setUrlValid] = useState(false);
  const [validating, setValidating] = useState(false);
  const [allowUnreachable, setAllowUnreachable] = useState(false);
  const [serverToDelete, setServerToDelete] = useState(null);
  const [submitting, setSubmitting] = useState(false);
  const [validationStatus, setValidationStatus] = useState(null);
  const latestValidationRef = useRef(0);

  const sensors = useSensors(
    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
    useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates })
  );

  const { sortMode, setSortMode, undoState, undoToPrevious } = useSidebarSortMode();

  useEffect(() => {
    if (!requestedMode) {
      return;
    }

    setMode(requestedMode);
    onRequestedModeHandled?.();
  }, [requestedMode, onRequestedModeHandled]);

  useEffect(() => {
    if (mode !== "add" && mode !== "list") {
      const srv = servers.find((s) => s.id === mode);
      if (srv) {
        setForm({
          label: srv.label || srv.server,
          url: srv.url || "",
          parentId: srv.parentId || "",
          type: srv.type || "peer",
          apiKey: "",
          hasExistingKey: srv.hasApiKey || false,
        });
        setAllowUnreachable(srv.unreachable || false);
      }
    } else {
      setForm({
        label: "",
        url: "",
        parentId: "",
        type: "peer",
        apiKey: "",
        hasExistingKey: false,
      });
      setAllowUnreachable(false);
    }
    setError("");
    setValidationStatus(null);
    setUrlValid(false);
  }, [mode, servers]);

  useEffect(() => {
    const originalUrl = form.url.trim();
    if (!originalUrl) {
      setUrlValid(false);
      setError("");
      setValidating(false);
      setValidationStatus(null);
      return;
    }
    const hasValidFormat =
      /^(https?:\/\/)?[\w-]+(\.[\w-]+)*([:\d]+)?(\/.*)?$/i.test(originalUrl);
    if (!hasValidFormat) {
      setValidationStatus({ type: "warning", message: "Invalid URL format" });
      setUrlValid(false);
      setValidating(false);
      return;
    }
    const validateUrl = async () => {
      const currentValidation = ++latestValidationRef.current;
      setValidating(true);
      setError("");
      setValidationStatus({
        type: "loading",
        message: "Checking server availability...",
      });
      let urlForCheck = originalUrl.startsWith("http")
        ? originalUrl
        : `http://${originalUrl}`;
      if (allowUnreachable) {
        if (currentValidation === latestValidationRef.current) {
          setUrlValid(true);
          setValidating(false);
          setValidationStatus({
            type: "success",
            message: "URL bypassed (unreachable allowed)",
          });
        }
        return;
      }
      try {
        const healthCheckUrl = `${urlForCheck.replace(/\/+$/, "")}/api/health`;
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 5000);
        const response = await fetch(healthCheckUrl, {
          signal: controller.signal,
          mode: "cors",
        });
        clearTimeout(timeoutId);
        if (currentValidation === latestValidationRef.current) {
          if (response.ok) {
            setUrlValid(true);
            setValidationStatus({
              type: "success",
              message: "Server is reachable",
            });
          } else {
            setUrlValid(false);
            setValidationStatus({
              type: "error",
              message: `Server responded with ${response.status}`,
            });
          }
          setValidating(false);
        }
      } catch (e) {
        if (currentValidation === latestValidationRef.current) {
          setUrlValid(false);
          setValidating(false);
          if (e.name === "AbortError") {
            setValidationStatus({
              type: "error",
              message: "Connection timeout",
            });
          } else {
            setValidationStatus({
              type: "error",
              message: `Cannot reach server: ${e.message}`,
            });
          }
        }
      }
    };
    const debounce = setTimeout(validateUrl, 1200);
    return () => clearTimeout(debounce);
  }, [form.url, allowUnreachable]);

  const handleSubmit = async (e) => {
    e.preventDefault();
    if (!form.label.trim()) {
      setError("Server name is required");
      return;
    }
    if (form.type === "peer" && !allowUnreachable && !urlValid) {
      setError(
        "Please enter a valid, reachable URL or allow unreachable servers"
      );
      return;
    }
    setSubmitting(true);
    setError("");
    try {
      let finalUrl = form.url.trim();
      if (
        finalUrl &&
        !finalUrl.startsWith("http://") &&
        !finalUrl.startsWith("https://")
      ) {
        finalUrl = `http://${finalUrl}`;
      }
      const serverData = {
        id: mode === "add" ? generateServerId(form.label.trim()) : mode,
        label: form.label.trim(),
        url: finalUrl,
        type: form.type,
        unreachable: allowUnreachable,
        parentId: form.parentId || null,
        ...(form.apiKey?.trim() ? { apiKey: form.apiKey.trim() } : form.hasExistingKey ? {} : { apiKey: null }),
      };
      await onAdd(serverData, mode !== "add");
      setValidationStatus({
        type: "success",
        message:
          mode === "add"
            ? "Server added successfully!"
            : "Server updated successfully!",
      });
      setTimeout(() => {
        setMode("list");
        setValidationStatus(null);
      }, 1000);
    } catch (e) {
      setError(e.message || "Failed to save server");
      setValidationStatus({
        type: "error",
        message: e.message || "Operation failed",
      });
    } finally {
      setSubmitting(false);
    }
  };

  const confirmDelete = () => {
    if (serverToDelete) {
      onDelete(serverToDelete.id);
      setServerToDelete(null);
    }
  };

  const availableParents = servers.filter((s) => s.id !== mode);

  const ValidationStatus = () => {
    if (!validationStatus && !validating) return null;
    const { type, message } = validationStatus || {};
    const statusConfig = {
      loading: {
        icon: Loader2,
        className: "text-blue-500 animate-spin",
        bgColor: "bg-blue-50 dark:bg-blue-900/20",
      },
      success: {
        icon: Check,
        className: "text-green-500",
        bgColor: "bg-green-50 dark:bg-blue-900/20",
      },
      error: {
        icon: AlertCircle,
        className: "text-red-500",
        bgColor: "bg-red-50 dark:bg-red-900/20",
      },
      warning: {
        icon: AlertCircle,
        className: "text-amber-500",
        bgColor: "bg-amber-50 dark:bg-amber-900/20",
      },
    };
    if (validating) {
      const { icon: Icon, className, bgColor } = statusConfig.loading;
      return (
        <div
          className={`flex items-center space-x-2 p-2 rounded-md ${bgColor} mt-2`}
        >
          <Icon className={`h-4 w-4 ${className}`} />
          <span className="text-sm text-blue-700 dark:text-blue-300">
            Checking server availability...
          </span>
        </div>
      );
    }
    if (type && statusConfig[type]) {
      const { icon: Icon, className, bgColor } = statusConfig[type];
      return (
        <div
          className={`flex items-center space-x-2 p-2 rounded-md ${bgColor} mt-2`}
        >
          <Icon className={`h-4 w-4 ${className}`} />
          <span
            className={`text-sm ${
              type === "success"
                ? "text-green-700 dark:text-green-300"
                : type === "error"
                ? "text-red-700 dark:text-red-300"
                : "text-amber-700 dark:text-amber-300"
            }`}
          >
            {message}
          </span>
        </div>
      );
    }
    return null;
  };

  if (loading) {
    return <SidebarSkeleton />;
  }

  const tree = buildSidebarTree(servers);
  const { topLevelServers, childrenMap } = tree;
  const dragEnabled = Boolean(onReorder) && sortMode === "custom";
  const displayedTopLevel = sortByLabel(topLevelServers, sortMode);

  const renderServerHierarchy = (server, level = 0) => {
    const children = childrenMap.get(server.id) || [];
    const displayedChildren = sortByLabel(children, sortMode);
    const maxIndentLevel = 3;
    const childIds = displayedChildren.map((c) => c.id);
    return (
      <SortableServerCard
        key={server.id}
        server={server}
        isSelected={selectedId === server.id}
        onSelect={onSelect}
        onEdit={setMode}
        onDelete={setServerToDelete}
        hostOverride={hostOverride}
        lastRefreshedTs={lastRefreshedAt[server.id]}
        draggable={dragEnabled}
      >
        {displayedChildren.length > 0 && level < maxIndentLevel && (
          <div className="mt-4 pt-4 border-t border-slate-200 dark:border-slate-700/50 space-y-3">
            <SortableContext items={childIds} strategy={verticalListSortingStrategy}>
              {displayedChildren.map((child) => renderServerHierarchy(child, level + 1))}
            </SortableContext>
          </div>
        )}
      </SortableServerCard>
    );
  };

  const handleDragEnd = (event) => {
    if (!onReorder || !dragEnabled) return;
    const items = computeReorderItems(event.active, event.over, tree);
    if (items) onReorder(items);
  };

  const topLevelIds = displayedTopLevel.map((s) => s.id);

  return (
    <div className="flex flex-col h-full bg-white dark:bg-slate-900">
      {mode === "list" ? (
        <>
          <div className="p-6 flex-shrink-0">
            <div className="mb-6">
              <h2 className="text-lg font-semibold text-slate-900 dark:text-slate-100 mb-1 flex items-center">
                <BarChart3 className="h-5 w-5 mr-2 text-slate-600 dark:text-slate-400" />
                Dashboard
              </h2>
              <p className="text-sm text-slate-500 dark:text-slate-400">
                Server Overview
              </p>
            </div>
            <h3 className="text-sm font-medium text-slate-500 dark:text-slate-400 mb-3 uppercase tracking-wider">
              Servers ({servers.length})
            </h3>
          </div>
          <div className="flex-1 overflow-y-auto px-6 space-y-4 pb-4">
            {!loading && (
              <DndContext
                sensors={sensors}
                collisionDetection={closestCenter}
                onDragEnd={handleDragEnd}
              >
                <SortableContext items={topLevelIds} strategy={verticalListSortingStrategy}>
                  {displayedTopLevel.map((server) => renderServerHierarchy(server))}
                </SortableContext>
              </DndContext>
            )}
          </div>
          <div className="px-6 pt-2 flex-shrink-0">
            <SidebarSortChip
              sortMode={sortMode}
              onChange={setSortMode}
              undoState={undoState}
              onUndo={undoToPrevious}
            />
          </div>
          <div className="p-6 mt-auto flex-shrink-0">
            <button
              onClick={() => setMode("add")}
              className="w-full p-4 border-2 border-dashed border-slate-300 dark:border-slate-700 rounded-xl text-slate-500 dark:text-slate-400 hover:border-slate-400 dark:hover:border-slate-600 hover:text-slate-600 dark:hover:text-slate-300 transition-colors flex flex-col items-center justify-center"
            >
              <Plus className="h-5 w-5 mb-1" />
              <span className="text-sm font-medium">Add Server</span>
            </button>
          </div>
        </>
      ) : (
        <div className="p-6 flex-1 overflow-y-auto">
          <h3 className="text-lg font-semibold text-slate-900 dark:text-slate-100 mb-6">
            {mode === "add" ? "Add New Server" : "Edit Server"}
          </h3>
          <form onSubmit={handleSubmit} className="space-y-4">
            <div>
              <Label htmlFor="label">Server Name *</Label>
              <Input
                id="label"
                value={form.label}
                onChange={(e) => setForm({ ...form, label: e.target.value })}
                placeholder="My Web Server"
                className="mt-1.5"
                disabled={submitting}
              />
            </div>
            <div>
              <Label htmlFor="url">Server URL</Label>
              <div className="relative">
                <Input
                  id="server-url"
                  value={form.url}
                  onChange={(e) => setForm({ ...form, url: e.target.value })}
                  placeholder="http://localhost:3000"
                  className={`pr-10 ${
                    urlValid
                      ? "border-green-500 focus:border-green-500"
                      : validationStatus?.type === "error"
                      ? "border-red-300 focus:border-red-500"
                      : ""
                  }`}
                  disabled={submitting}
                />
                {form.url && !validating && (
                  <div className="absolute inset-y-0 right-0 pr-3 flex items-center">
                    {urlValid ? (
                      <Check className="w-4 h-4 text-green-500" />
                    ) : validationStatus?.type === "error" ? (
                      <X className="w-4 h-4 text-red-500" />
                    ) : null}
                  </div>
                )}
                {validating && (
                  <div className="absolute inset-y-0 right-0 pr-3 flex items-center">
                    <Loader2 className="w-4 h-4 text-blue-500 animate-spin" />
                  </div>
                )}
              </div>
              <ValidationStatus />
            </div>
            {form.url && (
              <div>
                <Label htmlFor="apiKey">API Key (Optional)</Label>
                <Input
                  id="apiKey"
                  type="password"
                  value={form.apiKey}
                  onChange={(e) => setForm({ ...form, apiKey: e.target.value })}
                  placeholder={form.hasExistingKey ? "••••••••••••••••" : "Enter API key if server has auth enabled"}
                  className="mt-1.5"
                  disabled={submitting}
                />
                <p className="text-xs text-slate-500 dark:text-slate-400 mt-1">{form.hasExistingKey && !form.apiKey
                  ? "Key saved. Changing the server address requires a new key."
                  : "Required if the remote server has authentication enabled"}</p>
                {(form.apiKey || form.hasExistingKey) && !/^https:\/\//i.test(form.url) && (
                  <p role="status" className="mt-1 text-xs text-amber-700 dark:text-amber-300">HTTP sends this key without encryption. Use HTTPS or an encrypted VPN on untrusted networks.</p>
                )}
              </div>
            )}
            {availableParents.length > 0 && (
              <div>
                <Label htmlFor="parent">Parent Server (Optional)</Label>
                <select
                  id="parent"
                  value={form.parentId}
                  onChange={(e) =>
                    setForm({ ...form, parentId: e.target.value })
                  }
                  className="w-full mt-1.5 rounded-md border border-gray-300 dark:border-gray-700 bg-white dark:bg-gray-900 p-2 text-sm disabled:opacity-50"
                  disabled={submitting}
                >
                  <option value="">None (Top-level server)</option>
                  {availableParents.map((s) => (
                    <option key={s.id} value={s.id}>
                      {s.label || s.server}
                    </option>
                  ))}
                </select>
              </div>
            )}
            <div className="flex items-center justify-between pt-2">
              <div className="flex items-center">
                <input
                  id="allow-unreachable"
                  type="checkbox"
                  checked={allowUnreachable}
                  onChange={(e) => setAllowUnreachable(e.target.checked)}
                  className="rounded border-gray-300"
                  disabled={submitting}
                />
                <Label
                  htmlFor="allow-unreachable"
                  className="ml-2 text-sm font-normal text-slate-600 dark:text-slate-400"
                >
                  Save even if unreachable
                </Label>
              </div>
            </div>
            {error && (
              <p className="mt-4 text-sm text-red-600 dark:text-red-500 bg-red-100 dark:bg-red-900/20 p-3 rounded-md">
                {error}
              </p>
            )}
            <div className="mt-6 flex flex-col sm:flex-row justify-end gap-2">
              <Button variant="outline" onClick={() => setMode("list")}>
                Cancel
              </Button>
              <Button
                onClick={handleSubmit}
                disabled={
                  !form.label ||
                  (form.type === "peer" && !allowUnreachable && !urlValid) ||
                  submitting
                }
                className="min-w-[100px]"
              >
                {submitting ? (
                  <div className="flex items-center">
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    {mode === "add" ? "Adding..." : "Saving..."}
                  </div>
                ) : mode === "add" ? (
                  "Add Server"
                ) : (
                  "Save Changes"
                )}
              </Button>
            </div>
          </form>
        </div>
      )}
      <AlertDialog
        open={!!serverToDelete}
        onOpenChange={() => setServerToDelete(null)}
      >
        <AlertDialogContent>
          <AlertDialogHeader>
            <AlertDialogTitle>Delete Server</AlertDialogTitle>
            <AlertDialogDescription>
              Are you sure you want to delete "
              {serverToDelete?.label || serverToDelete?.server}"? This action
              cannot be undone and will remove all associated data.
            </AlertDialogDescription>
          </AlertDialogHeader>
          <AlertDialogFooter>
            <AlertDialogCancel>Cancel</AlertDialogCancel>
            <AlertDialogAction
              onClick={confirmDelete}
              className="bg-red-600 hover:bg-red-700 focus:ring-red-500"
            >
              Delete Server
            </AlertDialogAction>
          </AlertDialogFooter>
        </AlertDialogContent>
      </AlertDialog>
    </div>
  );
}