Files
ServiceMap-Public/frontend/src/App.tsx
T
NuklearRabbit adc2c70c21 ServiceMap: update tests and backend/app (+7 areas)
Public changes compared with the previous published export:
89 files changed.

Affected areas:
- backend/app: 21 files
- dependencies: 5 files
- deployment and CI: 6 files
- documentation: 2 files
- frontend: 3 files
- frontend/src: 20 files
- project files: 1 file
- tests: 30 files
- unraid: 1 file

Changed files:
- Updated: ".env.example"
- Updated: "Dockerfile.unraid"
- Updated: "README.md"
- Updated: "backend/Dockerfile"
- Added: "backend/app/alerts.py"
- Updated: "backend/app/auth.py"
- Added: "backend/app/backups.py"
- Updated: "backend/app/config_io.py"
- Updated: "backend/app/demo.py"
- Updated: "backend/app/discovery.py"
- Updated: "backend/app/discovery_store.py"
- Updated: "backend/app/docker_discovery.py"
- Updated: "backend/app/events.py"
- Updated: "backend/app/evidence.py"
- Updated: "backend/app/health.py"
- Updated: "backend/app/incidents.py"
- Added: "backend/app/loops.py"
- Updated: "backend/app/main.py"
- Updated: "backend/app/models.py"
- Updated: "backend/app/observation.py"
- Updated: "backend/app/probes.py"
- Added: "backend/app/response_cache.py"
- Updated: "backend/app/scheduler.py"
- Updated: "backend/app/semantic.py"
- Updated: "backend/app/store.py"
- Updated: "backend/pyproject.toml"
- Updated: "backend/tests/test_api.py"
- Updated: "backend/tests/test_config_io.py"
- Updated: "backend/tests/test_demo.py"
- Updated: "backend/tests/test_discovery_v120.py"
- Updated: "backend/tests/test_health.py"
- Updated: "backend/tests/test_probes.py"
- Updated: "backend/tests/test_scheduler.py"
- Updated: "backend/tests/test_v130_probe_reachability.py"
- Updated: "backend/tests/test_v160_evidence_changes.py"
- Added: "backend/tests/test_v163_alerts.py"
- Added: "backend/tests/test_v163_backups.py"
- Added: "backend/tests/test_v163_data_integrity.py"
- Added: "backend/tests/test_v163_efficiency.py"
- Added: "backend/tests/test_v163_health_performance.py"
- Added: "backend/tests/test_v163_loops.py"
- Added: "backend/tests/test_v163_management.py"
- Added: "backend/tests/test_v163_realtime.py"
- Added: "backend/tests/test_v163_security.py"
- Added: "backend/tests/test_v163_semantic_etag.py"
- Added: "compose.demo.yaml"
- Updated: "compose.yaml"
- Added: "docker-compose.broker.yml"
- Updated: "docker-compose.yml"
- Updated: "docs/ARCHITECTURE.md"
- Added: "frontend/e2e/a11y.spec.ts"
- Updated: "frontend/e2e/demo.spec.ts"
- Updated: "frontend/index.html"
- Updated: "frontend/nginx.conf"
- Updated: "frontend/package-lock.json"
- Updated: "frontend/package.json"
- Updated: "frontend/playwright.config.ts"
- Updated: "frontend/src/App.tsx"
- Updated: "frontend/src/LivingEdge.tsx"
- Added: "frontend/src/activityView.test.ts"
- Added: "frontend/src/activityView.ts"
- Updated: "frontend/src/api.ts"
- Added: "frontend/src/apiAuth.test.ts"
- Added: "frontend/src/components/ActionsMenu.tsx"
- Added: "frontend/src/components/ConfirmDialog.test.tsx"
- Added: "frontend/src/components/ConfirmDialog.tsx"
- Added: "frontend/src/components/StatusIcon.tsx"
- Updated: "frontend/src/demo/DemoWalkthrough.test.ts"
- Updated: "frontend/src/demo/DemoWalkthrough.tsx"
- Added: "frontend/src/elk-worker-url.d.ts"
- Added: "frontend/src/labels.ts"
- Updated: "frontend/src/main.tsx"
- Added: "frontend/src/realtime/refreshPlan.test.ts"
- Added: "frontend/src/realtime/refreshPlan.ts"
- Updated: "frontend/src/realtime/useRealtimeEvents.ts"
- Added: "frontend/src/routing/urlState.test.ts"
- Added: "frontend/src/routing/urlState.ts"
- Updated: "frontend/src/styles.css"
- Added: "frontend/src/topology/GraphListView.test.tsx"
- Added: "frontend/src/topology/GraphListView.tsx"
- Updated: "frontend/src/topology/ServiceNode.tsx"
- Updated: "frontend/src/topology/TopologyCommandBar.tsx"
- Added: "frontend/src/topology/semanticGraph.test.ts"
- Updated: "frontend/src/topology/semanticGraph.ts"
- Added: "frontend/src/topologyLayout.test.ts"
- Updated: "frontend/src/topologyLayout.ts"
- Updated: "package-lock.json"
- Updated: "package.json"
- Updated: "unraid/my-servicemap.xml"

Export provenance/manifests refreshed; excluded from the change summary.

Publish curated ServiceMap source from af46f684e468dffd3a5190e28d3b572d4c26bfd7
2026-11-20 13:51:46 +01:00

