import { FormEvent, type KeyboardEvent as ReactKeyboardEvent, useCallback, useEffect, useMemo, useRef, useState, } from "react"; import { Background, Controls, MarkerType, MiniMap, ReactFlow, type Connection, type Edge, type Node, type NodeChange, type ReactFlowInstance, } from "@xyflow/react"; import "@xyflow/react/dist/style.css"; import { api, ApiError, AUTH_REQUIRED_EVENT, downloadBackupFile, type BackupInfo, hasApiAccessToken, type AlertSettings, setApiAccessToken, type AvailabilitySummary, type ComponentRole, type Criticality, type DiscoveryResult, type DiscoveryRun, type DiscoveryStatus, type DiscoveryObservation, type RelationEvidence, type ProbeRepairReport, type TopologySuggestion, type TopologyDiff, type TopologySnapshot, type ProviderStatus, type DemoState, type DockerCandidate, type EventRecord, type HealthStatus, type IncidentDetail, type IncidentOverview, type IncidentRecord, type MonitoringState, type ServiceInput, type ServiceKind, type ServiceSnapshot, type SemanticTopology, } from "./api"; import { LivingEdge } from "./LivingEdge"; import { DemoWalkthrough } from "./demo/DemoWalkthrough"; import { ServiceNodeView, type ServiceNode, type ServiceNodeData } from "./topology/ServiceNode"; import { applicationEdges, applicationName, applicationTopologyLayout, topologyLayout, type LegacyTopologyMode, } from "./topology/legacyLayout"; export { applicationEdges, applicationTopologyLayout, landscapeGroups, topologyLayout, } from "./topology/legacyLayout"; import { matchesStatusFilter, semanticTopologyGraph, type SemanticView, } from "./topology/semanticGraph"; import { TopologyCommandBar } from "./topology/TopologyCommandBar"; import { GraphListView, nodeAriaLabel } from "./topology/GraphListView"; import { ConfirmDialog } from "./components/ConfirmDialog"; import { StatusIcon } from "./components/StatusIcon"; import { PANEL_LABELS, criticalityText, formatDateTime, formatNumber, formatTime, modeText, providerHealthText, providerText, statusText } from "./labels"; import { eventMeta, groupActivity, timeOf } from "./activityView"; import { ActionsMenu } from "./components/ActionsMenu"; import { Activity, Circle, CircleCheck, Download, Eye, FileCode, FlaskConical, History, LayoutDashboard, Lock, LockOpen, Menu, MessageSquare, Network, Plus, Radar, RefreshCw, Server, Settings, Siren, Wrench, X, Zap, type LucideIcon, } from "lucide-react"; import { arrangeTopology, topologyStructureKey } from "./topologyLayout"; import { createRefreshScheduler, type RealtimeEvent, type RefreshScheduler, } from "./realtime/refreshPlan"; import { useRealtimeEvents } from "./realtime/useRealtimeEvents"; import { changedFields, filterSuggestions } from "./auditViewModel"; import { applicationLocation, domainLocation, isTopologyRoot, topologyRoot, topologyUp, type TopologyLocation, } from "./topologyNavigation"; import { navigationKey, parseUrlState, serializeUrlState, type Panel, type UrlState, } from "./routing/urlState"; type FilterStatus = "all" | "unresolved" | "problems" | HealthStatus; type TopologyMode = LegacyTopologyMode; type ServiceForm = Omit & { depends_on: string[]; tags: string; }; type MonitoringFilter = "all" | MonitoringState; const emptyForm = (): ServiceForm => ({ name: "", kind: "http", url: "", host: "", port: undefined, depends_on: [], tags: "", group: "", environment: "production", application: "", domain: "", component_role: "unknown", application_locked: false, domain_locked: false, component_role_locked: false, criticality: "medium", description: "", category: "unknown", visibility: "visible", lifecycle: "active", enabled: true, monitoring_enabled: true, interval_seconds: undefined, timeout_seconds: undefined, retries: undefined, failure_threshold: 1, recovery_threshold: 1, availability_target: undefined, maintenance_enabled: false, }); const effectiveStatus = (snapshot: ServiceSnapshot): HealthStatus => snapshot.effective_status ?? snapshot.latest_probe?.status ?? "unknown"; const statusLabel = (status: HealthStatus) => status === "unknown" ? "Gezondheid onbekend" : statusText(status); /** Spoken summary of the history strip; the dots alone are colour-only. */ function historySummary(history: { status: string }[]): string { if (!history.length) return "Geen controlegeschiedenis"; const tally = new Map(); for (const item of history) tally.set(item.status, (tally.get(item.status) ?? 0) + 1); const parts = [...tally].map(([status, count]) => `${count} ${status}`).join(", "); return `Laatste ${history.length} controles: ${parts}. Meest recent: ${history[0].status}.`; } /** Shown in the mobile bottom bar; the rest sits behind "More". */ const PRIMARY_PANELS: Panel[] = ["overview", "topology", "incidents", "services"]; const ACTIVITY_ICONS: Record = { "incident.opened": Siren, "incident.resolved": CircleCheck, "incident.duplicate_resolved": CircleCheck, "incident.acknowledged": Eye, "incident.updated": RefreshCw, "incident.note": MessageSquare, "service.state_changed": Activity, "service.runtime_observed": Server, "service.maintenance_changed": Wrench, "topology.changed": Network, "flapping.detected": Activity, }; const PANEL_ICONS: Record = { overview: LayoutDashboard, topology: Network, incidents: Siren, services: Server, discovery: Radar, changes: History, activity: Activity, config: FileCode, settings: Settings, }; const formatDate = (value: string | null | undefined) => value ? formatDateTime(value) : "—"; const monitoringLabel = (state: MonitoringState) => ({ active_probe: "Actieve controle", docker_health: "Docker-gezondheid", appops_observation: "Waargenomen via AppOps", observed: "Runtime waargenomen", unmonitored: "Niet bewaakt", disabled: "Bewaking uitgeschakeld", })[state]; const hasCurrentNetworkProbe = (snapshot: ServiceSnapshot) => snapshot.service.monitoring_state === "active_probe"; const nodeTypes = { service: ServiceNodeView }; const edgeTypes = { living: LivingEdge }; function downloadText(filename: string, content: string, type: string) { const url = URL.createObjectURL(new Blob([content], { type })); const anchor = document.createElement("a"); anchor.href = url; anchor.download = filename; anchor.click(); URL.revokeObjectURL(url); } /** End of a maintenance window ``minutes`` from now; 0 means open-ended. */ function maintenanceEnd(minutes: number): string | null { return minutes > 0 ? new Date(Date.now() + minutes * 60_000).toISOString() : null; } export default function App() { // The URL is the source of the initial navigation and filter state, so a // refresh, Back/Forward and shared links restore the same view. const [initialUrl] = useState(() => parseUrlState(window.location.hash)); const [services, setServices] = useState([]); const [loading, setLoading] = useState(true); const [lastUpdatedAt, setLastUpdatedAt] = useState(null); const [selectedId, setSelectedId] = useState(initialUrl.serviceId); const [busyId, setBusyId] = useState(null); const [busyAll, setBusyAll] = useState(false); const [error, setError] = useState(null); const [notice, setNotice] = useState(null); const [incidentSearch, setIncidentSearch] = useState(""); const [incidentStatusFilter, setIncidentStatusFilter] = useState("active"); const [suggestionSearch, setSuggestionSearch] = useState(""); const [suggestionConfidence, setSuggestionConfidence] = useState("actionable"); const [suggestionType, setSuggestionType] = useState("all"); const [suggestionLimit, setSuggestionLimit] = useState(30); const [changeLimit, setChangeLimit] = useState(30); const [reconcileConfirm, setReconcileConfirm] = useState(false); const [panel, setPanel] = useState(initialUrl.panel); const [form, setForm] = useState(emptyForm); const [editingId, setEditingId] = useState(null); // Management: hidden services, bulk selection, maintenance windows, notes. const [showHidden, setShowHidden] = useState(false); const [hiddenSnapshots, setHiddenSnapshots] = useState([]); const [bulkSelection, setBulkSelection] = useState([]); const [bulkBusy, setBulkBusy] = useState(false); const [maintenanceFormOpen, setMaintenanceFormOpen] = useState(false); const [maintenanceReason, setMaintenanceReason] = useState(""); const [maintenanceMinutes, setMaintenanceMinutes] = useState("60"); const [incidentNote, setIncidentNote] = useState(""); const [incidentBusy, setIncidentBusy] = useState(false); const [activityEvents, setActivityEvents] = useState([]); const [activityFamily, setActivityFamily] = useState(""); const [activityBusy, setActivityBusy] = useState(false); const [activityExhausted, setActivityExhausted] = useState(false); const [alertSettings, setAlertSettings] = useState(null); const [alertToken, setAlertToken] = useState(""); const [alertBusy, setAlertBusy] = useState(false); const [alertMessage, setAlertMessage] = useState(null); const [backups, setBackups] = useState(null); const [backupBusy, setBackupBusy] = useState(false); const [backupMessage, setBackupMessage] = useState(null); // Admin-token mode: reads are open, changes need the token for this tab. const [writeAuth, setWriteAuth] = useState<"none" | "admin_token" | "oidc">("none"); const [editUnlocked, setEditUnlocked] = useState(() => hasApiAccessToken()); const [unlockOpen, setUnlockOpen] = useState(false); const [navMoreOpen, setNavMoreOpen] = useState(false); const [unlockValue, setUnlockValue] = useState(""); const [unlockBusy, setUnlockBusy] = useState(false); const [unlockError, setUnlockError] = useState(null); const [formOpen, setFormOpen] = useState(false); const [history, setHistory] = useState([]); const [historyServiceId, setHistoryServiceId] = useState(null); const [availability, setAvailability] = useState< Record >({ 24: null, 168: null, 720: null }); const [incident, setIncident] = useState(null); const [overview, setOverview] = useState< import("./api").OverviewSummary | null >(null); const [semanticTopology, setSemanticTopology] = useState(null); const [events, setEvents] = useState([]); const [demo, setDemo] = useState(null); const [demoConfirm, setDemoConfirm] = useState(false); const [demoBusy, setDemoBusy] = useState(false); const [demoStep, setDemoStep] = useState(0); const [configText, setConfigText] = useState("version: 1\nservices: []\n"); const [configFormat, setConfigFormat] = useState<"yaml" | "json">("yaml"); const [configMode, setConfigMode] = useState<"merge" | "replace">("merge"); const [dockerHost, setDockerHost] = useState("unix:///var/run/docker.sock"); const [dockerCandidates, setDockerCandidates] = useState( [], ); const [dockerBusy, setDockerBusy] = useState(false); const [appopsUrl, setAppopsUrl] = useState(""); const [discoveryRun, setDiscoveryRun] = useState(null); const [discoveryStatus, setDiscoveryStatus] = useState(null); const [discoveryItems, setDiscoveryItems] = useState( [], ); const [discoverySuggestions, setDiscoverySuggestions] = useState< TopologySuggestion[] >([]); const [discoveryBusy, setDiscoveryBusy] = useState(false); const [probeRepair, setProbeRepair] = useState( null, ); const [editMode, setEditMode] = useState(false); const [graphListView, setGraphListView] = useState(false); const mainRef = useRef(null); const [showMiniMap, setShowMiniMap] = useState(false); const [edgeEvidence, setEdgeEvidence] = useState([]); const [providerStatuses, setProviderStatuses] = useState([]); const [topologySnapshots, setTopologySnapshots] = useState([]); const [topologyDiff, setTopologyDiff] = useState(null); const [selectedSnapshotId, setSelectedSnapshotId] = useState(initialUrl.snapshotId); const [snapshotCheckedAt, setSnapshotCheckedAt] = useState(0); const [selectedEdgeId, setSelectedEdgeId] = useState(initialUrl.edgeId); const [search, setSearch] = useState(initialUrl.filters.search); const [statusFilter, setStatusFilter] = useState( initialUrl.filters.status as FilterStatus, ); const [monitoringFilter, setMonitoringFilter] = useState( initialUrl.filters.monitoring as MonitoringFilter, ); const [groupFilter, setGroupFilter] = useState(initialUrl.filters.group); const [environmentFilter, setEnvironmentFilter] = useState(initialUrl.filters.environment); const [criticalityFilter, setCriticalityFilter] = useState(initialUrl.filters.criticality); const [domainFilter, setDomainFilter] = useState(initialUrl.filters.domain); const [serviceApplicationFilter, setServiceApplicationFilter] = useState( initialUrl.filters.application, ); const [lifecycleFilter, setLifecycleFilter] = useState(initialUrl.filters.lifecycle); const [focusMode, setFocusMode] = useState(false); const [blastRadius, setBlastRadius] = useState(false); const [topologyMode, setTopologyMode] = useState( initialUrl.filters.mode as TopologyMode, ); const [applicationFilter, setApplicationFilter] = useState("all"); const [componentScope, setComponentScope] = useState<{ label: string; memberIds: string[]; } | null>(null); const [topologyLocation, setTopologyLocation] = useState( initialUrl.topology, ); // Compatibility adapter for legacy non-semantic controls. Navigation state // itself remains the single TopologyLocation value above. const semanticScope = topologyLocation; const setSemanticScope = ( update: | Pick | ((scope: TopologyLocation) => Pick), ) => { setTopologyLocation((current) => { const next = typeof update === "function" ? update(current) : update; if (!next.domainId) return topologyRoot(); return next.applicationId ? applicationLocation(next.domainId, next.applicationId) : domainLocation(next.domainId); }); }; // The drawer covers part of the graph: open it for a deep link or an explicit // selection, not for the service the app auto-selects on load. const [inspectorOpen, setInspectorOpen] = useState(() => Boolean(initialUrl.serviceId || initialUrl.incidentId)); const [filtersOpen, setFiltersOpen] = useState(false); const [hoveredNodeId, setHoveredNodeId] = useState(null); const [selectedIncident, setSelectedIncident] = useState(null); const [incidentDetail, setIncidentDetail] = useState( null, ); const flowInstance = useRef | null>( null, ); const sidePanelRef = useRef(null); const demoFocusApplied = useRef(false); const [layoutPositions, setLayoutPositions] = useState< Record >({}); const [layoutRoutes, setLayoutRoutes] = useState< Record >({}); const refreshDiscovery = useCallback(async () => { try { const [status, items, suggestions, evidence, providers, snapshots] = await Promise.all([ api.discoveryStatus(), api.discoveryItems(), api.discoverySuggestions("open"), api.topologyEdges(), api.providers(), api.topologySnapshots(), ]); setDiscoveryStatus(status); setDiscoveryRun(status.current ?? status.last_completed); setDiscoveryItems(items); setDiscoverySuggestions(suggestions); setEdgeEvidence(evidence); setProviderStatuses(providers); setTopologySnapshots(snapshots); setSnapshotCheckedAt(Date.now()); if (!snapshots.length) setTopologyDiff(null); setSelectedSnapshotId((current) => current && snapshots.some((item) => item.id === current) ? current : snapshots[0]?.id ?? null, ); } catch (err) { // Discovery is an optional enrichment path. Keep the primary topology usable // when an older API or an unavailable source is encountered during rollout. setError( err instanceof Error ? err.message : "Detectiestatus laden mislukt", ); } }, []); useEffect(() => { if (!selectedSnapshotId) return; const index = topologySnapshots.findIndex((item) => item.id === selectedSnapshotId); if (index < 0) return; let active = true; void api.topologyDiff(selectedSnapshotId, topologySnapshots[index + 1]?.id) .then((diff) => { if (active) setTopologyDiff(diff); }) .catch(() => { if (active) setTopologyDiff(null); }); return () => { active = false; }; }, [selectedSnapshotId, topologySnapshots]); const refreshCore = useCallback(async () => { try { const semantic = api .semanticTopology() .then(setSemanticTopology) .catch(() => { // The component-level graph remains available while a rolling deploy // brings older API instances forward. setSemanticTopology(null); }); const [nextServices, nextIncident, nextDemo, nextOverview, nextEvents] = await Promise.all([ api.listServices(), api.incidents(), api.demoState(), api.overview(), api.events(30), ]); setServices(nextServices); setSelectedId((current) => current && !nextServices.some((item) => item.service.id === current) ? null : current, ); setIncident(nextIncident); setDemo(nextDemo); if (!nextDemo.active) { demoFocusApplied.current = false; } else if (!demoFocusApplied.current && nextDemo.root_cause_service_id) { setSelectedId(nextDemo.root_cause_service_id); setPanel("topology"); demoFocusApplied.current = true; } if (!nextDemo.active && nextIncident.candidates[0]) { setSelectedId((current) => current ?? nextIncident.candidates[0].service_id); } setOverview(nextOverview); setEvents(nextEvents); setError(null); setLastUpdatedAt(new Date()); await semantic; } catch (err) { setError( err instanceof Error ? err.message : "ServiceMap vernieuwen mislukt", ); } finally { setLoading(false); } }, []); const refreshProviders = useCallback(async () => { try { setProviderStatuses(await api.providers()); } catch { // Provider status is enrichment; the next full refresh retries it. } }, []); useEffect(() => { let active = true; void api .meta() .then((meta) => { if (active) setWriteAuth(meta.write_auth ?? "none"); }) .catch(() => undefined); const onAuthRequired = () => { setEditUnlocked(false); setUnlockOpen(true); }; window.addEventListener(AUTH_REQUIRED_EVENT, onAuthRequired); return () => { active = false; window.removeEventListener(AUTH_REQUIRED_EVENT, onAuthRequired); }; }, []); const unlockEditing = async (event: FormEvent) => { event.preventDefault(); setUnlockBusy(true); setUnlockError(null); try { await api.verifyWriteAccess(unlockValue); setApiAccessToken(unlockValue); setEditUnlocked(true); setUnlockOpen(false); setUnlockValue(""); setError(null); setNotice("Bewerken ontgrendeld voor dit tabblad."); } catch (err) { setUnlockError(err instanceof Error ? err.message : "Het token werd niet aanvaard"); } finally { setUnlockBusy(false); } }; const lockEditing = () => { setApiAccessToken(null); setEditUnlocked(false); setNotice("Bewerken vergrendeld."); }; /** Full reload: initial load, user mutations and recovery after a gap. */ const refresh = useCallback(async () => { await Promise.all([refreshCore(), refreshDiscovery()]); }, [refreshCore, refreshDiscovery]); // Bumped when the selected service's probe history may have changed, so the // history/availability reads no longer follow every topology refresh. const [historyRevision, setHistoryRevision] = useState(0); const selectedIdRef = useRef(null); useEffect(() => { selectedIdRef.current = selectedId; }, [selectedId]); const refreshersRef = useRef({ refreshCore, refreshDiscovery, refreshProviders }); useEffect(() => { refreshersRef.current = { refreshCore, refreshDiscovery, refreshProviders }; }, [refreshCore, refreshDiscovery, refreshProviders]); const schedulerRef = useRef(null); useEffect(() => { const scheduler = createRefreshScheduler(async ({ scopes, serviceIds }) => { const { refreshCore: core, refreshDiscovery: discovery, refreshProviders: providers } = refreshersRef.current; const tasks: Promise[] = []; if (scopes.has("core")) tasks.push(core()); if (scopes.has("discovery")) tasks.push(discovery()); else if (scopes.has("providers")) tasks.push(providers()); await Promise.all(tasks); const selected = selectedIdRef.current; if (scopes.has("history") && selected && serviceIds.has(selected)) { setHistoryRevision((value) => value + 1); } }); schedulerRef.current = scheduler; return () => { scheduler.dispose(); schedulerRef.current = null; }; }, []); const onRealtimeEvent = useCallback( (event: RealtimeEvent) => schedulerRef.current?.requestForEvent(event), [], ); const onRealtimeResync = useCallback( () => schedulerRef.current?.request(["core", "discovery", "history"], selectedIdRef.current), [], ); const realtimeStatus = useRealtimeEvents({ onEvent: onRealtimeEvent, onResync: onRealtimeResync, onFallback: onRealtimeResync, }); useEffect(() => { // This starts async API reads; refresh applies its state only after those reads settle. // eslint-disable-next-line react-hooks/set-state-in-effect void refresh(); }, [refresh]); useEffect(() => { if (selectedId || selectedEdgeId) sidePanelRef.current?.scrollTo({ top: 0 }); }, [selectedId, selectedEdgeId, demo?.active]); const selectedKnown = Boolean( selectedId && services.some((item) => item.service.id === selectedId), ); useEffect(() => { if (!selectedId || !selectedKnown) return; let active = true; void Promise.all([ api.history(selectedId, 48), api.availability(selectedId, 24), api.availability(selectedId, 168), api.availability(selectedId, 720), ]) .then(([nextHistory, day, week, month]) => { if (!active) return; setHistory(nextHistory); setAvailability({ 24: day, 168: week, 720: month }); setHistoryServiceId(selectedId); }) .catch((err) => { if (active) setError( err instanceof Error ? err.message : "Servicegeschiedenis laden mislukt", ); }); return () => { active = false; }; }, [selectedId, selectedKnown, historyRevision]); const groups = useMemo( () => [ ...new Set( services .map((item) => item.service.group) .filter(Boolean) as string[], ), ].sort(), [services], ); const applications = useMemo( () => [...new Set(services.map(applicationName))].sort(), [services], ); const semanticDomainByService = useMemo(() => { const names = new Map( (semanticTopology?.domains ?? []).map((item) => [item.id, item.name]), ); return new Map( (semanticTopology?.components ?? []).map((item) => [ item.service_id, names.get(item.domain_id) ?? null, ]), ); }, [semanticTopology]); const domains = useMemo( () => [ ...new Set( services .map( (item) => item.service.domain ?? semanticDomainByService.get(item.service.id), ) .filter(Boolean) as string[], ), ].sort(), [semanticDomainByService, services], ); const environments = useMemo( () => [ ...new Set( services .map((item) => item.service.environment) .filter(Boolean) as string[], ), ].sort(), [services], ); // Filters other than search/status, shared by the Services table and the // semantic topology (which applies search and status per node itself). const matchesAttributeFilters = useCallback( (snapshot: ServiceSnapshot) => (monitoringFilter === "all" || snapshot.service.monitoring_state === monitoringFilter) && (groupFilter === "all" || snapshot.service.group === groupFilter) && (environmentFilter === "all" || snapshot.service.environment === environmentFilter) && (criticalityFilter === "all" || snapshot.service.criticality === criticalityFilter) && (domainFilter === "all" || (snapshot.service.domain ?? semanticDomainByService.get(snapshot.service.id)) === domainFilter) && (serviceApplicationFilter === "all" || applicationName(snapshot) === serviceApplicationFilter) && (lifecycleFilter === "all" || snapshot.service.lifecycle === lifecycleFilter), [ monitoringFilter, groupFilter, environmentFilter, criticalityFilter, domainFilter, serviceApplicationFilter, lifecycleFilter, semanticDomainByService, ], ); const attributeFiltersActive = [ monitoringFilter, groupFilter, environmentFilter, criticalityFilter, domainFilter, serviceApplicationFilter, lifecycleFilter, ].some((value) => value !== "all"); const filterSnapshots = useCallback( (list: ServiceSnapshot[]) => { const needle = search.toLowerCase(); return list.filter((snapshot) => { const name = `${snapshot.service.name} ${snapshot.service.description ?? ""} ${snapshot.service.tags.join(" ")}`.toLowerCase(); return ( (!search || name.includes(needle)) && matchesStatusFilter(effectiveStatus(snapshot), statusFilter) && matchesAttributeFilters(snapshot) ); }); }, [search, statusFilter, matchesAttributeFilters], ); const filteredServices = useMemo(() => filterSnapshots(services), [services, filterSnapshots]); // "Show hidden & ignored" lists every service, including the ones the // default views exclude, so they can be found and restored. const tableServices = useMemo( () => (showHidden ? filterSnapshots(hiddenSnapshots) : filteredServices), [showHidden, hiddenSnapshots, filteredServices, filterSnapshots], ); useEffect(() => { if (!showHidden) return; let active = true; void api .listServices(true) .then((list) => { if (active) setHiddenSnapshots(list); }) .catch(() => undefined); return () => { active = false; }; }, [showHidden, services]); const serviceById = useMemo( () => new Map(services.map((item) => [item.service.id, item])), [services], ); const directDependents = useMemo(() => { const result = new Map(); for (const snapshot of services) for (const dependencyId of snapshot.service.depends_on) result.set(dependencyId, [ ...(result.get(dependencyId) ?? []), snapshot.service.id, ]); return result; }, [services]); const relatedIds = useMemo(() => { if (!selectedId || !focusMode) return null; const result = new Set([selectedId]); const visit = (id: string, depth: number) => { if (depth <= 0) return; const service = services.find((item) => item.service.id === id)?.service; for (const dependencyId of service?.depends_on ?? []) { result.add(dependencyId); visit(dependencyId, depth - 1); } for (const dependentId of directDependents.get(id) ?? []) { result.add(dependentId); visit(dependentId, depth - 1); } }; visit(selectedId, 2); return result; }, [selectedId, focusMode, services, directDependents]); const impactIds = useMemo( () => new Set( demo?.affected_service_ids ?? selectedIncident?.affected_service_ids ?? [], ), [demo?.affected_service_ids, selectedIncident?.affected_service_ids], ); const graphServices = useMemo(() => { const base = filteredServices.filter( (item) => !relatedIds || relatedIds.has(item.service.id), ); if (!blastRadius) return base; const allowed = new Set( [ demo?.root_cause_service_id ?? selectedIncident?.root_service_id, ...impactIds, ].filter(Boolean), ); return base.filter((item) => allowed.has(item.service.id)); }, [ filteredServices, relatedIds, blastRadius, demo?.root_cause_service_id, selectedIncident?.root_service_id, impactIds, ]); const componentServices = useMemo(() => { if (topologyLocation.level !== "components") return graphServices; if (componentScope) { const members = new Set(componentScope.memberIds); return graphServices.filter((item) => members.has(item.service.id)); } return applicationFilter !== "all" ? graphServices.filter( (item) => applicationName(item) === applicationFilter, ) : graphServices; }, [topologyLocation.level, applicationFilter, componentScope, graphServices]); const activeGraphServices = topologyLocation.level === "components" ? componentServices : graphServices; const rootCauseId = demo?.root_cause_service_id ?? selectedIncident?.root_service_id ?? null; const legacyNodes = useMemo( () => topologyLocation.level === "components" ? topologyLayout(activeGraphServices, rootCauseId, impactIds) : applicationTopologyLayout( activeGraphServices, rootCauseId, impactIds, ), [topologyLocation.level, activeGraphServices, rootCauseId, impactIds], ); const legacyEdges = useMemo( () => topologyLocation.level !== "components" ? applicationEdges( activeGraphServices, topologyMode, impactIds, rootCauseId, ) : activeGraphServices.flatMap((snapshot) => snapshot.service.depends_on .filter((dependencyId) => activeGraphServices.some( (item) => item.service.id === dependencyId, ), ) .map((dependencyId) => ({ id: `${dependencyId}-${snapshot.service.id}`, source: dependencyId, target: snapshot.service.id, animated: effectiveStatus(snapshot) !== "healthy", className: `edge-${effectiveStatus(snapshot)}${blastRadius && !impactIds.has(snapshot.service.id) ? " edge-dimmed" : ""}`, markerEnd: { type: MarkerType.ArrowClosed }, })), ), [ topologyLocation.level, activeGraphServices, impactIds, blastRadius, rootCauseId, topologyMode, ], ); const semanticView: SemanticView = topologyLocation.level; const semanticGraph = useMemo( () => semanticTopology ? semanticTopologyGraph( semanticTopology, semanticView, semanticView === "components" ? topologyLocation.applicationId : topologyLocation.domainId, topologyMode === "impact" || blastRadius, search, statusFilter, { serviceFacts: (id) => { const item = serviceById.get(id); return item ? { criticality: item.service.criticality, flapping: item.flapping } : undefined; }, serviceFilter: attributeFiltersActive ? (id) => { const item = serviceById.get(id); return item ? matchesAttributeFilters(item) : false; } : undefined, }, ) : null, [ semanticTopology, semanticView, topologyLocation.domainId, topologyLocation.applicationId, topologyMode, blastRadius, search, statusFilter, serviceById, attributeFiltersActive, matchesAttributeFilters, ], ); const graphNodes = semanticGraph?.nodes ?? legacyNodes; const baseEdges = semanticGraph?.edges ?? legacyEdges; // Positions while a node is being dragged; cleared once the saved layout // comes back from the server. const [dragPositions, setDragPositions] = useState>({}); const onNodesChange = useCallback((changes: NodeChange[]) => { const moved: Record = {}; for (const change of changes) { if (change.type === "position" && change.position) moved[change.id] = change.position; } if (Object.keys(moved).length) setDragPositions((current) => ({ ...current, ...moved })); }, []); // Nodes drawn somewhere other than the automatic layout: their ELK routes // point at the old place, so edges touching them use a plain path. const movedNodeIds = useMemo(() => { const ids = new Set(Object.keys(dragPositions)); for (const item of services) { if (item.service.layout_pinned && item.service.layout_x != null) ids.add(item.service.id); } return ids; }, [dragPositions, services]); const edges = useMemo( () => baseEdges.map((edge) => { const touchesSelected = Boolean( selectedId && (edge.source === selectedId || edge.target === selectedId), ); const touchesHovered = Boolean( hoveredNodeId && (edge.source === hoveredNodeId || edge.target === hoveredNodeId), ); const incidentPath = Boolean( rootCauseId && (edge.source === rootCauseId || edge.target === rootCauseId) && (impactIds.has(edge.source) || impactIds.has(edge.target)), ); return { ...edge, type: "living", data: { relation: edge.className?.includes("routes") ? "routes_to" : edge.className?.includes("review") || edge.className?.includes("communicates") ? "review" : "depends_on", selected: edge.id === selectedEdgeId, route: movedNodeIds.has(edge.source) || movedNodeIds.has(edge.target) ? undefined : layoutRoutes[edge.id], signal: edge.id === selectedEdgeId || touchesSelected || touchesHovered || incidentPath, // Hovering a node fades every relation that does not touch it. dimmed: Boolean(hoveredNodeId) && !touchesHovered, }, }; }), [ baseEdges, hoveredNodeId, impactIds, layoutRoutes, movedNodeIds, rootCauseId, selectedEdgeId, selectedId, ], ); const graphLayoutKey = useMemo( () => topologyStructureKey(graphNodes, edges), [graphNodes, edges], ); const autoArrangeGraph = async () => { const layout = await arrangeTopology(graphNodes, edges); setLayoutPositions(layout.positions); setLayoutRoutes(layout.routes); }; useEffect(() => { if (!graphNodes.length) return; let active = true; void arrangeTopology(graphNodes, edges).then((layout) => { if (!active) return; setLayoutPositions(layout.positions); setLayoutRoutes(layout.routes); }); return () => { active = false; }; // Layout work is keyed only by structure; health updates retain positions. // eslint-disable-next-line react-hooks/exhaustive-deps }, [graphLayoutKey]); const nodes = useMemo( () => graphNodes.map((node): ServiceNode => { const service = serviceById.get(node.id)?.service; // An operator-pinned position wins over the automatic layout. const pinned = service?.layout_pinned && service.layout_x != null && service.layout_y != null ? { x: service.layout_x, y: service.layout_y } : undefined; return { ...node, ariaLabel: nodeAriaLabel(node.data), position: dragPositions[node.id] ?? pinned ?? layoutPositions[node.id] ?? node.position, }; }), [graphNodes, layoutPositions, dragPositions, serviceById], ); function openGraphNode(node: ServiceNode | Node) { setSelectedEdgeId(null); const data = node.data as ServiceNodeData; if (data.nodeKind === "domain") { setTopologyLocation(domainLocation(node.id)); setComponentScope(null); setTopologyMode("landscape"); } else if ( data.nodeKind === "application" || node.id.startsWith("app:") ) { const members = data.memberIds ?? []; setComponentScope({ label: data.name, memberIds: members }); setTopologyLocation(applicationLocation(data.domainId ?? null, node.id)); setApplicationFilter("all"); setTopologyMode("landscape"); const member = members.find((id) => id === rootCauseId) ?? members[0]; if (member) setSelectedId(member); } else setSelectedId(node.id); setInspectorOpen(true); setPanel("topology"); } function onGraphKeyDown(event: ReactKeyboardEvent) { // React Flow focuses node wrappers (Tab) but Enter/Space only toggles // its internal selection; open the node like a click does. if (event.key !== "Enter" && event.key !== " ") return; const target = (event.target as HTMLElement).closest(".react-flow__node"); const node = target?.dataset.id ? nodes.find((item) => item.id === target.dataset.id) : undefined; if (!node) return; event.preventDefault(); openGraphNode(node); } const selected = services.find((item) => item.service.id === selectedId) ?? null; const hasCurrentHistory = Boolean( selectedId && historyServiceId === selectedId, ); const selectedEdge = edgeEvidence.find((item) => item.id === selectedEdgeId) ?? null; const selectedIsRootCause = Boolean( selected && (demo?.root_cause_service_id === selected.service.id || selectedIncident?.root_service_id === selected.service.id), ); const counts = useMemo( () => services.reduce( (result, item) => { const key = effectiveStatus(item); result[key] = (result[key] ?? 0) + 1; return result; }, {} as Record, ), [services], ); const monitoredCount = useMemo( () => services.filter((item) => ["active_probe", "docker_health", "appops_observation", "observed"].includes( item.service.monitoring_state, ), ).length, [services], ); const resolvedComponentCount = useMemo( () => semanticTopology?.components.filter( (item) => !["unknown", "unmonitored"].includes(item.direct_status), ).length ?? monitoredCount, [monitoredCount, semanticTopology], ); const unresolvedComponentCount = useMemo( () => semanticTopology?.components.filter((item) => ["unknown", "unmonitored"].includes(item.direct_status), ).length ?? Math.max(0, services.length - monitoredCount), [monitoredCount, semanticTopology, services.length], ); const coverageCounts = useMemo( () => services.reduce>((result, item) => { const state = item.service.monitoring_state; result[state] = (result[state] ?? 0) + 1; return result; }, {}), [services], ); const visibleSuggestions = useMemo( () => filterSuggestions(discoverySuggestions, { query: suggestionSearch, confidence: suggestionConfidence, type: suggestionType, }), [discoverySuggestions, suggestionSearch, suggestionConfidence, suggestionType], ); const visibleIncidents = useMemo( () => (incident?.incidents ?? []).filter((item) => (incidentStatusFilter === "all" || (incidentStatusFilter === "active" ? item.status !== "resolved" : item.status === incidentStatusFilter)) && (!incidentSearch.trim() || `${item.title} ${item.root_service_name} ${item.root_cause_reason}` .toLowerCase().includes(incidentSearch.trim().toLowerCase())), ), [incident, incidentSearch, incidentStatusFilter], ); const selectedDomain = semanticTopology?.domains.find( (item) => item.id === topologyLocation.domainId, ); const selectedApplication = semanticTopology?.applications.find( (item) => item.id === topologyLocation.applicationId, ); const activeTopologyFilters: Array<{ label: string; value: string; clear: () => void; }> = [ { label: "Status", value: statusFilter, clear: () => setStatusFilter("all") }, { label: "Bewaking", value: monitoringFilter, clear: () => setMonitoringFilter("all") }, { label: "Domein", value: domainFilter, clear: () => setDomainFilter("all") }, { label: "Applicatie", value: serviceApplicationFilter, clear: () => setServiceApplicationFilter("all") }, { label: "Omgeving", value: environmentFilter, clear: () => setEnvironmentFilter("all") }, { label: "Kritiek", value: criticalityFilter, clear: () => setCriticalityFilter("all") }, { label: "Levenscyclus", value: lifecycleFilter, clear: () => setLifecycleFilter("all") }, ]; useEffect(() => { const onKeyDown = (event: KeyboardEvent) => { const target = event.target as HTMLElement | null; if ( !target || panel !== "topology" || ["INPUT", "TEXTAREA", "SELECT"].includes(target.tagName) || target.isContentEditable || isTopologyRoot(topologyLocation) ) return; if (event.key === "Escape" || event.key === "Backspace") { event.preventDefault(); setTopologyLocation((location) => topologyUp(location)); } }; window.addEventListener("keydown", onKeyDown); return () => window.removeEventListener("keydown", onKeyDown); }, [panel, topologyLocation]); // Fit once per view (navigation, mode, demo) after its layout is ready. // Health refreshes and services arriving over SSE keep the user's zoom. const fittedViewKey = useRef(null); const viewKey = JSON.stringify([ panel, topologyLocation.level, topologyLocation.domainId, topologyLocation.applicationId, topologyMode, focusMode, blastRadius, Boolean(demo?.active), ]); const layoutReady = graphNodes.length > 0 && graphNodes.every((node) => layoutPositions[node.id]); useEffect(() => { if (panel !== "topology" || !layoutReady || !flowInstance.current) return; if (fittedViewKey.current === viewKey) return; fittedViewKey.current = viewKey; const frame = window.requestAnimationFrame(() => flowInstance.current?.fitView({ padding: 0.16, duration: demo?.active ? 240 : 0, }), ); return () => window.cancelAnimationFrame(frame); }, [viewKey, layoutReady, panel, demo?.active]); const clearMessages = () => { setError(null); setNotice(null); }; const resetForm = () => { setEditingId(null); setForm(emptyForm()); setFormOpen(false); }; const payloadFromForm = (): ServiceInput => { const common = { name: form.name, kind: form.kind, depends_on: form.depends_on, description: form.description, tags: form.tags .split(",") .map((item) => item.trim()) .filter(Boolean), group: form.group, environment: form.environment, criticality: form.criticality, interval_seconds: form.interval_seconds, timeout_seconds: form.timeout_seconds, retries: form.retries, failure_threshold: form.failure_threshold, recovery_threshold: form.recovery_threshold, availability_target: form.availability_target, enabled: form.enabled, monitoring_enabled: form.monitoring_enabled, application: form.application || undefined, domain: form.domain || undefined, component_role: form.component_role, application_locked: form.application_locked, domain_locked: form.domain_locked, component_role_locked: form.component_role_locked, source_type: form.source_type, source_ref: form.source_ref, category: form.category, visibility: form.visibility, lifecycle: form.lifecycle, first_seen_at: form.first_seen_at, last_seen_at: form.last_seen_at, last_discovery_status: form.last_discovery_status, container_image: form.container_image, compose_project: form.compose_project, layout_x: form.layout_x, layout_y: form.layout_y, layout_pinned: form.layout_pinned, maintenance_enabled: form.maintenance_enabled, maintenance_reason: form.maintenance_reason, }; // Endpoint fields of the other kinds are cleared explicitly, so switching // kind on an existing service cannot leave a stale URL or port behind. if (form.kind === "http") return { ...common, kind: "http", url: form.url, host: undefined, port: undefined }; if (form.kind === "dns") return { ...common, kind: "dns", host: form.host, url: undefined, port: undefined }; const port = Number(form.port); return { ...common, kind: form.kind, host: form.host, url: undefined, // An empty field must not become port 0 (or NaN, serialized as null). port: form.port === undefined || !Number.isFinite(port) ? undefined : port, }; }; const payloadFromService = ( service: ServiceSnapshot["service"], overrides: Partial = {}, ): ServiceInput => ({ name: service.name, kind: service.kind, url: service.url ?? undefined, host: service.host ?? undefined, port: service.port ?? undefined, depends_on: [...service.depends_on], description: service.description ?? undefined, tags: [...service.tags], group: service.group ?? undefined, environment: service.environment ?? undefined, owner: service.owner ?? undefined, enabled: service.enabled, monitoring_enabled: service.monitoring_enabled, application: service.application ?? undefined, domain: service.domain ?? undefined, component_role: service.component_role, application_locked: service.application_locked, domain_locked: service.domain_locked, component_role_locked: service.component_role_locked, criticality: service.criticality, category: service.category, visibility: service.visibility, lifecycle: service.lifecycle, source_type: service.source_type ?? undefined, source_ref: service.source_ref ?? undefined, first_seen_at: service.first_seen_at ?? undefined, last_seen_at: service.last_seen_at ?? undefined, last_discovery_status: service.last_discovery_status ?? undefined, container_image: service.container_image ?? undefined, compose_project: service.compose_project ?? undefined, layout_x: service.layout_x ?? undefined, layout_y: service.layout_y ?? undefined, layout_pinned: service.layout_pinned, interval_seconds: service.interval_seconds ?? undefined, timeout_seconds: service.timeout_seconds ?? undefined, retries: service.retries ?? undefined, failure_threshold: service.failure_threshold, recovery_threshold: service.recovery_threshold, expected_status_min: service.expected_status_min ?? undefined, expected_status_max: service.expected_status_max ?? undefined, availability_target: service.availability_target ?? undefined, maintenance_enabled: service.maintenance_enabled, maintenance_reason: service.maintenance_reason ?? undefined, ...overrides, }); const submit = async (event: FormEvent) => { event.preventDefault(); clearMessages(); try { // Updates replace the whole record. Start from the stored service so // fields the form does not show (owner, expected status range, …) are // kept instead of silently reset. const existing = editingId ? services.find((item) => item.service.id === editingId)?.service : undefined; const payload = existing ? payloadFromService(existing, payloadFromForm()) : payloadFromForm(); const service = editingId ? await api.updateService(editingId, payload) : await api.createService(payload); setSelectedId(service.id); setNotice(editingId ? "Service bijgewerkt." : "Service toegevoegd."); resetForm(); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Service opslaan mislukt"); } }; const beginEdit = (snapshot: ServiceSnapshot) => { const service = snapshot.service; setEditingId(service.id); setForm({ name: service.name, kind: service.kind, url: service.url ?? "", host: service.host ?? "", port: service.port ?? undefined, depends_on: [...service.depends_on], tags: service.tags.join(", "), group: service.group ?? "", environment: service.environment ?? "", application: service.application ?? "", domain: service.domain ?? "", component_role: service.component_role, application_locked: service.application_locked, domain_locked: service.domain_locked, component_role_locked: service.component_role_locked, criticality: service.criticality, category: service.category, visibility: service.visibility, lifecycle: service.lifecycle, description: service.description ?? "", interval_seconds: service.interval_seconds ?? undefined, timeout_seconds: service.timeout_seconds ?? undefined, retries: service.retries ?? undefined, failure_threshold: service.failure_threshold, recovery_threshold: service.recovery_threshold, availability_target: service.availability_target ?? undefined, enabled: service.enabled, monitoring_enabled: service.monitoring_enabled, source_type: service.source_type ?? undefined, source_ref: service.source_ref ?? undefined, first_seen_at: service.first_seen_at ?? undefined, last_seen_at: service.last_seen_at ?? undefined, last_discovery_status: service.last_discovery_status ?? undefined, container_image: service.container_image ?? undefined, compose_project: service.compose_project ?? undefined, maintenance_enabled: service.maintenance_enabled, maintenance_reason: service.maintenance_reason ?? undefined, layout_x: service.layout_x ?? undefined, layout_y: service.layout_y ?? undefined, layout_pinned: service.layout_pinned, }); setFormOpen(true); setInspectorOpen(true); setPanel("services"); }; const probe = async (serviceId: string) => { clearMessages(); setBusyId(serviceId); try { await api.probeService(serviceId); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Controle mislukt"); } finally { setBusyId(null); } }; const probeAll = async () => { clearMessages(); setBusyAll(true); try { const result = await api.probeAll(); setNotice(`${result.completed}/${result.requested} controles voltooid.`); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Bulkcontrole mislukt"); } finally { setBusyAll(false); } }; const removeSelected = async () => { if (!selected) return; const dependents = services .filter((item) => item.service.depends_on.includes(selected.service.id)) .map((item) => item.service.name); const impact = dependents.length ? ` ${dependents.length} service(s) zijn ervan afhankelijk en verliezen die afhankelijkheid: ${dependents.join(", ")}.` : ""; if ( !window.confirm( `${selected.service.name} verwijderen?${impact} De controlegeschiedenis wordt ook verwijderd. Dit kan niet ongedaan worden gemaakt.`, ) ) return; clearMessages(); try { await api.deleteService(selected.service.id); setSelectedId(null); setNotice(`${selected.service.name} verwijderd.`); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Verwijderen mislukt"); } }; const focusDemo = (result: DemoState) => { setSelectedId(result.root_cause_service_id); // The demo story starts at the root cause, so show it in the inspector. setInspectorOpen(true); setDemoStep(0); setTopologyLocation(topologyRoot()); setTopologyMode("landscape"); setBlastRadius(false); setPanel("topology"); demoFocusApplied.current = true; }; const startDemo = async () => { clearMessages(); setDemoBusy(true); try { const result = await api.loadDemo(); setDemoConfirm(false); await refresh(); focusDemo(result); } catch (err) { setError(err instanceof Error ? err.message : "Demo laden mislukt"); } finally { setDemoBusy(false); } }; const loadDemo = async () => { clearMessages(); if (demo?.active) { await resetDemo(); return; } if (services.length) { setDemoConfirm(true); return; } await startDemo(); }; const resetDemo = async () => { clearMessages(); setDemoBusy(true); try { const result = await api.resetDemo(); await refresh(); focusDemo(result); } catch (err) { setError(err instanceof Error ? err.message : "Demo opnieuw starten mislukt"); } finally { setDemoBusy(false); } }; const exitDemo = async () => { clearMessages(); setDemoBusy(true); try { const result = await api.exitDemo(); demoFocusApplied.current = false; setDemoStep(0); setSelectedId(null); setNotice( result.restored ? "Demo afgesloten. Je vorige topologie is hersteld." : "Geen actieve demosessie.", ); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Demo afsluiten mislukt"); } finally { setDemoBusy(false); } }; const setDemoWalkthroughStep = (step: number) => { setDemoStep(step); setPanel("topology"); setInspectorOpen(true); if (step === 0) { setTopologyLocation(topologyRoot()); setTopologyMode("landscape"); setBlastRadius(false); return; } if (step === 1) { const dataDomain = semanticTopology?.domains.find( (item) => item.name === "Data", ); if (dataDomain) setTopologyLocation(domainLocation(dataDomain.id)); setTopologyMode("landscape"); setBlastRadius(false); return; } if (step === 2) { setTopologyLocation(topologyRoot()); setTopologyMode("impact"); setBlastRadius(true); return; } setSelectedId(demo?.root_cause_service_id ?? null); setTopologyLocation(topologyRoot()); setTopologyMode("impact"); setBlastRadius(true); }; const exportConfig = async (format: "yaml" | "json") => { clearMessages(); try { const content = await api.exportConfig(format); downloadText( `servicemap.${format}`, content, format === "json" ? "application/json" : "application/yaml", ); } catch (err) { setError(err instanceof Error ? err.message : "Exporteren mislukt"); } }; const importConfig = async () => { if ( configMode === "replace" && !window.confirm( `Vervangen verwijdert alle ${services.length} huidige services, samen met elk incident en elke gebeurtenis, ` + "en houdt alleen de services uit dit document over. Dit kan niet ongedaan worden gemaakt. Doorgaan?", ) ) return; clearMessages(); try { const result = await api.importConfig( configText, configFormat, configMode, ); setNotice( `Configuratie toegepast: ${result.created} aangemaakt, ${result.updated} bijgewerkt.`, ); setSelectedId(null); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Importeren mislukt"); } }; const discoverDocker = async () => { clearMessages(); setDockerBusy(true); try { const result = await api.discoverDocker(dockerHost); setDockerCandidates(result.candidates); setNotice( `${result.candidates.length} Docker-containers gevonden om na te kijken.`, ); } catch (err) { setError(err instanceof Error ? err.message : "Docker-detectie mislukt"); } finally { setDockerBusy(false); } }; const runProductionDiscovery = async () => { clearMessages(); setDiscoveryBusy(true); try { const result: DiscoveryResult = await api.runDiscovery( dockerHost, appopsUrl || undefined, false, ); setDiscoveryRun(result.run); setDiscoveryItems(result.observations); setDiscoverySuggestions( result.suggestions.filter((item) => item.status === "open"), ); setDockerCandidates(result.candidates); setDiscoveryStatus({ current: null, last_completed: result.run, active: false, }); setNotice( `Detectie klaar: ${result.run.diff.new} nieuw, ${result.run.diff.changed} gewijzigd, ${result.run.diff.missing} ontbrekend, ${result.run.diff.new_suggestions} nieuwe voorstellen.`, ); await refreshDiscovery(); } catch (err) { setError( err instanceof Error ? err.message : "Productiedetectie mislukt", ); } finally { setDiscoveryBusy(false); } }; const reconcileProduction = async () => { clearMessages(); setDiscoveryBusy(true); try { const result = await api.reconcileDiscovery(discoveryRun?.id, true); setReconcileConfirm(false); setDiscoveryRun(result.run); setNotice( `Canonieke topologie bijgewerkt: ${result.created} services aangemaakt, ${result.updated} gewijzigd, ${result.accepted_relations} relaties met hoge zekerheid aanvaard.`, ); await refresh(); } catch (err) { setError( err instanceof Error ? err.message : "Detectie verwerken mislukt", ); } finally { setDiscoveryBusy(false); } }; const repairDiscoveredProbes = async (dryRun: boolean) => { clearMessages(); setDiscoveryBusy(true); try { const report = await api.repairDiscoveredProbes(dryRun, discoveryRun?.id); setProbeRepair(report); setNotice( dryRun ? `Voorbeeld controleveiligheid: ${report.changed} services zouden wijzigen; ${report.disabled_unsafe} onveilige controles zouden worden uitgeschakeld.` : `Controleveiligheid toegepast: ${report.changed} services bijgewerkt; ${report.resolved_incidents} valse incidenten opgelost.`, ); if (!dryRun) await refresh(); } catch (err) { setError( err instanceof Error ? err.message : "Gevonden controles herstellen mislukt", ); } finally { setDiscoveryBusy(false); } }; const reviewSuggestion = async ( suggestionId: string, action: "accept" | "reject", ) => { clearMessages(); setDiscoveryBusy(true); try { if (action === "accept") await api.acceptSuggestion(suggestionId); else await api.rejectSuggestion(suggestionId); await refresh(); setNotice( action === "accept" ? "Detectievoorstel aanvaard." : "Detectievoorstel afgewezen.", ); } catch (err) { setError( err instanceof Error ? err.message : "Detectievoorstel bijwerken mislukt", ); } finally { setDiscoveryBusy(false); } }; const prefillDockerCandidate = ( candidate: DockerCandidate, suggestion = candidate.suggestions[0], ) => { if (!suggestion) return; setEditingId(null); setForm({ ...emptyForm(), name: suggestion.name, kind: suggestion.kind, url: suggestion.url ?? "", host: suggestion.host ?? "", port: suggestion.port ?? undefined, group: suggestion.group ?? "", category: suggestion.category, depends_on: [], tags: "docker-discovery", source_type: suggestion.source_type ?? "docker", source_ref: suggestion.stable_source_ref ?? suggestion.source_ref ?? `docker:${candidate.container_id}`, }); setFormOpen(true); setPanel("services"); setNotice( "Docker-voorstel overgenomen in het serviceformulier. Kijk het na voor je opslaat.", ); }; const persistNodePosition = async (node: ServiceNode) => { const snapshot = services.find((item) => item.service.id === node.id); if (!snapshot || !editMode) return; try { await api.updateService( node.id, payloadFromService(snapshot.service, { layout_x: node.position.x, layout_y: node.position.y, layout_pinned: true, }), ); setNotice(`Positie van ${snapshot.service.name} opgeslagen.`); await refresh(); setDragPositions((current) => { const next = { ...current }; delete next[node.id]; return next; }); } catch (err) { setError( err instanceof Error ? err.message : "Positie opslaan mislukt", ); } }; const createManualEdge = async (connection: Connection) => { if ( !editMode || !connection.source || !connection.target || connection.source === connection.target ) return; clearMessages(); try { // Edges render dependency -> dependent, so a connection drawn from A to // B means "B depends on A": the new arrow appears exactly as drawn. const dependency = services.find( (item) => item.service.id === connection.source, )?.service; const dependent = services.find( (item) => item.service.id === connection.target, )?.service; if (!dependent || !dependency) return; await api.createEdge({ source_service_id: dependent.id, target_service_id: dependency.id, relation_type: "depends_on", lock: true, explanation: "Handmatige afhankelijkheid aangemaakt in de bewerkmodus van de topologie", }); setNotice(`${dependent.name} is nu afhankelijk van ${dependency.name}.`); await refresh(); } catch (err) { setError( err instanceof Error ? err.message : "Afhankelijkheid aanmaken mislukt", ); } }; const handleEdgeAction = async ( action: "confirm" | "reject" | "lock" | "remove", ) => { if (!selectedEdgeId) return; if ( (action === "remove" || action === "reject") && !window.confirm( action === "remove" ? "Deze relatie uit de topologie verwijderen? Gezondheid wordt er dan niet meer langs doorgegeven." : "Deze relatie afwijzen? Ze wordt uit de topologie verwijderd en niet opnieuw voorgesteld.", ) ) return; clearMessages(); try { await api.edgeAction(selectedEdgeId, action); setSelectedEdgeId(null); await refresh(); const label = { confirm: "confirmed", reject: "rejected", lock: "locked", remove: "removed", }[action]; setNotice(`Relatie ${label}.`); } catch (err) { setError( err instanceof Error ? err.message : "Relatie bijwerken mislukt", ); } }; const toggleDependency = (dependencyId: string) => setForm((current) => ({ ...current, depends_on: current.depends_on.includes(dependencyId) ? current.depends_on.filter((item) => item !== dependencyId) : [...current.depends_on, dependencyId], })); const openIncident = async (item: IncidentRecord) => { setSelectedIncident(item); setSelectedId(item.root_service_id); setPanel("incidents"); try { setIncidentDetail(await api.incident(item.id)); } catch (err) { setError( err instanceof Error ? err.message : "Incidenttijdlijn laden mislukt", ); } }; // --- URL synchronisation ------------------------------------------------- const [pendingIncidentId, setPendingIncidentId] = useState( initialUrl.incidentId, ); const urlState: UrlState = useMemo( () => ({ panel, serviceId: selectedId, edgeId: selectedEdgeId, incidentId: selectedIncident?.id ?? pendingIncidentId, // The latest snapshot is selected automatically; it only belongs in a // link when the Changes workspace is open. snapshotId: panel === "changes" ? selectedSnapshotId : null, topology: topologyLocation, filters: { search, status: statusFilter, monitoring: monitoringFilter, group: groupFilter, environment: environmentFilter, criticality: criticalityFilter, domain: domainFilter, application: serviceApplicationFilter, lifecycle: lifecycleFilter, mode: topologyMode, }, }), [ panel, selectedId, selectedEdgeId, selectedIncident, pendingIncidentId, selectedSnapshotId, topologyLocation, search, statusFilter, monitoringFilter, groupFilter, environmentFilter, criticalityFilter, domainFilter, serviceApplicationFilter, lifecycleFilter, topologyMode, ], ); const lastNavigationKey = useRef(navigationKey(initialUrl)); useEffect(() => { const hash = serializeUrlState(urlState); if (hash === window.location.hash) return; const key = navigationKey(urlState); if (key !== lastNavigationKey.current) window.history.pushState(null, "", hash); else window.history.replaceState(null, "", hash); lastNavigationKey.current = key; }, [urlState]); useEffect(() => { const onPopState = () => { const next = parseUrlState(window.location.hash); lastNavigationKey.current = navigationKey(next); setPanel(next.panel); setSelectedId(next.serviceId); setSelectedEdgeId(next.edgeId); setSelectedSnapshotId(next.snapshotId); setTopologyLocation(next.topology); setSearch(next.filters.search); setStatusFilter(next.filters.status as FilterStatus); setMonitoringFilter(next.filters.monitoring as MonitoringFilter); setGroupFilter(next.filters.group); setEnvironmentFilter(next.filters.environment); setCriticalityFilter(next.filters.criticality); setDomainFilter(next.filters.domain); setServiceApplicationFilter(next.filters.application); setLifecycleFilter(next.filters.lifecycle); setTopologyMode(next.filters.mode as TopologyMode); if (!next.incidentId) { setSelectedIncident(null); setIncidentDetail(null); } setPendingIncidentId(next.incidentId); }; window.addEventListener("popstate", onPopState); return () => window.removeEventListener("popstate", onPopState); }, []); // An incident named in the URL opens once the incident journal is loaded. const resolvePendingIncident = async (record: IncidentRecord | undefined) => { setPendingIncidentId(null); if (record && selectedIncident?.id !== record.id) await openIncident(record); }; useEffect(() => { if (!pendingIncidentId || !incident) return; // Hydrating external state (an incident id from the URL) once its data // has loaded is exactly what this effect is for. // eslint-disable-next-line react-hooks/set-state-in-effect void resolvePendingIncident(incident.incidents.find((item) => item.id === pendingIncidentId)); // resolvePendingIncident only closes over stable setters and the current selection. // eslint-disable-next-line react-hooks/exhaustive-deps }, [pendingIncidentId, incident]); const acknowledge = async () => { if (!selectedIncident) return; try { const detail = await api.acknowledgeIncident(selectedIncident.id); setSelectedIncident(detail.incident); setIncidentDetail(detail); await refresh(); } catch (err) { setError( err instanceof Error ? err.message : "Incident bevestigen mislukt", ); } }; const toggleMaintenance = async () => { if (!selected) return; if (!selected.service.maintenance_enabled) { setMaintenanceFormOpen(true); return; } try { await api.maintenance(selected.service.id, false); await refresh(); } catch (err) { setError( err instanceof Error ? err.message : "Onderhoudsstatus wijzigen mislukt", ); } }; const startMaintenance = async (event: FormEvent) => { event.preventDefault(); if (!selected) return; const minutes = Number(maintenanceMinutes); const until = maintenanceEnd(minutes); try { await api.maintenance( selected.service.id, true, maintenanceReason.trim() || "Gepland onderhoud", until, ); setMaintenanceFormOpen(false); setMaintenanceReason(""); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Onderhoud starten mislukt"); } }; // ---- bulk actions --------------------------------------------------------- const toggleBulk = (serviceId: string) => setBulkSelection((current) => current.includes(serviceId) ? current.filter((item) => item !== serviceId) : [...current, serviceId], ); const runBulk = async ( label: string, action: (snapshot: ServiceSnapshot) => Promise, confirmText?: string, ) => { const targets = [...services, ...hiddenSnapshots].filter( (item, index, list) => bulkSelection.includes(item.service.id) && list.findIndex((other) => other.service.id === item.service.id) === index, ); if (!targets.length) return; if (confirmText && !window.confirm(confirmText.replace("{n}", String(targets.length)))) return; clearMessages(); setBulkBusy(true); let failed = 0; for (const item of targets) { try { await action(item); } catch { failed += 1; } } setBulkBusy(false); setBulkSelection([]); if (failed) setError(`${label}: ${failed} van ${targets.length} mislukt.`); else setNotice(`${label}: ${targets.length} service(s) klaar.`); await refresh(); }; // ---- incident lifecycle --------------------------------------------------- const resolveSelectedIncident = async () => { if (!selectedIncident) return; if ( !window.confirm( "Dit incident handmatig oplossen? Als de hoofdoorzaak nog steeds uitgevallen is, opent er bij de volgende controle een nieuw incident.", ) ) return; setIncidentBusy(true); try { const detail = await api.resolveIncident(selectedIncident.id, incidentNote.trim() || undefined); setSelectedIncident(detail.incident); setIncidentDetail(detail); setIncidentNote(""); await refresh(); } catch (err) { setError(err instanceof Error ? err.message : "Incident oplossen mislukt"); } finally { setIncidentBusy(false); } }; const addNoteToIncident = async () => { if (!selectedIncident || !incidentNote.trim()) return; setIncidentBusy(true); try { const detail = await api.addIncidentNote(selectedIncident.id, incidentNote.trim()); setIncidentDetail(detail); setIncidentNote(""); } catch (err) { setError(err instanceof Error ? err.message : "Notitie toevoegen mislukt"); } finally { setIncidentBusy(false); } }; // ---- activity journal ----------------------------------------------------- const loadActivity = useCallback( async (older: boolean) => { setActivityBusy(true); try { const before = older ? activityEvents[activityEvents.length - 1]?.created_at : undefined; const page = await api.events(100, { eventType: activityFamily || undefined, before }); setActivityEvents((current) => (older ? [...current, ...page] : page)); setActivityExhausted(page.length < 100); } catch (err) { setError(err instanceof Error ? err.message : "Activiteit laden mislukt"); } finally { setActivityBusy(false); } }, [activityEvents, activityFamily], ); useEffect(() => { if (panel !== "activity") return; // Loads the journal page for the chosen family when the workspace opens. // eslint-disable-next-line react-hooks/set-state-in-effect void loadActivity(false); // Only a workspace or filter change reloads; paging appends explicitly. // eslint-disable-next-line react-hooks/exhaustive-deps }, [panel, activityFamily]); const loadAlertSettings = useCallback(async () => { // Without the token every read here is a 401, which used to pop the unlock // form open on its own; the panel offers the unlock button instead. if (writeAuth === "admin_token" && !editUnlocked) return; try { const [settings, backupList] = await Promise.all([api.alertSettings(), api.backups()]); setBackups(backupList); setAlertSettings(settings); } catch (err) { // 401 opens the unlock form via AUTH_REQUIRED_EVENT; keep it quiet here. if (!(err instanceof ApiError && err.status === 401)) { setError(err instanceof Error ? err.message : "Instellingen laden mislukt"); } } }, [writeAuth, editUnlocked]); useEffect(() => { if (panel !== "settings") return; // Settings are read when the workspace opens or editing is unlocked. // eslint-disable-next-line react-hooks/set-state-in-effect void loadAlertSettings(); }, [panel, editUnlocked, loadAlertSettings]); const saveAlerts = async (event: FormEvent) => { event.preventDefault(); if (!alertSettings) return; setAlertBusy(true); setAlertMessage(null); try { setAlertSettings(await api.saveAlertSettings(alertSettings, alertToken || undefined)); setAlertToken(""); setAlertMessage("Meldingsinstellingen opgeslagen."); } catch (err) { setAlertMessage(err instanceof Error ? err.message : "Opslaan mislukt"); } finally { setAlertBusy(false); } }; const sendTestAlert = async () => { setAlertBusy(true); setAlertMessage(null); try { const result = await api.testAlert(); setAlertMessage(result.ok ? `Test verstuurd. ${result.detail}` : `Test mislukt: ${result.detail}`); } catch (err) { setAlertMessage(err instanceof Error ? err.message : "Test mislukt"); } finally { setAlertBusy(false); } }; const backupNow = async () => { setBackupBusy(true); setBackupMessage(null); try { const info = await api.createBackup(); setBackups(await api.backups()); setBackupMessage(`Back-up ${info.name} geschreven en gecontroleerd.`); } catch (err) { setBackupMessage(err instanceof Error ? err.message : "Back-up mislukt"); } finally { setBackupBusy(false); } }; const downloadBackup = async (name: string) => { try { const blob = await downloadBackupFile(name); const url = URL.createObjectURL(blob); const anchor = document.createElement("a"); anchor.href = url; anchor.download = name; document.body.append(anchor); anchor.click(); anchor.remove(); window.setTimeout(() => URL.revokeObjectURL(url), 1000); } catch (err) { setBackupMessage(err instanceof Error ? err.message : "Downloaden mislukt"); } }; const restoreFromBackup = async (info: BackupInfo) => { const answer = window.prompt( `${info.name} terugzetten? Elke wijziging sinds ${formatDate(info.created_at)} wordt vervangen. ` + "Eerst wordt een veiligheidsback-up van de huidige gegevens gemaakt. Typ RESTORE om door te gaan.", ); if (answer !== "RESTORE") return; setBackupBusy(true); setBackupMessage(null); try { const safety = await api.restoreBackup(info.name); setBackups(await api.backups()); setBackupMessage(`${info.name} teruggezet. De vorige gegevens zijn bewaard als ${safety.name}.`); await refresh(); } catch (err) { setBackupMessage(err instanceof Error ? err.message : "Terugzetten mislukt"); } finally { setBackupBusy(false); } }; const updateAlert = (key: K, value: AlertSettings[K]) => setAlertSettings((current) => (current ? { ...current, [key]: value } : current)); const renderSettings = () => (
Instellingen

Incidentmeldingen (ntfy)

{writeAuth === "admin_token" && !editUnlocked ? (

Meldingsinstellingen en back-ups vragen het beheerderstoken.

) : !alertSettings ? (

Instellingen laden…

) : (
void saveAlerts(event)}> {alertMessage &&

{alertMessage}

}
)}