4989 lines
186 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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<ServiceInput, "tags"> & {
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<string, number>();
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<string, LucideIcon> = {
"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<Panel, LucideIcon> = {
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<UrlState>(() => parseUrlState(window.location.hash));
const [services, setServices] = useState<ServiceSnapshot[]>([]);
const [loading, setLoading] = useState(true);
const [lastUpdatedAt, setLastUpdatedAt] = useState<Date | null>(null);
const [selectedId, setSelectedId] = useState<string | null>(initialUrl.serviceId);
const [busyId, setBusyId] = useState<string | null>(null);
const [busyAll, setBusyAll] = useState(false);
const [error, setError] = useState<string | null>(null);
const [notice, setNotice] = useState<string | null>(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<Panel>(initialUrl.panel);
const [form, setForm] = useState<ServiceForm>(emptyForm);
const [editingId, setEditingId] = useState<string | null>(null);
// Management: hidden services, bulk selection, maintenance windows, notes.
const [showHidden, setShowHidden] = useState(false);
const [hiddenSnapshots, setHiddenSnapshots] = useState<ServiceSnapshot[]>([]);
const [bulkSelection, setBulkSelection] = useState<string[]>([]);
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<EventRecord[]>([]);
const [activityFamily, setActivityFamily] = useState("");
const [activityBusy, setActivityBusy] = useState(false);
const [activityExhausted, setActivityExhausted] = useState(false);
const [alertSettings, setAlertSettings] = useState<AlertSettings | null>(null);
const [alertToken, setAlertToken] = useState("");
const [alertBusy, setAlertBusy] = useState(false);
const [alertMessage, setAlertMessage] = useState<string | null>(null);
const [backups, setBackups] = useState<BackupInfo[] | null>(null);
const [backupBusy, setBackupBusy] = useState(false);
const [backupMessage, setBackupMessage] = useState<string | null>(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<string | null>(null);
const [formOpen, setFormOpen] = useState(false);
const [history, setHistory] = useState<import("./api").ProbeResult[]>([]);
const [historyServiceId, setHistoryServiceId] = useState<string | null>(null);
const [availability, setAvailability] = useState<
Record<number, AvailabilitySummary | null>
>({ 24: null, 168: null, 720: null });
const [incident, setIncident] = useState<IncidentOverview | null>(null);
const [overview, setOverview] = useState<
import("./api").OverviewSummary | null
>(null);
const [semanticTopology, setSemanticTopology] =
useState<SemanticTopology | null>(null);
const [events, setEvents] = useState<EventRecord[]>([]);
const [demo, setDemo] = useState<DemoState | null>(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<DockerCandidate[]>(
[],
);
const [dockerBusy, setDockerBusy] = useState(false);
const [appopsUrl, setAppopsUrl] = useState("");
const [discoveryRun, setDiscoveryRun] = useState<DiscoveryRun | null>(null);
const [discoveryStatus, setDiscoveryStatus] =
useState<DiscoveryStatus | null>(null);
const [discoveryItems, setDiscoveryItems] = useState<DiscoveryObservation[]>(
[],
);
const [discoverySuggestions, setDiscoverySuggestions] = useState<
TopologySuggestion[]
>([]);
const [discoveryBusy, setDiscoveryBusy] = useState(false);
const [probeRepair, setProbeRepair] = useState<ProbeRepairReport | null>(
null,
);
const [editMode, setEditMode] = useState(false);
const [graphListView, setGraphListView] = useState(false);
const mainRef = useRef<HTMLElement | null>(null);
const [showMiniMap, setShowMiniMap] = useState(false);
const [edgeEvidence, setEdgeEvidence] = useState<RelationEvidence[]>([]);
const [providerStatuses, setProviderStatuses] = useState<ProviderStatus[]>([]);
const [topologySnapshots, setTopologySnapshots] = useState<TopologySnapshot[]>([]);
const [topologyDiff, setTopologyDiff] = useState<TopologyDiff | null>(null);
const [selectedSnapshotId, setSelectedSnapshotId] = useState<string | null>(initialUrl.snapshotId);
const [snapshotCheckedAt, setSnapshotCheckedAt] = useState(0);
const [selectedEdgeId, setSelectedEdgeId] = useState<string | null>(initialUrl.edgeId);
const [search, setSearch] = useState(initialUrl.filters.search);
const [statusFilter, setStatusFilter] = useState<FilterStatus>(
initialUrl.filters.status as FilterStatus,
);
const [monitoringFilter, setMonitoringFilter] = useState<MonitoringFilter>(
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<TopologyMode>(
initialUrl.filters.mode as TopologyMode,
);
const [applicationFilter, setApplicationFilter] = useState("all");
const [componentScope, setComponentScope] = useState<{
label: string;
memberIds: string[];
} | null>(null);
const [topologyLocation, setTopologyLocation] = useState<TopologyLocation>(
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<TopologyLocation, "domainId" | "applicationId">
| ((scope: TopologyLocation) => Pick<TopologyLocation, "domainId" | "applicationId">),
) => {
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<string | null>(null);
const [selectedIncident, setSelectedIncident] =
useState<IncidentRecord | null>(null);
const [incidentDetail, setIncidentDetail] = useState<IncidentDetail | null>(
null,
);
const flowInstance = useRef<ReactFlowInstance<ServiceNode, Edge> | null>(
null,
);
const sidePanelRef = useRef<HTMLElement | null>(null);
const demoFocusApplied = useRef(false);
const [layoutPositions, setLayoutPositions] = useState<
Record<string, { x: number; y: number }>
>({});
const [layoutRoutes, setLayoutRoutes] = useState<
Record<string, { x: number; y: number }[]>
>({});
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<string | null>(null);
useEffect(() => {
selectedIdRef.current = selectedId;
}, [selectedId]);
const refreshersRef = useRef({ refreshCore, refreshDiscovery, refreshProviders });
useEffect(() => {
refreshersRef.current = { refreshCore, refreshDiscovery, refreshProviders };
}, [refreshCore, refreshDiscovery, refreshProviders]);
const schedulerRef = useRef<RefreshScheduler | null>(null);
useEffect(() => {
const scheduler = createRefreshScheduler(async ({ scopes, serviceIds }) => {
const { refreshCore: core, refreshDiscovery: discovery, refreshProviders: providers } =
refreshersRef.current;
const tasks: Promise<void>[] = [];
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<string, string[]>();
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<Edge[]>(
() =>
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<Record<string, { x: number; y: number }>>({});
const onNodesChange = useCallback((changes: NodeChange<ServiceNode>[]) => {
const moved: Record<string, { x: number; y: number }> = {};
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<Edge[]>(
() =>
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<HTMLDivElement>) {
// 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<HTMLElement>(".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<string, number>,
),
[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<Record<string, number>>((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<string | null>(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> = {},
): 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<string | null>(
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<unknown>,
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 = <K extends keyof AlertSettings>(key: K, value: AlertSettings[K]) =>
setAlertSettings((current) => (current ? { ...current, [key]: value } : current));
const renderSettings = () => (
<section className="panel-section settings-panel">
<span className="eyebrow">Instellingen</span>
<h2>Incidentmeldingen (ntfy)</h2>
{writeAuth === "admin_token" && !editUnlocked ? (
<div className="locked-note">
<p className="muted">Meldingsinstellingen en back-ups vragen het beheerderstoken.</p>
<button className="primary" onClick={() => setUnlockOpen(true)}>
<LockOpen size={16} aria-hidden="true" />
Bewerken ontgrendelen
</button>
</div>
) : !alertSettings ? (
<p className="muted">Instellingen laden…</p>
) : (
<form className="settings-form" onSubmit={(event) => void saveAlerts(event)}>
<label className="checkbox-field">
<input
type="checkbox"
checked={alertSettings.enabled}
onChange={(event) => updateAlert("enabled", event.target.checked)}
/>
Incidentmeldingen versturen
</label>
<label>
ntfy-server
<input
type="url"
value={alertSettings.ntfy_server}
onChange={(event) => updateAlert("ntfy_server", event.target.value)}
/>
</label>
<label>
Topic
<input
value={alertSettings.ntfy_topic}
pattern="[A-Za-z0-9_-]+"
placeholder="servicemap-alerts"
onChange={(event) => updateAlert("ntfy_topic", event.target.value)}
/>
<small>Op een publieke server is de topicnaam het geheim: kies iets dat moeilijk te raden is.</small>
</label>
<label>
Toegangstoken (optioneel)
<input
type="password"
autoComplete="off"
value={alertToken}
placeholder={alertSettings.ntfy_token_set ? "Opgeslagen — laat leeg om te behouden" : "Geen"}
onChange={(event) => setAlertToken(event.target.value)}
/>
</label>
<label>
Melden vanaf ernst
<select
value={alertSettings.min_severity}
onChange={(event) => updateAlert("min_severity", event.target.value as Criticality)}
>
<option value="low">Laag en hoger</option>
<option value="medium">Gemiddeld en hoger</option>
<option value="high">Hoog en hoger</option>
<option value="critical">Alleen kritiek</option>
</select>
</label>
<label>
Wachten voor melden (seconden)
<input
type="number"
min={0}
max={3600}
value={alertSettings.delay_seconds}
onChange={(event) => updateAlert("delay_seconds", Number(event.target.value))}
/>
<small>Incidenten die binnen deze tijd herstellen, blijven stil.</small>
</label>
<label>
Herinneren om de (minuten, 0 = nooit)
<input
type="number"
min={0}
max={1440}
value={alertSettings.reminder_minutes}
onChange={(event) => updateAlert("reminder_minutes", Number(event.target.value))}
/>
</label>
<label className="checkbox-field">
<input
type="checkbox"
checked={alertSettings.notify_resolved}
onChange={(event) => updateAlert("notify_resolved", event.target.checked)}
/>
Ook melden als een incident is opgelost
</label>
<label>
ServiceMap-adres voor links (optioneel)
<input
type="url"
value={alertSettings.public_url}
placeholder="http://127.0.0.1:1253"
onChange={(event) => updateAlert("public_url", event.target.value)}
/>
</label>
{alertMessage && <p className="muted" role="status">{alertMessage}</p>}
<div className="button-row">
<button className="primary" type="submit" disabled={alertBusy}>Opslaan</button>
<button type="button" className="ghost" disabled={alertBusy} onClick={() => void sendTestAlert()}>
Testmelding versturen
</button>
</div>
</form>
)}
<h2>Back-ups</h2>
{backups === null ? (
<p className="muted">
{writeAuth === "admin_token" && !editUnlocked ? "Ontgrendel bewerken om back-ups te beheren." : "Back-ups laden…"}
</p>
) : (
<>
<p className="muted compact">
Gecontroleerde kopieën in /data/backups, dagelijks geschreven en geroteerd. Bij terugzetten wordt eerst een veiligheidskopie van de huidige gegevens bewaard.
</p>
<div className="button-row">
<button disabled={backupBusy} onClick={() => void backupNow()}>
{backupBusy ? "Bezig…" : "Nu back-uppen"}
</button>
</div>
{backupMessage && <p className="muted" role="status">{backupMessage}</p>}
<ul className="backup-list">
{backups.map((item) => (
<li key={item.name}>
<span>
<strong>{formatDate(item.created_at)}</strong>
<small>
{item.kind === "pre-restore" ? "Voor een terugzetting" : "Back-up"} ·{" "}
{formatNumber(item.size_bytes / 1024 / 1024, 1)} MB
</small>
</span>
<button className="ghost compact-button" onClick={() => void downloadBackup(item.name)}>
Downloaden
</button>
<button
className="danger compact-button"
disabled={backupBusy}
onClick={() => void restoreFromBackup(item)}
>
Terugzetten
</button>
</li>
))}
{!backups.length && <li className="muted">Nog geen back-ups.</li>}
</ul>
</>
)}
</section>
);
const renderActivity = () => (
<section className="panel-section activity-panel">
<div className="panel-heading">
<div>
<span className="eyebrow">Activiteit</span>
<h2>Gebeurtenissenlogboek</h2>
</div>
<label>
Type
<select value={activityFamily} onChange={(event) => setActivityFamily(event.target.value)}>
<option value="">Alle gebeurtenissen</option>
<option value="incident.">Incidenten</option>
<option value="service.">Servicestatus en onderhoud</option>
<option value="topology.">Topologiewijzigingen</option>
<option value="flapping.">Wisselvallig</option>
</select>
</label>
</div>
<div className="activity-days">
{groupActivity(activityEvents).map((day) => (
<section key={day.key} className="activity-day" aria-label={day.label}>
<h3>{day.label}</h3>
<ol className="activity-list">
{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<typeof item> => Boolean(item));
return (
<li key={row.id} className={`activity-row tone-${meta.tone}`}>
<time dateTime={row.createdAt}>{timeOf(row.createdAt)}</time>
<span className="activity-icon">
<Icon size={15} aria-hidden="true" />
</span>
<span className="activity-text">
<strong>{meta.label}</strong>
{row.count > 1 && <span className="activity-count">×{row.count}</span>}
<span className="activity-message">{row.message}</span>
</span>
{rowServices.length > 0 && (
<span className="activity-services">
{rowServices.slice(0, 6).map((service) => (
<button
key={service.id}
className="ghost compact-button"
onClick={() => {
setSelectedId(service.id);
setPanel("services");
}}
>
{service.name}
</button>
))}
{rowServices.length > 6 && (
<span className="activity-more">+{rowServices.length - 6} meer</span>
)}
</span>
)}
</li>
);
})}
</ol>
</section>
))}
</div>
{!activityEvents.length && !activityBusy && <p className="muted">Geen gebeurtenissen geregistreerd.</p>}
{!activityExhausted && activityEvents.length > 0 && (
<button className="ghost" disabled={activityBusy} onClick={() => void loadActivity(true)}>
{activityBusy ? "Laden…" : "Oudere gebeurtenissen laden"}
</button>
)}
</section>
);
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 (
<section
className="panel-section edge-inspector"
aria-label="Relatie-inspector"
>
<div className="inspector-title">
<div>
<span className="eyebrow">Relatie-inspector</span>
<h3>
{source?.name ?? "Onbekend"} →{" "}
{target?.name ?? selectedEdge.target_ref ?? "Onbekend"}
</h3>
</div>
<span
className={`health-pill status-${selectedEdge.active ? "healthy" : "unknown"}`}
>
{selectedEdge.active ? "actief" : "inactief"}
</span>
</div>
<dl className="detail-grid">
<div>
<dt>Richting</dt>
<dd>
{source?.name ?? selectedEdge.source_service_id} hangt af van{" "}
{target?.name ?? selectedEdge.target_ref ?? "unknown"}
</dd>
</div>
<div>
<dt>Zekerheid</dt>
<dd>{selectedEdge.confidence}</dd>
</div>
<div>
<dt>Bewijs</dt>
<dd>{selectedEdge.evidence_type}</dd>
</div>
<div>
<dt>Vergrendeld</dt>
<dd>{selectedEdge.locked ? "Ja" : "Nee"}</dd>
</div>
<div>
<dt>Eerst gezien</dt>
<dd>{formatDate(selectedEdge.first_seen_at)}</dd>
</div>
<div>
<dt>Laatst gezien</dt>
<dd>{formatDate(selectedEdge.last_seen_at)}</dd>
</div>
</dl>
<p className="probe-detail">{selectedEdge.explanation}</p>
<div className="button-row wrap">
<button
onClick={() => void handleEdgeAction("confirm")}
disabled={!selectedEdge.active}
>
Bevestigen
</button>
<button
className="ghost"
onClick={() => void handleEdgeAction("lock")}
disabled={!selectedEdge.active || selectedEdge.locked}
>
Vergrendelen
</button>
<button
className="ghost"
onClick={() => void handleEdgeAction("reject")}
disabled={!selectedEdge.active}
>
Afwijzen
</button>
<button
className="danger"
onClick={() => void handleEdgeAction("remove")}
disabled={!selectedEdge.active}
>
Verwijderen
</button>
</div>
</section>
);
};
const renderInspector = () => (
<section className="panel-section inspector-section">
<div className="inspector-title">
<div>
<span className="eyebrow">Inspector</span>
<h3>{selected?.service.name ?? "Selecteer een service"}</h3>
</div>
{selected && (
<span className={`health-pill status-${effectiveStatus(selected)}`}>
<StatusIcon status={effectiveStatus(selected)} />{" "}
{statusLabel(effectiveStatus(selected))}
</span>
)}
</div>
{!selected ? (
<p className="muted compact">
Selecteer een node om gezondheid, geschiedenis, afhankelijkheden en incidentcontext te bekijken.
</p>
) : (
<>
<div className="inspector-callout current-evidence-callout">
<strong>Waarom {statusLabel(effectiveStatus(selected))} nu?</strong>
<span>{selected.health_resolution.explanation || "Er is geen actuele verklaring voor de gezondheid beschikbaar."}</span>
<small>
{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)}`
: ""}
</small>
</div>
{panel === "topology" && !nodes.some((node) => node.id === selected.service.id) && (
<p className="muted compact">De geselecteerde service valt buiten dit grafiekniveau. Open de applicatie of gebruik Services om de component in context te bekijken.</p>
)}
{selectedIsRootCause && (
<div className="inspector-callout root-cause-callout">
<strong>Waarschijnlijke hoofdoorzaak</strong>
<span>
{demo?.affected_count ??
selectedIncident?.affected_service_ids.length ??
0}{" "}
afhankelijke services worden geraakt.
</span>
<small>
{(
demo?.affected_service_names ??
selectedIncident?.affected_service_names ??
[]
).join(" · ")}
</small>
</div>
)}
{!selectedIsRootCause && impactIds.has(selected.service.id) && (
<div className="inspector-callout impacted-callout">
<strong>Impact via afhankelijkheid</strong>
<span>
Deze service wordt geraakt via de huidige hoofdoorzaak.
</span>
</div>
)}
{!hasCurrentNetworkProbe(selected) && (
<div className="inspector-callout observation-callout">
<strong>{monitoringLabel(selected.service.monitoring_state)}</strong>
<span>
{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."}
</span>
{selected.service.probe_reachability === "internal_only" && (
<small>
Bewijs van interne Docker-endpoints wordt bewaard voor detectie en nooit als actieve controle gebruikt.
</small>
)}
</div>
)}
<dl className="detail-grid">
<div>
<dt>Effectieve gezondheid</dt>
<dd className={`status-${effectiveStatus(selected)}`}>
<StatusIcon status={effectiveStatus(selected)} />{" "}
{statusLabel(effectiveStatus(selected))}
</dd>
</div>
<div>
<dt>Directe gezondheid</dt>
<dd>
<StatusIcon status={selected.direct_status} />{" "}
{statusLabel(selected.direct_status)}
</dd>
</div>
<div>
<dt>Bewaking</dt>
<dd>
{selected.service.monitoring_state.replace("_", " ")} ·{" "}
{selected.service.probe_source.replace("_", " ")}
</dd>
</div>
<div>
<dt>Bereikbaarheid</dt>
<dd>
{selected.service.probe_reachability.replace("_", " ")} ·{" "}
{selected.service.probe_confidence}
</dd>
</div>
<div>
<dt>Runtime</dt>
<dd>
{selected.service.runtime_state ?? "—"}
{selected.service.runtime_health
? ` · ${selected.service.monitoring_state === "appops_observation" ? "AppOps" : "Docker"} ${selected.service.runtime_health}`
: ""}
</dd>
</div>
<div>
<dt>Applicatie</dt>
<dd>
{selected.service.application ?? selected.service.group ?? "—"}
</dd>
</div>
<div>
<dt>Doel</dt>
<dd>
{selected.service.url ??
`${selected.service.host ?? "—"}${selected.service.port ? `:${selected.service.port}` : ""}`}
</dd>
</div>
<div>
<dt>Controle</dt>
<dd>
{selected.service.kind.toUpperCase()} ·{" "}
{hasCurrentNetworkProbe(selected) &&
selected.latest_probe?.latency_ms != null
? `${selected.latest_probe.latency_ms} ms`
: selected.latest_probe
? "Historische controlegegevens"
: "—"}
</dd>
</div>
<div>
<dt>{hasCurrentNetworkProbe(selected) ? "Laatste controle" : "Controlegeschiedenis"}</dt>
<dd>
{selected.latest_probe
? `${hasCurrentNetworkProbe(selected) ? "Actueel" : "Historisch"} · ${formatDate(selected.latest_probe.checked_at)}`
: "—"}
</dd>
</div>
<div>
<dt>Volgende gepland</dt>
<dd>{hasCurrentNetworkProbe(selected) ? formatDate(selected.next_probe_at) : "Geen actieve controle"}</dd>
</div>
<div>
<dt>Beschikbaarheid</dt>
<dd>
{hasCurrentNetworkProbe(selected) &&
hasCurrentHistory &&
availability[24]?.uptime_percent != null
? `${availability[24]?.uptime_percent}% (24h)`
: selected.latest_probe
? "Historische controlegegevens"
: "—"}
</dd>
</div>
<div>
<dt>7d / 30d</dt>
<dd>
{hasCurrentNetworkProbe(selected) && hasCurrentHistory
? `${availability[168]?.uptime_percent ?? "—"}% / ${availability[720]?.uptime_percent ?? "—"}%`
: "Niet actueel"}
</dd>
</div>
<div>
<dt>Storingen / herstel</dt>
<dd>
{selected.service.failure_streak} /{" "}
{selected.service.recovery_streak}
</dd>
</div>
<div>
<dt>Afhankelijkheden</dt>
<dd>{selected.service.depends_on.length}</dd>
</div>
<div>
<dt>Directe afhankelijken</dt>
<dd>{directDependents.get(selected.service.id)?.length ?? 0}</dd>
</div>
<div>
<dt>Groep / omgeving</dt>
<dd>
{selected.service.group ?? "—"} /{" "}
{selected.service.environment ?? "—"}
</dd>
</div>
<div>
<dt>Categorie / levenscyclus</dt>
<dd>
{selected.service.category.replace("_", " ")} /{" "}
{selected.service.lifecycle}
</dd>
</div>
<div>
<dt>Detectiebron</dt>
<dd>
{selected.service.source_type
? `${selected.service.source_type} · ${selected.service.source_ref ?? "—"}`
: "Handmatig"}
</dd>
</div>
<div>
<dt>Laatst gezien</dt>
<dd>{formatDate(selected.service.last_seen_at)}</dd>
</div>
</dl>
{hasCurrentNetworkProbe(selected) && selected.latest_probe && <p className="probe-detail">{selected.latest_probe.detail}</p>}
<div className="evidence-list health-evidence-list">
<strong>Gezondheidsbewijs</strong>
<small>
{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("_", " ")}`}
</small>
<small>{selected.health_resolution.explanation}</small>
{selected.health_evidence.slice(0, 8).map((item) => (
<small key={item.id}>
{item.scope} · {item.provider} · {statusLabel(item.status)} · {item.freshness} · {formatNumber(item.confidence * 100)}% · {formatDate(item.observed_at)}
</small>
))}
</div>
{!!selected.sources.length && (
<div className="evidence-list">
<strong>Bronnen</strong>
{selected.sources.map((source) => (
<small key={source.id}>
{source.source_type}: {source.source_name ?? source.source_id}{" "}
· {source.lifecycle}
</small>
))}
</div>
)}
{!!selected.evidence.length && (
<div className="evidence-list">
<strong>Bewijs voor relaties</strong>
{selected.evidence
.filter((item) => item.active)
.map((item) => (
<small key={item.id}>
{item.confidence} · {item.explanation}
</small>
))}
</div>
)}
{hasCurrentHistory && !!history.length && (
<div
className="history-strip"
title="Controlegeschiedenis, van oud naar nieuw"
role="img"
aria-label={historySummary(history)}
>
{[...history].reverse().map((item) => (
<i
key={item.id}
className={`history-dot status-${item.status}`}
title={`${item.status} · ${formatDate(item.checked_at)}`}
aria-hidden="true"
/>
))}
</div>
)}
<div className="button-row wrap">
<button
onClick={() => void probe(selected.service.id)}
disabled={
busyId === selected.service.id ||
Boolean(demo?.active) ||
!hasCurrentNetworkProbe(selected)
}
>
{demo?.active
? "Synthetische gegevens"
: busyId === selected.service.id
? "Controleren…"
: hasCurrentNetworkProbe(selected)
? "Nu controleren"
: "Geen actieve controle"}
</button>
{!hasCurrentNetworkProbe(selected) && (
<button className="ghost" onClick={() => beginEdit(selected)}>
Endpoint instellen
</button>
)}
<button className="ghost" onClick={() => beginEdit(selected)}>
Bewerken
</button>
<button className="ghost" onClick={() => void toggleMaintenance()}>
{selected.service.maintenance_enabled
? "Onderhoud beëindigen"
: "Onderhoud"}
</button>
<button className="danger" onClick={() => void removeSelected()}>
Verwijderen
</button>
</div>
{selected.service.maintenance_enabled && selected.maintenance_until && (
<p className="muted compact">
Onderhoud stopt automatisch om {formatDate(selected.maintenance_until)}.
</p>
)}
{maintenanceFormOpen && !selected.service.maintenance_enabled && (
<form className="inline-form" onSubmit={(event) => void startMaintenance(event)}>
<label>
Reden
<input
value={maintenanceReason}
maxLength={240}
placeholder="Gepland onderhoud"
onChange={(event) => setMaintenanceReason(event.target.value)}
/>
</label>
<label>
Duur
<select value={maintenanceMinutes} onChange={(event) => setMaintenanceMinutes(event.target.value)}>
<option value="30">30 minuten</option>
<option value="60">1 uur</option>
<option value="240">4 uur</option>
<option value="1440">24 uur</option>
<option value="0">Tot ik het beëindig</option>
</select>
</label>
<div className="button-row">
<button className="primary" type="submit">Onderhoud starten</button>
<button type="button" className="ghost" onClick={() => setMaintenanceFormOpen(false)}>
Annuleren
</button>
</div>
</form>
)}
</>
)}
</section>
);
const renderServiceForm = () => (
<details
className="panel-section form-section"
open={formOpen}
onToggle={(event) => setFormOpen((event.target as HTMLDetailsElement).open)}
>
<summary className="panel-heading">
<span className="eyebrow">
{editingId ? "Service bewerken" : "Service toevoegen"}
</span>
</summary>
<form className="service-form" onSubmit={(event) => void submit(event)}>
<label>
Naam
<input
required
value={form.name}
onChange={(event) => setForm({ ...form, name: event.target.value })}
/>
</label>
<div className="field-row">
<label>
Controletype
<select
value={form.kind}
onChange={(event) =>
setForm({ ...form, kind: event.target.value as ServiceKind })
}
>
<option value="http">HTTP(S)</option>
<option value="tcp">TCP</option>
<option value="dns">DNS</option>
<option value="tls">TLS-certificaat</option>
</select>
</label>
<label>
Kritiek
<select
value={form.criticality}
onChange={(event) =>
setForm({
...form,
criticality: event.target.value as Criticality,
})
}
>
<option value="low">Laag</option>
<option value="medium">Gemiddeld</option>
<option value="high">Hoog</option>
<option value="critical">Kritiek</option>
</select>
</label>
</div>
{form.kind === "http" ? (
<label>
URL
<input
required
value={form.url}
onChange={(event) =>
setForm({ ...form, url: event.target.value })
}
placeholder="https://service.local/health"
/>
</label>
) : (
<div className="field-row">
<label>
{form.kind === "dns" ? "Hostnaam" : "Host"}
<input
required
value={form.host}
onChange={(event) =>
setForm({ ...form, host: event.target.value })
}
/>
</label>
{form.kind !== "dns" && (
<label>
Port
<input
required
type="number"
min="1"
max="65535"
value={form.port ?? ""}
onChange={(event) =>
setForm({
...form,
port: event.target.value === "" ? undefined : Number(event.target.value),
})
}
/>
</label>
)}
</div>
)}
<div className="field-row">
<label>
Groep
<input
value={form.group}
onChange={(event) =>
setForm({ ...form, group: event.target.value })
}
placeholder="Applicaties"
/>
</label>
<label>
Omgeving
<input
value={form.environment}
onChange={(event) =>
setForm({ ...form, environment: event.target.value })
}
/>
</label>
</div>
<fieldset className="semantic-fields">
<legend>Topologie-identiteit</legend>
<div className="field-row">
<label>
Applicatie
<input
value={form.application ?? ""}
onChange={(event) =>
setForm({
...form,
application: event.target.value,
application_locked: Boolean(event.target.value),
})
}
placeholder="Afgeleid indien leeg"
/>
</label>
<label>
Domein
<input
value={form.domain ?? ""}
onChange={(event) =>
setForm({
...form,
domain: event.target.value,
domain_locked: Boolean(event.target.value),
})
}
placeholder="Afgeleid indien leeg"
/>
</label>
</div>
<div className="field-row">
<label>
Componentrol
<select
value={form.component_role ?? "unknown"}
onChange={(event) =>
setForm({
...form,
component_role: event.target.value as ComponentRole,
component_role_locked: event.target.value !== "unknown",
})
}
>
{(
[
"unknown",
"frontend",
"api",
"database",
"cache",
"proxy",
"worker",
"storage",
"monitoring",
"agent",
"scheduler",
"auxiliary",
] as ComponentRole[]
).map((role) => (
<option key={role} value={role}>
{role}
</option>
))}
</select>
</label>
<p className="muted compact">
Vul een waarde in om de handmatige keuze vast te zetten; laat leeg/onbekend voor de metadata uit detectie.
</p>
</div>
</fieldset>
<div className="field-row">
<label>
Categorie
<select
value={form.category ?? "unknown"}
onChange={(event) =>
setForm({
...form,
category: event.target.value as ServiceInput["category"],
})
}
>
{[
"application",
"database",
"cache",
"proxy",
"monitoring",
"development",
"storage",
"infrastructure",
"background_worker",
"system",
"unknown",
].map((item) => (
<option key={item} value={item}>
{item.replace("_", " ")}
</option>
))}
</select>
</label>
<label>
Zichtbaarheid
<select
value={form.visibility ?? "visible"}
onChange={(event) =>
setForm({
...form,
visibility: event.target.value as ServiceInput["visibility"],
})
}
>
<option value="visible">Zichtbaar</option>
<option value="hidden">Verborgen</option>
<option value="ignored">Genegeerd</option>
</select>
</label>
</div>
<label>
Beschrijving
<input
value={form.description}
onChange={(event) =>
setForm({ ...form, description: event.target.value })
}
/>
</label>
<label>
Tags
<input
value={form.tags}
onChange={(event) => setForm({ ...form, tags: event.target.value })}
placeholder="api, customer-facing"
/>
</label>
<div className="field-row">
<label>
Interval (s)
<input
type="number"
min="1"
value={form.interval_seconds ?? ""}
onChange={(event) =>
setForm({
...form,
interval_seconds: event.target.value
? Number(event.target.value)
: undefined,
})
}
/>
</label>
<label>
Time-out (s)
<input
type="number"
min="0.1"
step="0.1"
value={form.timeout_seconds ?? ""}
onChange={(event) =>
setForm({
...form,
timeout_seconds: event.target.value
? Number(event.target.value)
: undefined,
})
}
/>
</label>
</div>
<div className="field-row">
<label>
Storingsdrempel
<input
type="number"
min="1"
value={form.failure_threshold ?? 1}
onChange={(event) =>
setForm({
...form,
failure_threshold: Number(event.target.value),
})
}
/>
</label>
<label>
Hersteldrempel
<input
type="number"
min="1"
value={form.recovery_threshold ?? 1}
onChange={(event) =>
setForm({
...form,
recovery_threshold: Number(event.target.value),
})
}
/>
</label>
</div>
<fieldset className="dependency-fieldset">
<legend>Afhankelijkheden</legend>
{services
.filter((item) => item.service.id !== editingId)
.map((item) => (
<label className="check-row" key={item.service.id}>
<input
type="checkbox"
checked={form.depends_on.includes(item.service.id)}
onChange={() => toggleDependency(item.service.id)}
/>
{item.service.name}
</label>
))}
{!services.length && (
<span className="muted compact">Nog geen services.</span>
)}
</fieldset>
<div className="button-row">
<button className="primary" type="submit">
{editingId ? "Wijzigingen opslaan" : "Service toevoegen"}
</button>
{editingId && (
<button type="button" className="ghost" onClick={resetForm}>
Annuleren
</button>
)}
</div>
</form>
</details>
);
const renderOverview = () => (
<div className="overview-grid">
<section className="panel-section overview-lead">
<span className="eyebrow">Service-inzicht</span>
<h2>
{demo?.active
? "Northstar-incident in één oogopslag"
: "Operationeel overzicht"}
</h2>
<p className="muted">
{demo?.active
? "Synthetische gegevens tonen hoe één onbeschikbare afhankelijkheid zich door een productietopologie verspreidt."
: "Een compact beeld van de echte infrastructuurtopologie, gezondheidsbewijs en actieve incidenten."}
</p>
<div className="summary-cards">
<button onClick={() => { setStatusFilter("all"); setPanel("services"); }}>
<strong>{services.length}</strong>
<span>zichtbare services</span>
</button>
<button className="status-healthy" onClick={() => { setStatusFilter("healthy"); setPanel("services"); }}>
<strong>{counts.healthy ?? 0}</strong>
<span>gezond</span>
</button>
<button className="status-degraded" onClick={() => { setStatusFilter("degraded"); setPanel("services"); }}>
<strong>{counts.degraded ?? 0}</strong>
<span>verminderd</span>
</button>
<button className="status-down" onClick={() => { setStatusFilter("down"); setPanel("services"); }}>
<strong>{counts.down ?? 0}</strong>
<span>uitgevallen</span>
</button>
</div>
{(overview?.total_services ?? services.length) > services.length && (
<p className="muted compact">{(overview?.total_services ?? services.length) - services.length} verborgen services zijn uitgesloten van dit operationele overzicht.</p>
)}
{!!providerStatuses.length && (
<div className="provider-statuses" aria-label="Bronnen van gezondheidsgegevens">
{providerStatuses.map((provider) => (
<small key={provider.provider} className={`status-${provider.status}`}>
{providerText(provider.provider)}: {providerHealthText(provider.status)}
</small>
))}
</div>
)}
</section>
<section className="panel-section overview-incident">
<span className="eyebrow">Incidentbeeld</span>
<h3>
{incident?.active
? `${incident.candidates.length} waarschijnlijke ${incident.candidates.length === 1 ? "hoofdoorzaak" : "hoofdoorzaken"}`
: "Geen actief incident"}
</h3>
{incident?.candidates.length ? (
<div className="candidate-list overview-root-list">
{incident.candidates.map((candidate) => (
<button key={candidate.service_id} className="candidate" onClick={() => {
const record = incident.incidents.find((item) =>
item.root_service_id === candidate.service_id && item.status !== "resolved");
if (record) void openIncident(record);
else { setSelectedId(candidate.service_id); setPanel("topology"); }
}}>
<strong>{candidate.service_name}</strong>
<small>Raakt {candidate.affected_service_ids.length} afhankelijke services</small>
<small>{candidate.reason}</small>
</button>
))}
</div>
) : (
<p className="muted compact">
Gezonde afhankelijkheidsgrafiek. Gebeurtenissen verschijnen hier zodra de status wijzigt.
</p>
)}
</section>
<section className="panel-section coverage-overview">
<div className="panel-heading">
<div>
<span className="eyebrow">Bewakingsdekking</span>
<h3>
{services.length
? `${resolvedComponentCount}/${services.length} met actueel gezondheidsbewijs`
: "Nog geen services"}
</h3>
</div>
<button
className="ghost"
onClick={() => {
setStatusFilter("unresolved");
setMonitoringFilter("all");
setPanel("services");
}}
disabled={unresolvedComponentCount === 0}
>
Onopgeloste nakijken
</button>
</div>
<div className="coverage-breakdown">
{(
[
"active_probe",
"docker_health",
"appops_observation",
"observed",
"unmonitored",
] as MonitoringState[]
).map((state) => (
<div key={state}>
<strong>{coverageCounts[state] ?? 0}</strong>
<span>{monitoringLabel(state)}</span>
</div>
))}
</div>
<p className="muted compact">
{unresolvedComponentCount} services hebben nog een onopgeloste gezondheid. Runtimewaarneming bevestigt alleen dat iets draait, niet dat het gezond is. Actieve controles vragen een gecontroleerd endpoint.
</p>
</section>
<section className="panel-section discovery-overview">
<span className="eyebrow">Infrastructuurdetectie</span>
<h3>
{discoverySuggestions.length
? `${discoverySuggestions.length} open bevindingen over alle runs`
: "Detectie is bijgewerkt"}
</h3>
<p className="muted compact">
{discoveryRun
? `Meest recente run ${formatDate(discoveryRun.completed_at ?? discoveryRun.started_at)}: ${discoveryRun.diff.new} nieuw, ${discoveryRun.diff.changed} gewijzigd en ${discoveryRun.diff.missing} ontbrekend in die run.`
: "Voer een detectie uit om Docker- en AppOps-waarnemingen met de canonieke topologie te vergelijken."}
</p>
<div className="button-row wrap">
<button onClick={() => setPanel("discovery")}>Detectie openen</button>
{!demo?.active && (
<button
className="ghost"
onClick={() => void runProductionDiscovery()}
disabled={discoveryBusy}
>
Nu uitvoeren
</button>
)}
</div>
</section>
<section className="panel-section event-panel">
<div className="panel-heading">
<span className="eyebrow">Recente gebeurtenissen</span>
<button className="text-button" onClick={() => setPanel("incidents")}>
Logboek openen
</button>
</div>
<div className="event-list">
{(overview?.recent_events ?? events.slice(0, 8)).map((item) => (
<div className="event-row" key={item.id}>
<span className="event-dot" />
<div>
<strong>{item.message}</strong>
<small>{formatDate(item.created_at)}</small>
</div>
</div>
))}
{!(overview?.recent_events.length || events.length) && (
<div className="empty-inline">Nog geen gebeurtenissen.</div>
)}
</div>
</section>
</div>
);
const renderIncidents = () => (
<div className="incident-workspace">
<section className="panel-section incident-list-panel">
<div className="panel-heading">
<div>
<span className="eyebrow">Blijvend incidentlogboek</span>
<h3>
{incident?.active
? "Actieve en eerdere incidenten"
: "Incidentgeschiedenis"}
</h3>
</div>
<span className="health-pill">
{incident?.incidents.length ?? 0} items
</span>
</div>
<div className="review-filters">
<label>Incidenten zoeken<input value={incidentSearch} onChange={(event) => setIncidentSearch(event.target.value)} placeholder="Service of oorzaak" /></label>
<label>Status<select value={incidentStatusFilter} onChange={(event) => setIncidentStatusFilter(event.target.value)}>
<option value="active">Actief</option><option value="all">Alle</option><option value="open">Open</option><option value="acknowledged">Bevestigd</option><option value="resolved">Opgelost</option>
</select></label>
</div>
<p className="muted compact">Toont {visibleIncidents.length} van {incident?.incidents.length ?? 0} items.</p>
<div className="candidate-list">
{visibleIncidents.map((item) => (
<button
className={`candidate incident-card ${item.status}`}
key={item.id}
onClick={() => void openIncident(item)}
>
<div className="incident-card-top">
<span
className={`health-pill status-${item.status === "resolved" ? "healthy" : item.status === "acknowledged" ? "degraded" : "down"}`}
>
{item.status}
</span>
<span>{item.severity}</span>
</div>
<strong>{item.title}</strong>
<small>Hoofdoorzaak · {item.root_service_name}</small>
<small>
{item.affected_service_ids.length} afhankelijke geraakt · gestart{" "}
{formatDate(item.started_at)}
</small>
</button>
))}
{!visibleIncidents.length && (
<div className="empty-inline">Geen incidenten voor deze filters.</div>
)}
</div>
</section>
<section className="panel-section incident-detail-panel">
{incidentDetail ? (
<>
<span className="eyebrow">Incidenttijdlijn</span>
<h3>{incidentDetail.incident.title}</h3>
<div className="button-row wrap">
<span
className={`health-pill status-${incidentDetail.incident.status === "resolved" ? "healthy" : incidentDetail.incident.status === "acknowledged" ? "degraded" : "down"}`}
>
{incidentDetail.incident.status}
</span>
{incidentDetail.incident.status === "open" && (
<button className="primary" onClick={() => void acknowledge()}>
Incident bevestigen
</button>
)}
{incidentDetail.incident.status !== "resolved" && (
<button className="ghost" disabled={incidentBusy} onClick={() => void resolveSelectedIncident()}>
Oplossen
</button>
)}
<button
className="ghost"
onClick={() => {
setPanel("topology");
setBlastRadius(true);
}}
>
Impact tonen
</button>
</div>
<p className="muted compact">
{incidentDetail.incident.root_cause_reason}
</p>
<div className="inline-form">
<label>
Notitie
<textarea
rows={2}
maxLength={2000}
value={incidentNote}
placeholder="Wat heb je gevonden of gewijzigd?"
onChange={(event) => setIncidentNote(event.target.value)}
/>
</label>
<button
className="ghost"
disabled={incidentBusy || !incidentNote.trim()}
onClick={() => void addNoteToIncident()}
>
Notitie toevoegen
</button>
</div>
<div className="timeline">
{incidentDetail.timeline.map((item) => (
<div className="timeline-row" key={item.id}>
<span className="timeline-line" />
<div>
<strong>{item.message}</strong>
<small>{formatDate(item.created_at)}</small>
</div>
</div>
))}
</div>
</>
) : (
<p className="muted compact">
Selecteer een incident om de hoofdoorzaak, bevestiging, tijdlijn en impact te bekijken.
</p>
)}
</section>
</div>
);
// Latency and 24h columns only earn their space when some service has a
// current network probe; otherwise every cell would read "—".
const tableHasMetrics = tableServices.some((item) => hasCurrentNetworkProbe(item) || item.latest_probe);
const renderServicesTable = () => (
<div className="services-workspace">
<section className="panel-section table-panel">
<div className="table-toolbar">
<label className="search-field">
Zoeken
<input
value={search}
onChange={(event) => setSearch(event.target.value)}
placeholder="Naam, tag of beschrijving"
/>
</label>
<label className="checkbox-field">
<input
type="checkbox"
checked={showHidden}
onChange={(event) => {
setShowHidden(event.target.checked);
setBulkSelection([]);
}}
/>
Verborgen en genegeerde tonen
</label>
<label>
Status
<select
value={statusFilter}
onChange={(event) =>
setStatusFilter(event.target.value as FilterStatus)
}
>
<option value="all">Alle statussen</option>
<option value="problems">Problemen (uitgevallen, verminderd, herstellend)</option>
<option value="unresolved">Onopgeloste gezondheid</option>
{(
[
"healthy",
"degraded",
"down",
"recovering",
"unknown",
"unmonitored",
"maintenance",
] as HealthStatus[]
).map((item) => (
<option key={item} value={item}>
{statusLabel(item)}
</option>
))}
</select>
</label>
<label>
Bewaking
<select
value={monitoringFilter}
onChange={(event) =>
setMonitoringFilter(event.target.value as MonitoringFilter)
}
>
<option value="all">Elke bron</option>
{(
[
"active_probe",
"docker_health",
"appops_observation",
"observed",
"unmonitored",
] as MonitoringState[]
).map((item) => (
<option key={item} value={item}>
{monitoringLabel(item)}
</option>
))}
</select>
</label>
<label>
Groep
<select
value={groupFilter}
onChange={(event) => setGroupFilter(event.target.value)}
>
<option value="all">Alle groepen</option>
{groups.map((item) => (
<option key={item}>{item}</option>
))}
</select>
</label>
<label>
Omgeving
<select
value={environmentFilter}
onChange={(event) => setEnvironmentFilter(event.target.value)}
>
<option value="all">Alle omgevingen</option>
{environments.map((item) => (
<option key={item}>{item}</option>
))}
</select>
</label>
<label>
Kritiek
<select
value={criticalityFilter}
onChange={(event) => setCriticalityFilter(event.target.value)}
>
<option value="all">Alle kritiekniveaus</option>
{(["low", "medium", "high", "critical"] as Criticality[]).map(
(item) => (
<option key={item} value={item}>
{item}
</option>
),
)}
</select>
</label>
<button className="primary toolbar-end"
type="button"
onClick={() => {
resetForm();
setSelectedId(null);
setFormOpen(true);
}}
>
<Plus size={16} aria-hidden="true" />
Service toevoegen
</button>
</div>
{bulkSelection.length > 0 && (
<div className="bulk-bar" role="region" aria-label="Bulkacties">
<strong>{bulkSelection.length} geselecteerd</strong>
<button
className="ghost compact-button"
disabled={bulkBusy}
onClick={() =>
void runBulk("Onderhoud gestart", (item) =>
api.maintenance(item.service.id, true, "Bulkonderhoud"),
)
}
>
Onderhoud starten
</button>
<button
className="ghost compact-button"
disabled={bulkBusy}
onClick={() => void runBulk("Onderhoud beëindigd", (item) => api.maintenance(item.service.id, false))}
>
Onderhoud beëindigen
</button>
<button
className="ghost compact-button"
disabled={bulkBusy}
onClick={() => void runBulk("Gecontroleerd", (item) => api.probeService(item.service.id))}
>
Nu controleren
</button>
<button
className="ghost compact-button"
disabled={bulkBusy}
onClick={() =>
void runBulk("Verborgen", (item) =>
api.updateService(item.service.id, payloadFromService(item.service, { visibility: "hidden" })),
)
}
>
Verbergen
</button>
<button
className="ghost compact-button"
disabled={bulkBusy}
onClick={() =>
void runBulk("Getoond", (item) =>
api.updateService(
item.service.id,
payloadFromService(item.service, { visibility: "visible", lifecycle: "active" }),
),
)
}
>
Tonen
</button>
<button
className="danger compact-button"
disabled={bulkBusy}
onClick={() =>
void runBulk(
"Verwijderd",
(item) => api.deleteService(item.service.id),
"{n} services en hun controlegeschiedenis verwijderen? Afhankelijke services verliezen deze afhankelijkheden. Dit kan niet ongedaan worden gemaakt.",
)
}
>
Verwijderen
</button>
<button className="ghost compact-button" onClick={() => setBulkSelection([])}>
Wissen
</button>
</div>
)}
<div className={`service-table${tableHasMetrics ? "" : " no-metrics"}`}>
<div className="service-row-wrap">
<input
type="checkbox"
aria-label="Alle getoonde services selecteren"
checked={tableServices.length > 0 && tableServices.every((item) => bulkSelection.includes(item.service.id))}
onChange={(event) =>
setBulkSelection(event.target.checked ? tableServices.map((item) => item.service.id) : [])
}
/>
<div className="service-table-head">
<span>Service</span>
<span>Applicatie</span>
<span>Runtime</span>
<span>Bewaking</span>
<span>Gezondheid</span>
<span>Latentie</span>
<span>24h</span>
</div>
</div>
{tableServices.map((item) => (
<div className="service-row-wrap" key={item.service.id}>
<input
type="checkbox"
aria-label={`${item.service.name} selecteren`}
checked={bulkSelection.includes(item.service.id)}
onChange={() => toggleBulk(item.service.id)}
/>
<button
className="service-table-row"
key={item.service.id}
aria-pressed={selectedId === item.service.id}
onClick={() => setSelectedId(item.service.id)}
>
<span>
<strong>{item.service.name}</strong>
<small>
{item.service.group ?? "Zonder groep"} ·{" "}
{item.service.environment ?? "—"} · {criticalityText(item.service.criticality)}
{item.service.visibility !== "visible" ? ` · ${item.service.visibility}` : ""}
{item.service.lifecycle !== "active" ? ` · ${item.service.lifecycle}` : ""}
</small>
</span>
<span>
{item.service.application ?? item.service.group ?? "—"}
</span>
<span>
{item.service.runtime_state ?? "—"}
{item.service.runtime_health
? ` · ${item.service.runtime_health}`
: ""}
</span>
<span className="monitoring-cell">
{monitoringLabel(item.service.monitoring_state)}
<small>{item.service.probe_source.replace("_", " ")}</small>
</span>
<span className={`status-${effectiveStatus(item)}`}>
<StatusIcon status={effectiveStatus(item)} />{" "}
{statusLabel(effectiveStatus(item))}
</span>
<span>
{hasCurrentNetworkProbe(item) && item.latest_probe?.latency_ms != null
? `${item.latest_probe.latency_ms} ms`
: "—"}
</span>
<span>
{hasCurrentNetworkProbe(item) && item.availability_24h?.uptime_percent != null
? `${formatNumber(item.availability_24h.uptime_percent, 1)}%`
: item.latest_probe
? "Historisch"
: "—"}
</span>
</button>
</div>
))}
{loading && !services.length ? (
<div className="table-skeleton" role="status">
{Array.from({ length: 6 }, (_, index) => (
<span key={index} className="skeleton-row" aria-hidden="true" />
))}
<span className="sr-only">Services laden…</span>
</div>
) : (
!tableServices.length && (
<div className="empty-inline">
Geen services voor de huidige filters.
</div>
)
)}
</div>
</section>
{(selected || formOpen) && (
<aside className="service-drawer" aria-label="Servicedetails">
<div className="drawer-header">
<span className="eyebrow">Servicedetails</span>
<button
className="ghost"
onClick={() => {
setSelectedId(null);
resetForm();
}}
>
Sluiten
</button>
</div>
{selected && renderInspector()}
{formOpen && renderServiceForm()}
</aside>
)}
</div>
);
const renderDiscovery = () => {
const diff = discoveryRun?.diff;
const currentRun = discoveryStatus?.current;
return (
<div className="discovery-workspace">
<section className="panel-section discovery-panel">
<span className="eyebrow">Productie-infrastructuur</span>
<h2>Ontdek de echte omgeving</h2>
<p className="muted compact">
Read-only discovery inspects Docker metadata and optional AppOps
enrichment. A run records observations and suggestions; it does not
change the canonical topology until you explicitly reconcile it.
</p>
<div className="field-row">
<label>
Docker-host
<input
value={dockerHost}
onChange={(event) => setDockerHost(event.target.value)}
placeholder="unix:///var/run/docker.sock"
/>
</label>
<label>
AppOps-URL
<input
value={appopsUrl}
onChange={(event) => setAppopsUrl(event.target.value)}
placeholder="optionele alleen-lezen-URL"
/>
</label>
</div>
<div className="button-row wrap">
<button className="primary"
onClick={() => void runProductionDiscovery()}
disabled={discoveryBusy}
>
{discoveryBusy ? "Detecteren…" : "Detectie uitvoeren"}
</button>
<button
className="ghost"
onClick={() => void refreshDiscovery()}
disabled={discoveryBusy}
>
Status vernieuwen
</button>
<button
className="ghost"
onClick={() => void discoverDocker()}
disabled={dockerBusy}
>
Voorbeeld Docker-kandidaten
</button>
</div>
{currentRun && (
<p className="notice-inline">
Detectie is momenteel {currentRun.status}.
</p>
)}
{discoveryRun && (
<div className="discovery-summary">
<div>
<strong>{discoveryRun.status}</strong>
<span>laatste run</span>
</div>
<div>
<strong>{diff?.new ?? 0}</strong>
<span>nieuw</span>
</div>
<div>
<strong>{diff?.changed ?? 0}</strong>
<span>gewijzigd</span>
</div>
<div>
<strong>{diff?.missing ?? 0}</strong>
<span>ontbrekend</span>
</div>
<div>
<strong>{diff?.new_suggestions ?? 0}</strong>
<span>nieuwe voorstellen</span>
</div>
</div>
)}
<div className="discovery-callout">
<strong>De canonieke topologie is bewust.</strong>
<span>
Services en relaties met hoge zekerheid importeer je expliciet. Netwerkhints met lage zekerheid blijven alleen ter controle en beïnvloeden de gezondheid nooit.
</span>
</div>
<div className="probe-safety-callout">
<strong>Bewakingsdekking herstellen</strong>
<span>
Published endpoints are preflighted before activation. Container-only
Docker DNS is discovery evidence only; AppOps, Docker health and
runtime observations retain their own provenance.
</span>
<div className="button-row wrap">
<button
className="ghost"
onClick={() => void repairDiscoveredProbes(true)}
disabled={discoveryBusy || !discoveryRun}
>
Voorbeeld dekkingsherstel
</button>
<button
onClick={() => void repairDiscoveredProbes(false)}
disabled={
discoveryBusy || !probeRepair || probeRepair.dry_run === false || probeRepair.changed === 0
}
>
Gecontroleerde wijzigingen toepassen
</button>
</div>
{probeRepair && (
<small>
{probeRepair.dry_run ? "Voorbeeld" : "Toegepast"} ·{" "}
{probeRepair.changed} gewijzigd · {probeRepair.disabled_unsafe}{" "}
onveilig uitgeschakeld · {probeRepair.enabled_published} gepubliceerde endpoints gecontroleerd · {probeRepair.docker_health_observed} Docker-gezondheid · {probeRepair.appops_observed} AppOps ·{" "}
{probeRepair.runtime_observed} runtime waargenomen ·{" "}
{probeRepair.unmonitored} niet bewaakt
</small>
)}
{!!probeRepair?.changes.length && (
<div className="coverage-change-list">
{probeRepair.changes.slice(0, 12).map((change) => (
<div key={change.service_id}>
<strong>{change.service_name}</strong>
<small>
{monitoringLabel(change.next_monitoring_state)} ·{" "}
{change.next_probe_source
? change.next_probe_source.replace("_", " ")
: "geen bron"}
{change.next_endpoint ? ` · ${change.next_endpoint}` : ""}
{change.next_probe_confidence
? ` · ${change.next_probe_confidence}`
: ""}
</small>
<small>{change.reason}</small>
</div>
))}
</div>
)}
</div>
<div className="button-row wrap">
<button
onClick={() => setReconcileConfirm(true)}
disabled={
discoveryBusy ||
!discoveryRun ||
discoveryRun.status !== "completed"
}
>
Import nakijken
</button>
<span className="muted compact">
{discoverySuggestions.length} open voorstellen ·{" "}
{discoveryItems.length} waarnemingen
</span>
</div>
<ConfirmDialog
open={reconcileConfirm}
title="Detectiebevindingen importeren?"
confirmLabel="Import toepassen"
onConfirm={() => void reconcileProduction()}
onCancel={() => setReconcileConfirm(false)}
busy={discoveryBusy}
>
<p>Laatste run: {formatDate(discoveryRun?.completed_at ?? discoveryRun?.started_at)}. {discoveryRun?.diff.new ?? 0} nieuw en {discoveryRun?.diff.changed ?? 0} gewijzigde kandidaten; {discoverySuggestions.filter((item) => ["high", "confirmed"].includes(item.confidence)).length} open voorstellen met hoge zekerheid. Verwerken kan ook de levenscyclus bijwerken en ontbrekende services uitfaseren. Kijk de kandidaten na voor je toepast.</p>
</ConfirmDialog>
</section>
<section className="panel-section suggestion-panel">
<div className="panel-heading">
<div>
<span className="eyebrow">Bewijs nakijken</span>
<h3>Open detectievoorstellen</h3>
</div>
<span className="health-pill">
{discoverySuggestions.length} open
</span>
</div>
<p className="muted compact">
Aanvaard een bevinding pas nadat je het bewijs hebt nagekeken. Afgewezen bevindingen worden bewaard en komen niet bij elke scan terug.
</p>
<div className="review-filters">
<label>Bevindingen zoeken<input value={suggestionSearch} onChange={(event) => { setSuggestionSearch(event.target.value); setSuggestionLimit(30); }} placeholder="Service, bron of bewijs" /></label>
<label>Zekerheid<select value={suggestionConfidence} onChange={(event) => { setSuggestionConfidence(event.target.value); setSuggestionLimit(30); }}><option value="actionable">Hoog + bevestigd</option><option value="all">Alle</option><option value="confirmed">Bevestigd</option><option value="high">Hoog</option><option value="medium">Gemiddeld</option><option value="low">Laag</option></select></label>
<label>Type<select value={suggestionType} onChange={(event) => { setSuggestionType(event.target.value); setSuggestionLimit(30); }}><option value="all">Alle</option><option value="service">Service</option><option value="relation">Relatie</option></select></label>
</div>
<p className="muted compact">Toont {Math.min(suggestionLimit, visibleSuggestions.length)} van {visibleSuggestions.length} overeenkomende bevindingen ({discoverySuggestions.length} open).</p>
<div className="suggestion-list">
{visibleSuggestions.slice(0, suggestionLimit).map((suggestion) => {
const source = services.find(
(item) => item.service.id === suggestion.source_service_id,
)?.service;
const target = services.find(
(item) => item.service.id === suggestion.target_service_id,
)?.service;
return (
<article className="suggestion-card" key={suggestion.id}>
<div className="suggestion-card-heading">
<div>
<span className="eyebrow">
{suggestion.suggestion_type}
</span>
<strong>
{source?.name ??
suggestion.proposed_name ??
suggestion.source_ref ??
"Gevonden item"}
{suggestion.suggestion_type === "relation" && (
<>
{" "}
<span aria-hidden="true">→</span>{" "}
{target?.name ?? suggestion.target_ref ?? "target"}
</>
)}
</strong>
</div>
<span
className={`health-pill status-${suggestion.confidence === "low" ? "unknown" : suggestion.confidence === "medium" ? "degraded" : "healthy"}`}
>
{suggestion.confidence}
</span>
</div>
{suggestion.suggestion_type === "service" && (
<small>
{suggestion.proposed_category.replace("_", " ")} ·{" "}
{suggestion.proposed_url ??
`${suggestion.proposed_host ?? "geen endpoint"}${suggestion.proposed_port ? `:${suggestion.proposed_port}` : ""}`}
</small>
)}
{suggestion.suggestion_type === "relation" && (
<small>
{suggestion.relation_type ?? "relationship"} · pas na aanvaarding een canonieke gezondheidsrelatie
</small>
)}
<div className="evidence-list">
<strong>Bewijs</strong>
{suggestion.evidence.map((item) => (
<small key={item}>{item}</small>
))}
</div>
<div className="button-row wrap">
<button className="primary"
onClick={() =>
void reviewSuggestion(suggestion.id, "accept")
}
disabled={discoveryBusy}
>
Aanvaarden
</button>
<button
className="ghost"
onClick={() =>
void reviewSuggestion(suggestion.id, "reject")
}
disabled={discoveryBusy}
>
Afwijzen
</button>
{suggestion.suggestion_type === "service" && (
<button
className="ghost"
onClick={() => {
const candidate = dockerCandidates.find(
(item) =>
item.stable_source_ref === suggestion.source_ref,
);
if (candidate) prefillDockerCandidate(candidate);
}}
>
Controle bekijken
</button>
)}
</div>
</article>
);
})}
{!visibleSuggestions.length && (
<div className="empty-inline">
Geen bevindingen voor deze filters.
</div>
)}
</div>
{visibleSuggestions.length > suggestionLimit && <button className="ghost show-more" onClick={() => setSuggestionLimit((current) => current + 30)}>30 bevindingen meer tonen</button>}
</section>
<section className="panel-section discovery-observations">
<div className="panel-heading">
<div>
<span className="eyebrow">Waargenomen infrastructuur</span>
<h3>Laatste bronwaarnemingen</h3>
</div>
<span className="health-pill">
{dockerCandidates.length} Docker-kandidaten
</span>
</div>
<div className="observation-list">
{discoveryItems.slice(0, 24).map((item) => (
<div className="observation-row" key={item.id}>
<strong>{item.source_name}</strong>
<span>{item.change_type}</span>
<small>
{item.lifecycle} · {formatDate(item.observed_at)}
</small>
</div>
))}
{!discoveryItems.length && (
<div className="empty-inline">
Nog geen afgeronde detectierun.
</div>
)}
</div>
<details className="candidate-details">
<summary>
Kandidatenlijst tonen ({dockerCandidates.length})
</summary>
<div className="docker-list compact-list">
{dockerCandidates.slice(0, 80).map((candidate) => (
<article
className="docker-card"
key={`${candidate.container_id}-${candidate.stable_source_ref}`}
>
<div>
<strong>{candidate.name}</strong>
<span>
{candidate.category.replace("_", " ")} · {candidate.state}
{candidate.health ? ` · ${candidate.health}` : ""}
</span>
</div>
<small>
{candidate.image} · {candidate.import_state}
</small>
<small>
{candidate.stable_source_ref ?? "geen stabiele identiteit"}
{candidate.compose_project
? ` · compose ${candidate.compose_project}`
: ""}
</small>
{candidate.proxy_route_evidence.map((item) => (
<small key={item}>{item}</small>
))}
{candidate.probe_candidates.map((probe) => (
<small key={`${probe.source}-${probe.url ?? probe.host ?? "none"}-${probe.port ?? ""}`}>
{probe.source.replace("_", " ")} · {probe.reachability}
{probe.url ??
(probe.host
? ` · ${probe.host}${probe.port ? `:${probe.port}` : ""}`
: "")}
{probe.preflight_detail ? ` · ${probe.preflight_detail}` : ""}
</small>
))}
</article>
))}
</div>
</details>
</section>
</div>
);
};
const renderChanges = () => {
const snapshotIndex = topologySnapshots.findIndex((item) => item.id === selectedSnapshotId);
const selectedSnapshot = topologySnapshots[snapshotIndex] ?? topologySnapshots[0];
const previousSnapshot = topologySnapshots[snapshotIndex + 1];
const changes = topologyDiff
? [...topologyDiff.added, ...topologyDiff.changed, ...topologyDiff.removed]
: [];
const inspectChange = (entityId: string, after: Record<string, unknown> | null) => {
const serviceId =
services.some((item) => item.service.id === entityId)
? entityId
: typeof after?.source_service_id === "string"
? after.source_service_id
: null;
if (!serviceId) return;
setSelectedId(serviceId);
setPanel("topology");
setInspectorOpen(true);
};
return (
<section className="panel-section change-intelligence">
<span className="eyebrow">Wijzigingsinzicht</span>
<h3>Topologiebewijs door de tijd</h3>
<p className="muted compact">
Snapshots are compact canonical topology captures. They compare service identity, lifecycle, semantic metadata and dependencies without changing your topology.
</p>
{selectedSnapshot && (
<label className="snapshot-picker">Snapshot vergelijken
<select value={selectedSnapshot.id} onChange={(event) => { setSelectedSnapshotId(event.target.value); setTopologyDiff(null); setChangeLimit(30); }}>
{topologySnapshots.map((item) => <option key={item.id} value={item.id}>{formatDate(item.created_at)} · {item.service_count} services</option>)}
</select>
</label>
)}
{selectedSnapshot && snapshotCheckedAt - new Date(selectedSnapshot.created_at).getTime() > 24 * 60 * 60 * 1000 && (
<p className="notice-inline">This topology snapshot is more than 24 hours old. Snapshots update after discovery reconciliation; current health evidence is shown in Overview and Services. <button className="text-button" onClick={() => setPanel("discovery")}>Detectie openen</button></p>
)}
{selectedSnapshot ? (
<dl className="detail-grid">
<div><dt>Geselecteerde topologiesnapshot</dt><dd>{formatDate(selectedSnapshot.created_at)}</dd></div>
<div><dt>Vergeleken met</dt><dd>{formatDate(previousSnapshot?.created_at)}</dd></div>
<div><dt>Services / relaties</dt><dd>{selectedSnapshot.service_count} / {selectedSnapshot.relationship_count}</dd></div>
<div><dt>Toegevoegd</dt><dd>{topologyDiff?.summary.added ?? 0}</dd></div>
<div><dt>Gewijzigd</dt><dd>{topologyDiff?.summary.changed ?? 0}</dd></div>
<div><dt>Verwijderd</dt><dd>{topologyDiff?.summary.removed ?? 0}</dd></div>
</dl>
) : <p className="muted compact">Na de volgende verwerking wordt een topologiesnapshot gemaakt.</p>}
{changes.length ? (
<>
<p className="muted compact">Toont {Math.min(changeLimit, changes.length)} van {changes.length} wijzigingen. Klap een item open om de gewijzigde velden te bekijken.</p>
<div className="change-list">
{changes.slice(0, changeLimit).map((change) => {
const fields = changedFields(change.before, change.after);
return <details key={`${change.change_type}-${change.entity_type}-${change.entity_id}`} className="change-card">
<summary><strong>{change.name}</strong><small>{change.change_type} {change.entity_type} · {fields.length ? `${fields.length} ${fields.length === 1 ? "veld" : "velden"} gewijzigd` : "item toegevoegd of verwijderd"}</small></summary>
{fields.length > 0 && <div className="change-fields">{fields.map((item) => <div key={item.field}><strong>{item.field.replaceAll("_", " ")}</strong><small>{item.before} → {item.after}</small></div>)}</div>}
{change.after && <button className="ghost" onClick={() => inspectChange(change.entity_id, change.after)}>Bekijken in topologie</button>}
</details>;
})}
</div>
{changes.length > changeLimit && <button className="ghost show-more" onClick={() => setChangeLimit((current) => current + 30)}>30 wijzigingen meer tonen</button>}
</>
) : (
<p className="muted compact">Er is geen topologieverschil geregistreerd tussen de twee laatste snapshots.</p>
)}
</section>
);
};
const renderConfig = () => (
<section className="panel-section config-panel">
<span className="eyebrow">Configuratie v2</span>
<h3>Importeren / exporteren</h3>
<p className="muted compact">
Een import controleert eerst de volledige grafiek in één keer voor hij iets opslaat. Bestaande v1-documenten blijven importeerbaar.
</p>
<div className="field-row">
<label>
Formaat
<select
value={configFormat}
onChange={(event) =>
setConfigFormat(event.target.value as "yaml" | "json")
}
>
<option value="yaml">YAML</option>
<option value="json">JSON</option>
</select>
</label>
<label>
Modus
<select
value={configMode}
onChange={(event) =>
setConfigMode(event.target.value as "merge" | "replace")
}
>
<option value="merge">Samenvoegen</option>
<option value="replace">Vervangen</option>
</select>
</label>
</div>
<label className="config-label">
Configuratie
<textarea
value={configText}
onChange={(event) => setConfigText(event.target.value)}
spellCheck={false}
/>
</label>
<div className="button-row wrap">
<button className="primary" onClick={() => void importConfig()}>Configuratie toepassen</button>
<button className="ghost" onClick={() => void exportConfig("yaml")}>
YAML
</button>
<button className="ghost" onClick={() => void exportConfig("json")}>
JSON
</button>
</div>
</section>
);
return (
<div className={`shell ${demo?.active ? "demo-mode" : ""}`}>
<a className="skip-link" href="#main-content" onClick={(event) => { event.preventDefault(); mainRef.current?.focus(); }}>
Naar inhoud springen
</a>
<header className="topbar">
<div className="topbar-inner">
<div className="brand-lockup">
<img src="/brand/servicemap-mark.svg" alt="" />
<h1>ServiceMap</h1>
</div>
<nav className={`panel-tabs ${navMoreOpen ? "nav-more-open" : ""}`} aria-label="ServiceMap-werkruimtes">
{(
[
"overview",
"topology",
"incidents",
"services",
"discovery",
"changes",
"activity",
"config",
"settings",
] as Panel[]
).map((item) => (
<button
key={item}
className={`${panel === item ? "active" : ""} ${PRIMARY_PANELS.includes(item) ? "" : "nav-secondary"}`}
aria-current={panel === item ? "page" : undefined}
onClick={() => { setPanel(item); setNotice(null); setReconcileConfirm(false); setNavMoreOpen(false); }}
>
{(() => {
const TabIcon = PANEL_ICONS[item];
return <TabIcon size={16} aria-hidden="true" />;
})()}
{item === "incidents" ? (
<>
Incidenten
{incident?.active && (
<>
<span aria-hidden="true"> •</span>
<span className="sr-only"> (actief incident)</span>
</>
)}
</>
) : (
PANEL_LABELS[item]
)}
</button>
))}
<button
className={`nav-more ${PRIMARY_PANELS.includes(panel) ? "" : "active"}`}
aria-expanded={navMoreOpen}
onClick={() => setNavMoreOpen(!navMoreOpen)}
>
<Menu size={16} aria-hidden="true" />
Meer
</button>
</nav>
<div className="topbar-status">
{lastUpdatedAt && (
<span
className={`freshness ${realtimeStatus === "live" ? "" : "is-stale"}`}
title={`Laatst volledig bijgewerkt: ${formatDateTime(lastUpdatedAt)}`}
>
bijgewerkt {formatTime(lastUpdatedAt)}
</span>
)}
<span
className={`live-status live-status-${realtimeStatus}`}
role="status"
aria-live="polite"
>
{realtimeStatus === "live"
? "● Live"
: realtimeStatus === "connecting"
? "Verbinden…"
: "Updates gepauzeerd — opnieuw verbinden"}
</span>
<div className="kpi-chips" role="group" aria-label="Gezondheidsoverzicht">
{(["healthy", "degraded", "down", "unknown"] as HealthStatus[]).map((item) => (
<span key={item} className={`kpi-chip status-${item}`} title={`${counts[item] ?? 0} ${item}`}>
<StatusIcon status={item} />
<strong>{counts[item] ?? 0}</strong>
<span className="sr-only"> {item}</span>
</span>
))}
</div>
</div>
<div className="toolbar">
<button
className="primary"
onClick={() => void probeAll()}
disabled={busyAll || Boolean(demo?.active)}
>
<Zap size={16} aria-hidden="true" />
<span className="toolbar-label">
{demo?.active
? "Synthetische controles"
: busyAll
? "Alles controleren…"
: "Alles controleren"}
</span>
</button>
<ActionsMenu label="Meer acties" footer={<small>ServiceMap v1.6.3</small>}>
{(close) => (
<>
{writeAuth === "admin_token" &&
(editUnlocked ? (
<button className="ghost" onClick={() => { close(); lockEditing(); }}>
<Lock size={16} aria-hidden="true" />
Bewerken vergrendelen
</button>
) : (
<button className="ghost" onClick={() => { close(); setUnlockOpen(true); }}>
<LockOpen size={16} aria-hidden="true" />
Bewerken ontgrendelen
</button>
))}
{demo?.enabled && (
<button
className="ghost"
onClick={() => { close(); void loadDemo(); }}
disabled={demoBusy || loading}
>
<FlaskConical size={16} aria-hidden="true" />
{demo.active ? "Demo opnieuw starten" : "Demo verkennen"}
</button>
)}
<button className="ghost" onClick={() => { close(); void exportConfig("yaml"); }}>
<Download size={16} aria-hidden="true" />
YAML exporteren
</button>
</>
)}
</ActionsMenu>
</div>
</div>
{unlockOpen && (
<form
className="unlock-panel unlock-popover"
aria-label="Bewerken ontgrendelen"
onSubmit={(event) => void unlockEditing(event)}
onKeyDown={(event) => {
if (event.key === "Escape") {
setUnlockOpen(false);
setUnlockError(null);
setUnlockValue("");
}
}}
>
<label>
Beheerderstoken
<input
type="password"
autoComplete="off"
autoFocus
required
value={unlockValue}
onChange={(event) => setUnlockValue(event.target.value)}
/>
</label>
<small>
Wijzigingen vragen het ServiceMap-beheerderstoken. Lees het op de host met{" "}
<code>docker exec servicemap cat /data/admin-token</code>. Het wordt alleen voor dit tabblad bewaard.
</small>
{unlockError && (
<span className="unlock-error" role="alert">
{unlockError}
</span>
)}
<div className="unlock-actions">
<button className="primary" type="submit" disabled={unlockBusy || !unlockValue.trim()}>
{unlockBusy ? "Controleren…" : "Ontgrendelen"}
</button>
<button
type="button"
className="ghost"
onClick={() => {
setUnlockOpen(false);
setUnlockError(null);
setUnlockValue("");
}}
>
Annuleren
</button>
</div>
</form>
)}
</header>
{(incident?.active || realtimeStatus === "offline") && (
<section
className={`status-line ${incident?.active ? "status-line-incident" : "status-line-offline"}`}
aria-label="Huidig operationeel beeld"
>
<strong>
{incident?.active ? "Actief afhankelijkheidsincident" : "Laatst bekende toestand"}
</strong>
<span>
{services.length} services · {resolvedComponentCount} met actueel componentbewijs ·{" "}
{unresolvedComponentCount} onopgelost
</span>
{incident?.active && panel !== "incidents" && (
<button className="text-button" onClick={() => setPanel("incidents")}>
Incidenten bekijken
</button>
)}
</section>
)}
{error && (
<div className="error-banner" role="alert">
{error}
</div>
)}
{notice && (
<div className="notice-banner" role="status">
<span>{notice}</span><button className="text-button" aria-label="Melding sluiten" onClick={() => setNotice(null)}>Sluiten</button>
</div>
)}
{demo?.active && (
<section
className="demo-banner"
role="status"
aria-label="Demoscenario verkennen"
aria-live="polite"
aria-busy={demoBusy}
>
<div>
<span className="eyebrow">
Demoscenario · synthetische bewakingsgegevens
</span>
<strong>PostgreSQL is niet beschikbaar.</strong>
<p>
ServiceMap wijst het aan als waarschijnlijke hoofdoorzaak; het raakt{" "}
{demo.affected_count} afhankelijke services. Selecteer een node om gezondheid en geschiedenis te bekijken.
</p>
</div>
<div className="demo-actions">
<button
className="ghost"
onClick={() => {
setPanel("topology");
setTopologyMode("impact");
setBlastRadius(true);
}}
>
Impact volgen
</button>
<button
className="ghost"
onClick={() => {
const dataDomain = semanticTopology?.domains.find(
(item) => item.name === "Data",
);
if (dataDomain) setTopologyLocation(domainLocation(dataDomain.id));
setPanel("topology");
}}
>
Data verkennen
</button>
<button className="ghost" onClick={() => setPanel("incidents")}>
Incident bekijken
</button>
{demo.enabled && (
<button
className="ghost"
onClick={() => void resetDemo()}
disabled={demoBusy}
>
Demo opnieuw starten
</button>
)}
</div>
<DemoWalkthrough
step={demoStep}
affectedCount={demo.affected_count}
busy={demoBusy}
onStepChange={setDemoWalkthroughStep}
onExit={() => void exitDemo()}
/>
</section>
)}
<ConfirmDialog
open={demoConfirm}
title="De demo vervangt deze topologie tijdelijk."
confirmLabel="Snapshot maken en verkennen"
onConfirm={() => void startDemo()}
onCancel={() => setDemoConfirm(false)}
busy={demoBusy}
>
<p>
Je huidige services, controles, incidenten en gebeurtenissen worden vastgelegd en teruggezet zodra je Demo afsluiten kiest.
</p>
</ConfirmDialog>
<main id="main-content" ref={mainRef} tabIndex={-1} aria-label={`Werkruimte ${PANEL_LABELS[panel]}`}>
{panel === "overview" && renderOverview()}
{panel === "incidents" && renderIncidents()}
{panel === "services" && renderServicesTable()}
{panel === "discovery" && renderDiscovery()}
{panel === "changes" && renderChanges()}
{panel === "activity" && renderActivity()}
{panel === "settings" && renderSettings()}
{panel === "config" && renderConfig()}
{panel === "topology" && (
<>
<TopologyCommandBar
location={topologyLocation}
setLocation={setTopologyLocation}
selectedDomain={selectedDomain ?? null}
selectedApplication={selectedApplication ?? null}
mode={topologyMode}
setMode={setTopologyMode}
setImpact={setBlastRadius}
showImpact={Boolean(demo?.active || selectedIncident)}
search={search}
setSearch={setSearch}
statusFilter={statusFilter}
setStatusFilter={setStatusFilter}
monitoringFilter={monitoringFilter}
setMonitoringFilter={setMonitoringFilter}
groupFilter={groupFilter}
environmentFilter={environmentFilter}
setEnvironmentFilter={setEnvironmentFilter}
criticalityFilter={criticalityFilter}
setCriticalityFilter={setCriticalityFilter}
domainFilter={domainFilter}
setDomainFilter={setDomainFilter}
applicationFilter={serviceApplicationFilter}
setApplicationFilter={setServiceApplicationFilter}
lifecycleFilter={lifecycleFilter}
setLifecycleFilter={setLifecycleFilter}
filtersOpen={filtersOpen}
setFiltersOpen={setFiltersOpen}
domains={domains}
applications={applications}
environments={environments}
activeFilters={activeTopologyFilters}
onFit={() => flowInstance.current?.fitView({ padding: 0.16 })}
onArrange={() => void autoArrangeGraph()}
inspectorOpen={inspectorOpen}
onToggleInspector={() => setInspectorOpen(!inspectorOpen)}
/> <section
className="workspace topology-workspace"
>
<div className="canvas-card">
{loading && !services.length ? (
<div className="graph-skeleton" role="status">
{Array.from({ length: 8 }, (_, index) => (
<span key={index} className="skeleton-card" aria-hidden="true" />
))}
<span className="sr-only">Topologie laden…</span>
</div>
) : services.length ? (
<>
{(
<div className="canvas-toolbar">
<button
className={graphListView ? "compact-button" : "ghost compact-button"}
aria-pressed={graphListView}
onClick={() => setGraphListView(!graphListView)}
>
{graphListView ? "Grafiek tonen" : "Als lijst tonen"}
</button>
{(semanticGraph?.hiddenEdgeCount ?? 0) > 0 && (
<span className="canvas-note">
Toont de sterkste {edges.length} van{" "}
{edges.length + (semanticGraph?.hiddenEdgeCount ?? 0)} relaties op dit niveau
</span>
)}
{topologyLocation.level === "components" && (
<>
{editMode && (
<span className="canvas-note">
Sleep nodes om ze vast te zetten. Trek een lijn van een afhankelijkheid naar de service die ze gebruikt.
</span>
)}
<button
className={editMode ? "compact-button" : "ghost compact-button"}
aria-pressed={editMode}
onClick={() => setEditMode(!editMode)}
>
{editMode ? "Klaar met bewerken" : "Indeling bewerken"}
</button>
</>
)}
</div>
)}
{graphListView ? (
<GraphListView nodes={nodes} edges={edges} onOpen={openGraphNode} />
) : (
<div className="flow-host" onKeyDown={onGraphKeyDown}>
<ReactFlow
nodes={nodes}
edges={edges}
onNodesChange={onNodesChange}
nodeTypes={nodeTypes}
edgeTypes={edgeTypes}
minZoom={0.2}
nodesDraggable={editMode && topologyLocation.level === "components"}
nodesConnectable={editMode && topologyLocation.level === "components"}
onInit={(instance) => {
flowInstance.current = instance;
instance.fitView({ padding: 0.16 });
}}
onNodeClick={(_, node) => openGraphNode(node)}
onNodeMouseEnter={(_, node) => setHoveredNodeId(node.id)}
onNodeMouseLeave={() => setHoveredNodeId(null)}
onPaneClick={() => setSelectedEdgeId(null)}
onEdgeClick={(_, edge) => {
const evidence = edgeEvidence.find(
(item) =>
item.source_service_id === edge.target &&
item.target_service_id === edge.source,
);
setSelectedEdgeId(evidence?.id ?? null);
setInspectorOpen(true);
}}
onConnect={(connection) => void createManualEdge(connection)}
onNodeDragStop={(_, node) =>
void persistNodePosition(node as ServiceNode)
}
>
<Background color="#2a333f" gap={22} size={1.2} />
<Controls />
{showMiniMap && <MiniMap pannable zoomable />}
</ReactFlow>
</div>
)}
</>
) : (
<div className="empty-state">
<strong>Nog geen services</strong>
<span>
Voeg een endpoint toe, importeer een configuratie of verken de synthetische demo.
</span>
</div>
)}
</div>
{inspectorOpen && (selected || selectedEdge) && (
<aside ref={sidePanelRef} className="side-panel topology-drawer" aria-label="Inspector">
<button
className="ghost icon-button drawer-close"
aria-label="Inspector sluiten"
onClick={() => setInspectorOpen(false)}
>
<X size={18} aria-hidden="true" />
</button>
{selectedEdge ? renderEdgeInspector() : renderInspector()}
<div className="graph-tools panel-section">
<div className="panel-heading">
<span className="eyebrow">Topologiebediening</span>
<button
className="ghost"
onClick={() => setInspectorOpen(!inspectorOpen)}
>
{inspectorOpen ? "Inspector verbergen" : "Inspector tonen"}
</button>
</div>
<div className="mode-tabs" aria-label="Topologiemodus">
{(
[
"landscape",
"dependencies",
"impact",
] as TopologyMode[]
).map((mode) => (
<button
key={mode}
className={topologyMode === mode ? "active" : "ghost"}
onClick={() => {
setTopologyMode(mode);
if (mode === "impact") setBlastRadius(true);
else {
setBlastRadius(false);
setComponentScope(null);
if (mode === "landscape") {
setSemanticScope({
domainId: null,
applicationId: null,
});
}
}
}}
>
{mode === "impact"
? "Incidentimpact"
: modeText(mode)}
</button>
))}
</div>
{semanticTopology &&
(semanticScope.domainId || semanticScope.applicationId) && (
<div
className="topology-breadcrumbs"
aria-label="Topologiehiërarchie"
>
<button
className="text-button"
onClick={() => {
setSemanticScope({
domainId: null,
applicationId: null,
});
setTopologyMode("landscape");
}}
>
Domeinen
</button>
{semanticScope.domainId && (
<>
<span>›</span>
<button
className="text-button"
onClick={() =>
setSemanticScope((scope) => ({
...scope,
applicationId: null,
}))
}
>
{semanticTopology.domains.find(
(item) => item.id === semanticScope.domainId,
)?.name ?? "Domein"}
</button>
</>
)}
{semanticScope.applicationId && (
<>
<span>›</span>
<span>
{semanticTopology.applications.find(
(item) => item.id === semanticScope.applicationId,
)?.name ?? "Applicatie"}
</span>
</>
)}
</div>
)}
{topologyLocation.level === "components" && !semanticTopology && (
<>
<label className="scope-label">
{componentScope
? `Landschapsgroep: ${componentScope.label}`
: "Applicatiecomponenten"}
</label>
<select
aria-label="Applicatiecomponenten"
value={applicationFilter}
onChange={(event) => {
setComponentScope(null);
setApplicationFilter(event.target.value);
}}
>
<option value="all">Alle applicaties</option>
{applications.map((item) => (
<option key={item}>{item}</option>
))}
</select>
</>
)}
<div className="button-row wrap">
<button
className={focusMode ? "" : "ghost"}
onClick={() => setFocusMode(!focusMode)}
disabled={
!selectedId ||
topologyLocation.level !== "components" ||
Boolean(semanticTopology)
}
>
Focus op selectie
</button>
<button
className={blastRadius ? "" : "ghost"}
onClick={() => {
setBlastRadius(!blastRadius);
setTopologyMode("impact");
}}
disabled={!demo?.active && !selectedIncident}
>
Impact tonen
</button>
<button
className="ghost"
onClick={() => void autoArrangeGraph()}
>
Automatisch schikken
</button>
<button
className="ghost"
onClick={() =>
flowInstance.current?.fitView({ padding: 0.16 })
}
>
Passend tonen
</button>
<button
className={showMiniMap ? "" : "ghost"}
onClick={() => setShowMiniMap(!showMiniMap)}
>
Minikaart
</button>
</div>
<div className="filter-row">
<input
aria-label="Topologie doorzoeken"
value={search}
onChange={(event) => setSearch(event.target.value)}
placeholder="Alle services doorzoeken"
/>
<select
aria-label="Filter op status"
value={statusFilter}
onChange={(event) =>
setStatusFilter(event.target.value as FilterStatus)
}
>
<option value="all">Alle statussen</option>
{(
[
"healthy",
"degraded",
"down",
"recovering",
"unmonitored",
"unknown",
"maintenance",
] as HealthStatus[]
).map((item) => (
<option key={item} value={item}>
{statusLabel(item)}
</option>
))}
</select>
<select
aria-label="Filter op groep"
value={groupFilter}
onChange={(event) => setGroupFilter(event.target.value)}
>
<option value="all">Alle groepen</option>
{groups.map((item) => (
<option key={item}>{item}</option>
))}
</select>
</div>
<p className="muted compact">
{topologyMode === "landscape"
? semanticScope.domainId
? "Applicatieweergave voor het geselecteerde operationele domein. Selecteer een applicatie om de componenten te bekijken."
: "Het landschap is geordend per operationeel domein. Selecteer een domein om de applicaties te verkennen."
: editMode
? "Sleep componentnodes om hun plaats vast te zetten. Nieuwe semantische relaties worden bevestigd als handmatige afhankelijkheden."
: focusMode
? "Toont twee afhankelijkheidsniveaus rond de geselecteerde service."
: blastRadius
? "Toont de hoofdoorzaak en de impact op afhankelijke services."
: "Pijlen wijzen van een afhankelijkheid naar de service die ervan afhangt. Selecteer een relatie voor het bewijs."}
</p>
<button
className={editMode ? "" : "ghost"}
onClick={() => setEditMode(!editMode)}
disabled={topologyLocation.level !== "components"}
>
{editMode ? "Klaar met bewerken" : "Componenten bewerken"}
</button>
</div>
{formOpen && renderServiceForm()}
</aside>
)}
</section>
</>
)}
</main>
</div>
);
}