Back-ups

{backups === null ? (

{writeAuth === "admin_token" && !editUnlocked ? "Ontgrendel bewerken om back-ups te beheren." : "Back-ups laden…"}

) : ( <>

Gecontroleerde kopieën in /data/backups, dagelijks geschreven en geroteerd. Bij terugzetten wordt eerst een veiligheidskopie van de huidige gegevens bewaard.

{backupMessage &&

{backupMessage}

}
    {backups.map((item) => (
  • {formatDate(item.created_at)} {item.kind === "pre-restore" ? "Voor een terugzetting" : "Back-up"} ·{" "} {formatNumber(item.size_bytes / 1024 / 1024, 1)} MB
  • ))} {!backups.length &&
  • Nog geen back-ups.
  • }
)}
); const renderActivity = () => (
Activiteit

Gebeurtenissenlogboek

{groupActivity(activityEvents).map((day) => (

{day.label}

    {day.rows.map((row) => { const meta = eventMeta(row.type); const Icon = ACTIVITY_ICONS[row.type] ?? Circle; const rowServices = row.serviceIds .map((id) => serviceById.get(id)?.service) .filter((item): item is NonNullable => Boolean(item)); return (
  1. {meta.label} {row.count > 1 && ×{row.count}} {row.message} {rowServices.length > 0 && ( {rowServices.slice(0, 6).map((service) => ( ))} {rowServices.length > 6 && ( +{rowServices.length - 6} meer )} )}
  2. ); })}
))}
{!activityEvents.length && !activityBusy &&

Geen gebeurtenissen geregistreerd.

} {!activityExhausted && activityEvents.length > 0 && ( )}
); const renderEdgeInspector = () => { if (!selectedEdge) return null; const source = services.find( (item) => item.service.id === selectedEdge.source_service_id, )?.service; const target = selectedEdge.target_service_id ? services.find( (item) => item.service.id === selectedEdge.target_service_id, )?.service : null; return (
Relatie-inspector

{source?.name ?? "Onbekend"} →{" "} {target?.name ?? selectedEdge.target_ref ?? "Onbekend"}

{selectedEdge.active ? "actief" : "inactief"}
Richting
{source?.name ?? selectedEdge.source_service_id} hangt af van{" "} {target?.name ?? selectedEdge.target_ref ?? "unknown"}
Zekerheid
{selectedEdge.confidence}
Bewijs
{selectedEdge.evidence_type}
Vergrendeld
{selectedEdge.locked ? "Ja" : "Nee"}
Eerst gezien
{formatDate(selectedEdge.first_seen_at)}
Laatst gezien
{formatDate(selectedEdge.last_seen_at)}

{selectedEdge.explanation}

); }; const renderInspector = () => (
Inspector

{selected?.service.name ?? "Selecteer een service"}

{selected && ( {" "} {statusLabel(effectiveStatus(selected))} )}
{!selected ? (

Selecteer een node om gezondheid, geschiedenis, afhankelijkheden en incidentcontext te bekijken.

) : ( <>
Waarom {statusLabel(effectiveStatus(selected))} nu? {selected.health_resolution.explanation || "Er is geen actuele verklaring voor de gezondheid beschikbaar."} {selected.health_resolution.selected_provider?.replaceAll("_", " ") ?? "Geen geselecteerd bewijs"} {selected.health_resolution.selected_evidence_id ? ` · ${formatDate(selected.health_evidence.find((item) => item.id === selected.health_resolution.selected_evidence_id)?.observed_at)}` : ""}
{panel === "topology" && !nodes.some((node) => node.id === selected.service.id) && (

De geselecteerde service valt buiten dit grafiekniveau. Open de applicatie of gebruik Services om de component in context te bekijken.

)} {selectedIsRootCause && (
Waarschijnlijke hoofdoorzaak {demo?.affected_count ?? selectedIncident?.affected_service_ids.length ?? 0}{" "} afhankelijke services worden geraakt. {( demo?.affected_service_names ?? selectedIncident?.affected_service_names ?? [] ).join(" · ")}
)} {!selectedIsRootCause && impactIds.has(selected.service.id) && (
Impact via afhankelijkheid Deze service wordt geraakt via de huidige hoofdoorzaak.
)} {!hasCurrentNetworkProbe(selected) && (
{monitoringLabel(selected.service.monitoring_state)} {selected.service.monitoring_state === "docker_health" ? "Docker levert het huidige gezondheidssignaal; er is geen netwerkcontrole ingesteld." : selected.service.monitoring_state === "appops_observation" ? "AppOps levert een alleen-lezen gezondheidswaarneming van de applicatie; er is geen netwerkcontrole ingesteld." : selected.service.monitoring_state === "observed" ? "De Docker-runtime wordt waargenomen, maar er is geen gecontroleerd extern bereikbaar endpoint gevonden." : "Voor deze service is geen actueel bewakingssignaal ingesteld."} {selected.service.probe_reachability === "internal_only" && ( Bewijs van interne Docker-endpoints wordt bewaard voor detectie en nooit als actieve controle gebruikt. )}
)}
Effectieve gezondheid
{" "} {statusLabel(effectiveStatus(selected))}
Directe gezondheid
{" "} {statusLabel(selected.direct_status)}
Bewaking
{selected.service.monitoring_state.replace("_", " ")} ·{" "} {selected.service.probe_source.replace("_", " ")}
Bereikbaarheid
{selected.service.probe_reachability.replace("_", " ")} ·{" "} {selected.service.probe_confidence}
Runtime
{selected.service.runtime_state ?? "—"} {selected.service.runtime_health ? ` · ${selected.service.monitoring_state === "appops_observation" ? "AppOps" : "Docker"} ${selected.service.runtime_health}` : ""}
Applicatie
{selected.service.application ?? selected.service.group ?? "—"}
Doel
{selected.service.url ?? `${selected.service.host ?? "—"}${selected.service.port ? `:${selected.service.port}` : ""}`}
Controle
{selected.service.kind.toUpperCase()} ·{" "} {hasCurrentNetworkProbe(selected) && selected.latest_probe?.latency_ms != null ? `${selected.latest_probe.latency_ms} ms` : selected.latest_probe ? "Historische controlegegevens" : "—"}
{hasCurrentNetworkProbe(selected) ? "Laatste controle" : "Controlegeschiedenis"}
{selected.latest_probe ? `${hasCurrentNetworkProbe(selected) ? "Actueel" : "Historisch"} · ${formatDate(selected.latest_probe.checked_at)}` : "—"}
Volgende gepland
{hasCurrentNetworkProbe(selected) ? formatDate(selected.next_probe_at) : "Geen actieve controle"}
Beschikbaarheid
{hasCurrentNetworkProbe(selected) && hasCurrentHistory && availability[24]?.uptime_percent != null ? `${availability[24]?.uptime_percent}% (24h)` : selected.latest_probe ? "Historische controlegegevens" : "—"}
7d / 30d
{hasCurrentNetworkProbe(selected) && hasCurrentHistory ? `${availability[168]?.uptime_percent ?? "—"}% / ${availability[720]?.uptime_percent ?? "—"}%` : "Niet actueel"}
Storingen / herstel
{selected.service.failure_streak} /{" "} {selected.service.recovery_streak}
Afhankelijkheden
{selected.service.depends_on.length}
Directe afhankelijken
{directDependents.get(selected.service.id)?.length ?? 0}
Groep / omgeving
{selected.service.group ?? "—"} /{" "} {selected.service.environment ?? "—"}
Categorie / levenscyclus
{selected.service.category.replace("_", " ")} /{" "} {selected.service.lifecycle}
Detectiebron
{selected.service.source_type ? `${selected.service.source_type} · ${selected.service.source_ref ?? "—"}` : "Handmatig"}
Laatst gezien
{formatDate(selected.service.last_seen_at)}
{hasCurrentNetworkProbe(selected) && selected.latest_probe &&

{selected.latest_probe.detail}

}
Gezondheidsbewijs {selected.health_resolution.selected_provider ? `${selected.health_resolution.selected_provider} geselecteerd${selected.health_resolution.conflict ? " · tegenstrijdige signalen bewaard" : ""}` : `No current component signal selected · ${selected.health_resolution.reason_code.replaceAll("_", " ")}`} {selected.health_resolution.explanation} {selected.health_evidence.slice(0, 8).map((item) => ( {item.scope} · {item.provider} · {statusLabel(item.status)} · {item.freshness} · {formatNumber(item.confidence * 100)}% · {formatDate(item.observed_at)} ))}
{!!selected.sources.length && (
Bronnen {selected.sources.map((source) => ( {source.source_type}: {source.source_name ?? source.source_id}{" "} · {source.lifecycle} ))}
)} {!!selected.evidence.length && (
Bewijs voor relaties {selected.evidence .filter((item) => item.active) .map((item) => ( {item.confidence} · {item.explanation} ))}
)} {hasCurrentHistory && !!history.length && (
{[...history].reverse().map((item) => (